如何在Lucene中搜索特殊字符+！\\\\？：

如何解决如何在Lucene中搜索特殊字符+！\\\\？：

|| 我想在索引中搜索特殊字符。 我对查询字符串中的所有特殊字符进行了转义，但是当我对索引中的lucene进行+时，它将查询创建为+（）。 因此，它不搜索任何字段。 如何解决这个问题呢？我的索引包含这些特殊字符。     

解决方法

如果使用的是“ 0”，则将丢弃非字母字符。尝试用ѭ1索引相同的值，看看是否保留了所需的字符。它可能还会保留您不想要的东西：那是您可能考虑编写自己的分析器的时候，这基本上意味着创建一个TokenStream堆栈，该堆栈可以完全执行所需的处理。 例如，“ 2”实现以下管线：

@Override
public TokenStream tokenStream(String fieldName,Reader reader) {
   return new LowerCaseTokenizer(reader);
}

只是小写令牌。

StandardAnalyzer

还有更多功能：

/** Constructs a {@link StandardTokenizer} filtered by a {@link
StandardFilter},a {@link LowerCaseFilter} and a {@link StopFilter}. */
@Override
public TokenStream tokenStream(String fieldName,Reader reader) {
    StandardTokenizer tokenStream = new StandardTokenizer(matchVersion,reader);
    tokenStream.setMaxTokenLength(maxTokenLength);
    TokenStream result = new StandardFilter(tokenStream);
    result = new LowerCaseFilter(result);
    result = new StopFilter(enableStopPositionIncrements,result,stopSet);
    return result;
 }

您可以在

org.apache.lucene.analysis

中混合和匹配这些组件和其他组件，也可以编写自己的专用

TokenStream

实例，这些实例由您的自定义

Analyzer

包装到处理管道中。 要看的另一件事是您使用的是哪种

CharTokenizer

。

CharTokenizer

是一个抽象类，指定用于标记文本字符串的机制。一些更简单的分析器（而不是but0ѭ）使用它。 Lucene带有两个子类：

LetterTokenizer

和

WhitespaceTokenizer

。您可以通过实现ѭ14keep方法来创建自己的字符，以保留所需的字符，并中断不需要的字符。     ,也许这对作者来说不是实际的，但是要能够搜索特殊字符，您需要： 创建自定义分析器 使用它进行索引和搜索 示例如何为我工作：

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.custom.CustomAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.RAMDirectory;
import org.junit.Test;

import java.io.IOException;

import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;

public class LuceneSpecialCharactersSearchTest {

/**
 * Test that tries to search a string by some substring with each special character separately.
 */
@Test
public void testSpecialCharacterSearch() throws Exception {
    // GIVEN
    LuceneSpecialCharactersSearch service = new LuceneSpecialCharactersSearch();
    String[] luceneSpecialCharacters = new String[]{\"+\",\"-\",\"&&\",\"||\",\"!\",\"(\",\")\",\"{\",\"}\",\"[\",\"]\",\"^\",\"\\\"\",\"~\",\"*\",\"?\",\":\",\"\\\\\"};

    // WHEN
    for (String specialCharacter : luceneSpecialCharacters) {
        String actual = service.search(\"list\'s special-characters \" + specialCharacter);

        // THEN
        assertThat(actual,equalTo(LuceneSpecialCharactersSearch.TEXT_WITH_SPECIAL_CHARACTERS));
    }
}

private static class LuceneSpecialCharactersSearch {
    private static final String TEXT_WITH_SPECIAL_CHARACTERS = \"This is the list\'s of special-characters + - && || ! ( ) { } [ ] ^ \\\" ~ ? : \\\\ *\";

    private final IndexWriter writer;

    public LuceneSpecialCharactersSearch() throws Exception {
        Document document = new Document();
        document.add(new TextField(\"body\",TEXT_WITH_SPECIAL_CHARACTERS,Field.Store.YES));

        RAMDirectory directory = new RAMDirectory();
        writer = new IndexWriter(directory,new IndexWriterConfig(buildAnalyzer()));
        writer.addDocument(document);
        writer.commit();
    }

    public String search(String queryString) throws Exception {
        try (IndexReader reader = DirectoryReader.open(writer,false)) {
            IndexSearcher searcher = new IndexSearcher(reader);

            String escapedQueryString = QueryParser.escape(queryString).toLowerCase();

            Analyzer analyzer = buildAnalyzer();
            QueryParser bodyQueryParser = new QueryParser(\"body\",analyzer);
            bodyQueryParser.setDefaultOperator(QueryParser.Operator.AND);


            Query bodyQuery = bodyQueryParser.parse(escapedQueryString);
            BooleanQuery query = new BooleanQuery.Builder()
                    .add(new BooleanClause(bodyQuery,BooleanClause.Occur.SHOULD))
                    .build();
            TopDocs searchResult = searcher.search(query,1);

            return searcher.doc(searchResult.scoreDocs[0].doc).getField(\"body\").stringValue();
        }
    }

    /**
     * Builds analyzer that is used for indexing and searching.
     */
    private static Analyzer buildAnalyzer() throws IOException {
        return CustomAnalyzer.builder()
                .withTokenizer(\"whitespace\")
                .addTokenFilter(\"lowercase\")
                .addTokenFilter(\"standard\")
                .build();

    }
}
}