lucene 搜索详解（4）

╰+攻爆jí腚メ 2023-07-17 04:49 66阅读 0赞

## 搜索流程 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 1][]

## 搜索代码示例 ##

package com.dongsheng.lucene.dslucene.lucene;
    
    import org.apache.lucene.analysis.Analyzer;
    import org.apache.lucene.analysis.core.SimpleAnalyzer;
    import org.apache.lucene.document.Document;
    import org.apache.lucene.index.DirectoryReader;
    import org.apache.lucene.index.IndexReader;
    import org.apache.lucene.queryparser.classic.ParseException;
    import org.apache.lucene.queryparser.classic.QueryParser;
    import org.apache.lucene.search.IndexSearcher;
    import org.apache.lucene.search.Query;
    import org.apache.lucene.search.ScoreDoc;
    import org.apache.lucene.search.TopDocs;
    import org.apache.lucene.store.Directory;
    import org.apache.lucene.store.FSDirectory;
    
    import java.io.IOException;
    import java.nio.file.Paths;
    
    /***
     *@author dongsheng
     *@date 2020/3/19 16:59
     *@version 1.0.0
     *@Description  搜索代码示例
     */
    public class SearchFlow {
    
        public static void main(String[] args) throws IOException, ParseException {
            // 使用的分词器
            Analyzer analyzer = new SimpleAnalyzer();
            // 索引存储目录
            Directory directory = FSDirectory.open(Paths.get("e:/test/indextest"));
            // 索引读取器
            IndexReader indexReader = DirectoryReader.open(directory);
            // 索引搜索器
            IndexSearcher indexSearcher = new IndexSearcher(indexReader);
            // 要搜索的字段
            String filedName = "name";
            // 查询生成器（解析输入生成Query查询对象）
            QueryParser parser = new QueryParser(filedName, analyzer);
            // 通过parse解析输入（分词），生成query对象
            Query query = null;
            try {
                query = parser.parse("Thinkpad");
            } catch (ParseException e) {
                e.printStackTrace();
            }
            // 搜索，得到TopN的结果（结果中有命中总数，topN的scoreDocs（评分文档（文档id，评分）））
            TopDocs topDocs = indexSearcher.search(query, 10);   //前10条
            //获得总命中数
            System.out.println(topDocs.totalHits);
            // 遍历topN结果的scoreDocs,取出文档id对应的文档信息
            for (ScoreDoc sdoc : topDocs.scoreDocs) {
                // 根据文档id取存储的文档
                Document hitDoc = indexSearcher.doc(sdoc.doc);
                // 取文档的字段
                System.out.println(hitDoc.get(filedName));
            }
            // 使用完毕，关闭、释放资源
            indexReader.close();
            directory.close();
        }
    }

## 核心API图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 2][]

## 核心API详解 ##

## **1.IndexReader** ** 索引读取器** ##

Open一个读取器，读取的是该时刻点的索引视图

*  DirectoryReader.open(IndexWriter indexWriter)     
 *  DirectoryReader.open(Directory)
 *  DirectoryReader.openIfChanged(DirectoryReader)

分为两类

![20200319170759380.png][]

*  叶子读取器：支持获取stored fields, doc values, terms（词项）, and postings （词项对应的文档）

*  复合读取器，多个读取器的复合。只可直接用它获取stored fields 。在内部通CompositeReader.getSequentialSubReaders 得到里面的叶子读取器来获取其他数据。
 *  DirectoryReader 是 复合读取器

注：  indexRead是线程安全的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 4][]

## 2.IndexSearcher 索引搜索器 ##

应用通过调用它的search(Query,int)重载方法在一个IndexReader上实现搜索。出于性能的考虑，请使用一个IndexSearcher实例，除非索引发生变化。如索引更新了则通过DirectoryReader.openIfChanged(DirectoryReader)  取得新的读取器，再创建新的搜索器。

注：  IndexSearcher 是线程安全的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 5][]

### TopDocs ###

/** The total number of hits for the query. */
    public long totalHits; 宗命中数
    
    /** The top hits for the query. */
    public ScoreDoc[] scoreDocs; Top-N结果集
    
    /** Stores the maximum score value encountered, needed for normalizing. */
    private float maxScore;取得最大分数

### ScoreDoc ###

/** The score of this document for the query. */
      public float score; 得分值
    
      /** A hit document's number.
       * @see IndexSearcher#doc(int) */
      public int doc; 文档id

## 3.Query查询的实例类 ##

*  TermQuery   词项查询

//词项查询，最基本、最常用的查询。用来查询指定字段包含指定词项的文档
    TermQuery tq = new TermQuery(new Term("fieldName", "term"));

*  BooleanQuery  布尔查询

搜索的条件往往是多个的，如要查询名称包含“电脑” 或 “thinkpad”的商品，就需要两个词项查询做或合并。布尔查询就是用来组合多个子查询的。每个子查询称为布尔字句 BooleanClause，布尔字句自身也可以是组合的。

*  Occur.SHOULD        或
 *  Occur.MUST           且
 *  Occur.MUST\_NOT        且非
 *  Occur.FILTER    同 MUST，但该字句不参与评分

布尔查询默认的最大字句数为1024，在将通配符查询这样的查询rewriter为布尔查询时，往往会产生很多的字句，可能抛出TooManyClauses 异常。可通过BooleanQuery.setMaxClauseCount(int)设置最大字句数。

// 布尔查询
    Query query1 = new TermQuery(new Term(filedName, "thinkpad"));
    Query query2 = new TermQuery(new Term("simpleIntro", "英特尔"));
    BooleanQuery.Builder booleanQueryBuilder = new BooleanQuery.Builder();
    booleanQueryBuilder.add(query1, Occur.SHOULD);
    booleanQueryBuilder.add(query2, Occur.MUST);
    BooleanQuery booleanQuery = booleanQueryBuilder.build();
    
    // 可像下一行这样写
    // BooleanQuery booleanQuery = new BooleanQuery.Builder()
    // 	.add(query1, Occur.SHOULD).add(query2, Occur.MUST).build();

组合关系支持如下四种：

*  WildcardQuery   通配符查询

表示0个或多个字符，?表示1个字符，\\是转义符。通配符查询可能会比较慢，不可以通配符开头。

// WildcardQuery 通配符查询
    WildcardQuery wildcardQuery = new WildcardQuery(
    	new Term("name", "think*"));
    
    // WildcardQuery 通配符查询
    WildcardQuery wildcardQuery2 = new WildcardQuery(
    	new Term("name", "厉害了???"));

*  PhraseQuery  短语查询

最常用的查询，匹配特点序列的多个词项。PhraserQuery使用一个位置移动因子（slop）来决定任意两个词项的位置可最大移动多少个位置来进行匹配，默认为0。有两种方式来构建对象：

1.直接构造方法

2.用里面的Builder构建

PhraseQuery phraseQuery1 = new PhraseQuery("name", "thinkpad",
    	"carbon");
    
    PhraseQuery phraseQuery2 = new PhraseQuery(1, "name", "thinkpad",
    	"carbon");
    
    PhraseQuery phraseQuery3 = new PhraseQuery("name", "笔记本电脑", "联想");
    
    PhraseQuery phraseQuery4 = new PhraseQuery.Builder()
    	.add(new Term("name", "笔记本电脑"), 4)
    	.add(new Term("name", "联想"), 5).build();
    // 这两句等同
    PhraseQuery phraseQuery5 = new PhraseQuery.Builder()
    	.add(new Term("name", "笔记本电脑"), 0)
    	.add(new Term("name", "联想"), 1).build();

slop 移动因子说明

1、如果想用  “thinkpad  carbon” 来匹配 name。因中间有 x1,则需要将thinkpad 向右移动1个位置。

2、如果想用  “carbon  thinkpad” 来匹配 name。因中间有 x1,则需要将carbon 向右移动3个位置。

// String name = "ThinkPad X1 Carbon 20KH0009CD/25CD 超极本轻薄笔记本电脑联想";
    
    // PhraseQuery 短语查询
    PhraseQuery phraseQuery2 = new PhraseQuery(1, "name", "thinkpad","carbon");
    // slop示例
    PhraseQuery phraseQuery2Slop = new PhraseQuery(3, "name", "carbon",	"thinkpad");
    PhraseQuery phraseQuery3 = new PhraseQuery("name", "笔记本电脑", "联想");
    // slop示例
    PhraseQuery phraseQuery3Slop = new PhraseQuery(2, "name", "联想","笔记本电脑");

*  PrefixQuery   前缀查询

查询包含以xxx为前缀的词项的文档，是通配符查询，如 app，实际是 app\*

// PrefixQuery 前缀查询
    PrefixQuery prefixQuery = new PrefixQuery(new Term("name", "think"));

*  MultiPhraseQuery  多重短语查询

短语查询的一种更通用的用法，支持同位置多个词的OR匹配。通过里面的Builder来构建MultiPhraseQuery

// 4 MultiPhraseQuery 多重短语查询
    Term[] terms = new Term[2];
    terms[0] = new Term("name", "笔记本");
    terms[1] = new Term("name", "笔记本电脑");
    Term t = new Term("name", "联想");
    MultiPhraseQuery multiPhraseQuery = new MultiPhraseQuery.Builder()
    	.add(terms).add(t).build();
    
    // 对比 PhraseQuery在同位置加入多个词 ，同位置的多个词都需匹配，所以查不出。
    PhraseQuery pquery = new PhraseQuery.Builder().add(terms[0], 0)
    	.add(terms[1], 0).add(t, 1).build();

*  FuzzyQuery  模糊查询

简单地与索引词项进行相近匹配，允许最大2个不同字符。常用于拼写错误的容错：如把 “thinkpad” 拼成 “thinkppd”或 “thinkd”，使用FuzzyQuery 仍可搜索到正确的结果。

// FuzzyQuery 模糊查询
    FuzzyQuery fuzzyQuery = new FuzzyQuery(new Term("name", "thind"));
    
    FuzzyQuery fuzzyQuery2 = new FuzzyQuery(new Term("name", "thinkd"), 2);
    
    FuzzyQuery fuzzyQuery3 = new FuzzyQuery(new Term("name", "thinkpaddd"));
    
    FuzzyQuery fuzzyQuery4 = new FuzzyQuery(new Term("name", "thinkdaddd"));

*  RegexpQuery  正则表示查询

词项符合某正则表达式

*  TermRangeQuery  词项范围查询

// RegexpQuery 正则表达式查询
    RegexpQuery regexpQuery = new RegexpQuery(new Term("name", "厉害.{4}"));

用于查询包含某个范围内的词项的文档，如以字母开头a到c的词项。词项在反向索引中是排序的，只需指定的开始词项、结束词项，就可以查询该范围的词项。

如果是做数值的范围查询则用 PointRangeQuery 。

// TermRangeQuery 词项范围查询
    TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange("name",
    	"carbon", "张三", false, true);

*  PointRangeQuery  单个或多维点查询
 *  ConstantScoreQuery 
 *  DisjunctionMaxQuery 
 *  MatchAllDocsQuery  匹配所有
 *  数值查询

前提：查询的数值字段必须索引。通过 IntPoint, LongPoint, FloatPoint, or DoublePoint 中的方法构建对应的查询。

![20200319174452713.png][]

// 精确值查询
    Query exactQuery = IntPoint.newExactQuery("price", 1999900);
    
    // 数值范围查询
    Query pointRangeQuery = IntPoint.newRangeQuery("price", 499900,1000000);
    
    // 集合查询
    Query setQuery = IntPoint.newSetQuery("price", 1999900, 1000000,2000000);

*  SpanNearQuery 临近查询（跨度查询）

用于更复杂的短语查询，可以指定词间位置的最大间隔跨度。通过组合一系列的SpanQuery 实例来进行查询，可以指定是否按顺序匹配、slop、gap。

// SpanNearQuery 临近查询
    SpanTermQuery tq1 = new SpanTermQuery(new Term("name", "thinkpad"));
    SpanTermQuery tq2 = new SpanTermQuery(new Term("name", "carbon"));
    SpanNearQuery spanNearQuery = new SpanNearQuery(
    	new SpanQuery[] { tq1, tq2 }, 1, true);
    
    // SpanNearQuery 临近查询 gap slop 使用
    SpanNearQuery.Builder spanNearQueryBuilder = SpanNearQuery
    	.newOrderedNearQuery("name");
    spanNearQueryBuilder.addClause(tq1).addGap(0).setSlop(1)
    	.addClause(tq2);
    SpanNearQuery spanNearQuery5 = spanNearQueryBuilder.build();

## **QueryParser****详解** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 6][]

两类查询解析器

1. 传统的解析器

QueryParser

MultiFieldQueryParser

//传统解析器-单默认字段   QueryParser
    QueryParser parser = new QueryParser("defaultFiled", analyzer);
    //parser.setPhraseSlop(2);
    Query query = parser.parse("query String");
    
    
    
    // 传统查询解析器-多默认字段
    String[] multiDefaultFields = { "name", "type", "simpleIntro" };
    MultiFieldQueryParser multiFieldQueryParser = new MultiFieldQueryParser(
    		multiDefaultFields, analyzer);
    // 设置默认的组合操作，默认是 OR
    multiFieldQueryParser.setDefaultOperator(Operator.OR);
    Query query4 = multiFieldQueryParser.parse("笔记本电脑 AND price:1999900");

2. 基于新的  flexible 框架的解析器

StandardQueryParser

StandardQueryParser queryParserHelper = new StandardQueryParser(analyzer);
    // 设置默认字段
    // queryParserHelper.setMultiFields(CharSequence[] fields);
    // queryParserHelper.setPhraseSlop(8);
    // Query query = queryParserHelper.parse("a AND b", "defaultField");
    Query query5 = queryParserHelper.parse(
    	"(\"联想笔记本电脑\" OR simpleIntro:英特尔) AND type:电脑 AND price:1999900","name");

使用查询解析器需要考虑的三点：

1.  查询字符串应是由人输入的，而不应是你编程产生。如果你为了用查询解析器，而在你的应用中编程产生查询字符串，不  可取，更应该直接使用基本查询API;
2.  未分词的字段，应直接使用基本查询API加入到查询中，而不应使用查询解析器；
3.  对于普通文本字段，使用查询解析器，而其他值字段：如 时间、数值，则应使用基本查询API；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70]: /images/20230528/23c70a74b1df434bb1db108f57e18338.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 1]: /images/20230528/b6b6e2a6bf074abe8790cda45525685a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 2]: /images/20230528/9b5792b623c64093880c18daa1fa6ec2.png
[20200319170759380.png]: /images/20230528/2367df21fca042f1926ad59953a15162.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 3]: /images/20230528/17eaf5731e0743d28afac26ab94d2484.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 4]: /images/20230528/82a11a601b4f4040a5342c1fa7491471.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 5]: /images/20230528/0e76038ceed5453c8864bdc4952ad9a4.png
[20200319174452713.png]: /images/20230528/75a7d5bdd91747fe98f7d14d00a7b269.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkbXhkemI_size_16_color_FFFFFF_t_70 6]: /images/20230528/aea08d5467cd42c5b4e5b225af37adc4.png