lucene 搜索详解（4）

最新推荐文章于 2023-02-12 16:01:02 发布

无怨_无悔

最新推荐文章于 2023-02-12 16:01:02 发布

阅读量317

点赞数

本文链接：https://blog.csdn.net/sdmxdzb/article/details/104971338

版权

搜索流程

搜索代码示例

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图

核心API详解

1.IndexReader 索引读取器

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

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

分为两类

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

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

注： indexRead是线程安全的。

2.IndexSearcher 索引搜索器

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

注： IndexSearcher 是线程安全的。

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 中的方法构建对应的查询。

// 精确值查询
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详解

两类查询解析器

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");

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

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

无怨_无悔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
lucene 搜索详解（4）

搜索流程搜索代码示例package com.dongsheng.lucene.dslucene.lucene;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.analysis.core.SimpleAnalyzer;import org.apache.lucene.document....
复制链接

扫一扫