本文详细介绍了Lucene的查询操作，包括关键词、范围、通配符、模糊和短语查询，以及布尔查询的使用。同时讨论了QueryParser与MultiFieldQueryParser的区别。接着，文章阐述了分词器的重要性和工作流程，如StandardAnalyzer、CJKAnalyzer以及第三方的IKAnalyzer。此外，还讲解了如何通过Boost和Sort调整搜索结果的排序，以及使用Filter进行结果过滤。最后，提到了高亮显示的关键类，并给出了相关代码示例。
Lucene查询：
查询出所有
关键词查询
范围查询
通配符查询
模糊查询
短语查询
布尔查询
QueryParser与MultiFieldQueryParser的区别
QueryParser：只在一个字段中查询
MultiFieldQueryParser：可以在多个字段查询
布尔查询：
public void add(Query query, Occur occur)
Occur 用于表示布尔查询子句关系的类，包括：
Occur.MUST，Occur.MUST_NOT，Occur.SHOULD。
1， MUST和MUST：取得连个查询子句的交集。
2， MUST和MUST_NOT：包含MUST并且查询结果中不包含MUST_NOT的检索结果。
3， SHOULD与SHOULD，表示“或”关系，最终检索结果为所有检索子句的并集。
一般不单独使用，因为单独就不应使用BooleanQuery了。
使用时注意：
1， 单独使用MUST_NOT：无意义，检索无结果。（也不报错）
2， MUST_NOT和MUST_NOT：无意义，检索无结果。（也不报错）
3， 单独使用SHOULD：结果相当于MUST。
4， SHOULD和MUST_NOT： 此时SHOULD相当于MUST，结果同MUST和MUST_NOT。
5， MUST和SHOULD：此时SHOULD无意义，结果为MUST子句的检索结果。
代码示例(utils和bean类可以去上一篇文章中去找)：
package com.my.lucene;
import java.util.ArrayList;
import java.util.List;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.FuzzyQuery;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.NumericRangeQuery;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.util.Version;
import org.junit.Test;
import com.my.bean.Article;
import com.my.utils.ArticleDocumentUtils;
import com.my.utils.Configuration;
public class QueryTest {
@Test
public void searchByString() throws Exception {
// 搜索条件
String queryString = "content:lucene";
// String queryString = "全文 OR 用户";
// String queryString = "全文 AND 用户";
//把查询字符串转为Query对象
QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_30,new String[] { "title", "content" },Configuration.getAnalyzer()); // 在title与content中查询
Query query = queryParser.parse(queryString);
//查询，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(Configuration.getDirectory());
TopDocs topDocs = indexSearcher.search(query, 100); // 按指定条件条询，只返回前n条结束
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
//处理结果
List<Article> list = new ArrayList<Article>();
for (int i = 0; i < scoreDocs.length; i++) {
Document doc = indexSearcher.doc(scoreDocs[i].doc);
list.add(ArticleDocumentUtils.document2Article(doc));
}
indexSearcher.close();
//显示结果
System.out.println("总结果数量为：" + list.size());
for (Article article : list) {
System.out.println("--------> id = " + article.getId());
System.out.println("title = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}
@Test
public void searchByQuery() throws Exception {
Query query = new TermQuery(new Term("title", "lucene"));
// Query query = new TermQuery(new Term("content", "lucene"));
System.out.println("对应的查询字符串为：" + query.toString());
//查询，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(Configuration.getDirectory());
TopDocs topDocs = indexSearcher.search(query, 100); // 按指定条件条询，只返回前n条结束
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
//处理结果
List<Article> list = new ArrayList<Article>();
for (int i = 0; i < scoreDocs.length; i++) {
Document doc = indexSearcher.doc(scoreDocs[i].doc);
list.add(ArticleDocumentUtils.document2Article(doc));
}
indexSearcher.close();
// 显示结果
System.out.println("总结果数量为：" + list.size());
for (Article article : list) {
System.out.println("--------> id = " + article.getId());
System.out.println("title = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}
// 查询出所有文档
@Test
public void testMatchAllDocsQuery() {
// 对应的查询字符串为：*:*
Query query = new MatchAllDocsQuery();
searchByQuery(query);
}
// 关键词查询
@Test
public void testTermQuery() {
// 对应的查询字符串为：title:lucene
Query query = new TermQuery(new Term("title", "lucene"));
searchByQuery(query);
}
// 范围查询
@Test
public void testRangeQuery() {
// 对应的查询字符串为：id:[5 TO 15]
// Query query = NumericRangeQuery.newIntRange("id", 5, 15, true, true);
// 对应的查询字符串为：id:{5 TO 15}
// Query query = NumericRangeQuery.newIntRange("id", 5, 15, false,
// false);
// 对应的查询字符串为：id:[5 TO 15}
Query query = NumericRangeQuery.newIntRange("id", 5, 15, true, false);
searchByQuery(query);
}
// 通配符查询
// ? 代表1个字符
// * 代表0个或多个字符
@Test
public void testWildcardQuery() {
// 对应的查询字符串为：title:lucen?
// Query query = new WildcardQuery(new Term("title", "lucen?"));
// 对应的查询字符串为：title:luce*
Query query = new WildcardQuery(new Term("title", "luce*"));
searchByQuery(query);
}
// 模糊查询
@Test
public void testFuzzyQuery() {
// 对应的查询字符串为：title:lucena~0.5
// Query query = new FuzzyQuery(new Term("title", "lucena"));
// 第2个参数minimumSimilarity（相似度）的取值范围是 0<= minimumSimilarity < 1
// minimumSimilarity（相似度）是指超过多少字母相同就可以查出来。
// 如指定0.7，表示相同的字符超过70%就可以查出来（如果刚好有70%相同则查不出来）
Query query = new FuzzyQuery(new Term("title", "luceneutii"), 0.7F);
searchByQuery(query);
}
// 短语查询
@Test
public void testPhraseQuery() {
// 对应的查询字符串为：title:"lucene ? ? 框架"
PhraseQuery phraseQuery = new PhraseQuery();
// phraseQuery.add(new Term("title", "lucene"), 0); // 指定词的位置，第1个从0开始
// phraseQuery.add(new Term("title", "框架"), 3);
// 对应的查询字符串为：title:"lucene 框架"~5
phraseQuery.add(new Term("title", "lucene"));
phraseQuery.add(new Term("title", "框架"));
phraseQuery.setSlop(5); // 词之间的间隔最多不超过5个
searchByQuery(phraseQuery);
}
// 布尔查询
@Test
public void testBooleanQuery() {
BooleanQuery booleanQuery = new BooleanQuery();
// booleanQuery.add(query, Occur.MUST); // 必须满足
// booleanQuery.add(query, Occur.MUST_NOT); // 非
// booleanQuery.add(query, Occur.SHOULD); // 多个SHOULD一起用是OR的关系
Query query1 = new TermQuery(new Term("title", "lucene"));
Query query2 = NumericRangeQuery.newIntRange("id", 5, 15, false, true);
// // 对应的查询字符串为：+title:lucene +id:{5 TO 15]
// // 对应的查询字符串为：title:lucene AND id:{5 TO 15]
// booleanQuery.add(query1, Occur.MUST);
// booleanQuery.add(query2, Occur.MUST);
// // 对应的查询字符串为：+title:lucene -id:{5 TO 15]
// // 对应的查询字符串为：title:lucene NOT id:{5 TO 15]
// booleanQuery.add(query1, Occur.MUST);
// booleanQuery.add(query2, Occur.MUST_NOT);
// 对应的查询字符串为：title:lucene id:{5 TO 15]
// 对应的查询字符串为：title:lucene OR id:{5 TO 15]
booleanQuery.add(query1, Occur.SHOULD);
booleanQuery.add(query2, Occur.SHOULD);
// 以下三种组合不要使用
// MUST 与 SHOULD，只有MUST的结果（这时的SHOULD相当于没有指定）
// MUST_NOT 与 MUST_NOT，没有结果，也不会报错
// MUST_NOT 与 SHOULD，这时SHOULD相当于MUST，他的条件必须满足，即相当于MUST与MUST_NOT的效果
// 可以使用括号
// 对应的查询字符串为：+(title:lucene OR content:lucene) +id:{5 TO 15]
searchByQuery(booleanQuery);
}
//查询并显示结果
private void searchByQuery(Query query) {
try {
System.out.println(" //对应的查询字符串为：" + query.toString());
//查询，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(Configuration.getDirectory());
TopDocs topDocs = indexSearcher.search(query, 100); // 按指定条件条询，只返回前n条结束
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
//处理结果
List<Article> list = new ArrayList<Article>();
for (int i = 0; i < scoreDocs.length; i++) {
Document doc = indexSearcher.doc(scoreDocs[i].doc);
list.add(ArticleDocumentUtils.document2Article(doc));
}
indexSearcher.close();
//显示结果
System.out.println("总结果数量为：" + list.size());
for (Article article : list) {
System.out.println("--------> id = " + article.getId());
System.out.println("title = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
分词器
分词器的作用
在创建索引时会用到分词器，在使用字符串搜索时也会用到分词器，这两个地方要使用同一个分词器，否则可能会搜索不出结果。
Analyzer（分词器）的作用是把一段文本中的词按规则取出所包含的所有词。对应的是Analyzer类，这是一个抽象类，切分词的具体规则是由子类实现的，所以对于不同的语言（规则），要用不同的分词器
英文）分词器的一般工作流程：
1， 切分关键词
2， 去除停用词
3，对于英文单词，把所有字母转为小写（搜索时不区分大小写）
停用词：
有些词在文本中出现的频率非常高，但是对文本所携带的信息基本不产生影响，例如英文的“a、an、the、of”，或中文的“的、了、着”，以及各种标点符号等，这样的词称为停用词（stop word）。文本经过分词之后，停用词通常被过滤掉，不会被进行索引。在检索的时候，用户的查询中如果含有停用词，检索系统也会将其过滤掉（因为用户输入的查询字符串也要进行分词处理）。排除停用词可以加快建立索引的速度，减小索引库文件的大小。
自带标准的分词器其核心类为StandardAnalyzer
另外还有单字分词 ChineseAnalyzer
二分法分词 CJKAnalyzer
还有第三方的分词器如IKAnalyzer
中文分词器使用IKAnalyzer，主页：http://www.oschina.net/p/ikanalyzer。
实现了以词典为基础的正反向全切分，以及正反向最大匹配切分两种方法。IKAnalyzer是第三方实现的分词器，继承自Lucene的Analyzer类，针对中文文本进行处理。具体的使用方式参见其文档。
代码示例：
package com.my.lucene;
import java.io.StringReader;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.cjk.CJKAnalyzer;
import org.apache.lucene.analysis.cn.ChineseAnalyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.analysis.tokenattributes.TermAttribute;
import org.apache.lucene.util.Version;
import org.junit.Test;
import org.wltea.analyzer.lucene.IKAnalyzer;
public class AnalyzerTest {
@Test
public void test() throws Exception{
// 英文分词
String text = "An IndexWriter creates and maintains an index.";
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);
testAnalyzer(analyzer, text);
// 中文分词
String text2 = "传智播客的Lucene是全文检索的框架";
testAnalyzer(new ChineseAnalyzer(), text2); // 单字分词
testAnalyzer(new CJKAnalyzer(Version.LUCENE_30), text2); // 二分法分词
testAnalyzer(new IKAnalyzer(), text2); // 词库分词
testAnalyzer(new IKAnalyzer(), text); // 词库分词
}
/**
* 使用指定的分词器对指定的文本进行分词，并打印出分出的词
*
* @param analyzer
* @param text
* @throws Exception
*/
private void testAnalyzer(Analyzer analyzer, String text) throws Exception {
System.out.println("当前使用的分词器：" + analyzer.getClass());
TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(text));
tokenStream.addAttribute(TermAttribute.class);
while (tokenStream.incrementToken()) {
TermAttribute termAttribute = tokenStream.getAttribute(TermAttribute.class);
System.out.println(termAttribute.term());
}
System.out.println();
}
}
分词器配置文件
IKAnalyzer.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>IK Analyzer 扩展配置</comment>
<!--用户可以在这里配置自己的扩展字典-->
<entry key="ext_dict">/mydict.dic</entry>
<!--用户可以在这里配置自己的扩展停止词字典-->
<entry key="ext_stopwords">/ext_stopword.dic</entry>
</properties>
mydict.dic
全文检索
ext_stopword.dic
就
并
很
或
把
是
的
着
给
而
被
让
在
还
比
等
当
与
于
但
注意：查询必须使用与建立索引库相同的分词器。
排序
通过改变文档Boost值来改变排序结果。Boost是指索引建立过程中，给整篇文档或者文档的某一特定属性设定的权值因子，在检索时，优先返回分数高的。通过Document对象的setBoost()方法和Field对象的setBoost()方法，可以分别为Document和Field指定Boost参数。不同在于前者对文档中每一个域都修改了参数，而后者只针对指定域进行修改。默认情值为1F，一般不做修改。
使用Sort对象定制排序。Sort支持的排序功能以文档当中的域为单位，通过这种方法，可以实现一个或者多个不同域的多形式的值排序。时间类型的属性采用STRING常量。
按相关度排序
1，相关度得分是在查询时根据查询条件实进计算出来的
2，如果索引库据不变，查询条件不变，查出的文档得分也不变
按指定的字段排序
利用Field.Index.NOT_ANALYZED.
代码示例：
package com.my.lucene;
import java.util.ArrayList;
import java.util.List;
import org.apache.lucene.document.Document;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.util.Version;
import org.junit.Test;
import com.my.bean.Article;
import com.my.utils.ArticleDocumentUtils;
import com.my.utils.Configuration;
import com.my.utils.LuceneUtils;
public class SortTest {
@Test
public void createIndex() throws Exception {
// 模拟一条刚保存到数据库中的数据
Article article = new Article();
article.setId(31);
article.setTitle("Lucene是全文检索的框架");
article.setContent("如果信息检索系统在用户发出了检索请求后再去互联网上找答案，根本无法在有限的时间内返回用户。");
// 建立索引
Document doc = ArticleDocumentUtils.article2Document(article);
doc.setBoost(0.5F); // 使用boost影响相关度得分，默认值为1F
LuceneUtils.getIndexWriter().addDocument(doc);
}
@Test
public void search1() throws Exception {
// 搜索条件
String queryString = "用户";
// 1，把查询字符串转为Query对象
QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_30, new String[] { "title", "content" }, Configuration.getAnalyzer()); // 在title与content中查询
Query query = queryParser.parse(queryString);
// 2，查询，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(Configuration.getDirectory());
TopDocs topDocs = indexSearcher.search(query, 100); // 按指定条件条询，只返回前n条结束
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
// 3，处理结果
List<Article> list = new ArrayList<Article>();
for (int i = 0; i < scoreDocs.length; i++) {
System.out.println(scoreDocs[i].score); // 相关度得分
// 根据编号取出真正的Document数据
Document doc = indexSearcher.doc(scoreDocs[i].doc);
// 把Document转成Article
Article article = ArticleDocumentUtils.document2Article(doc);
list.add(article);
}
indexSearcher.close();
// 显示结果
System.out.println("总结果数量为：" + list.size());
for (Article article : list) {
System.out.println("--------> id = " + article.getId());
System.out.println("title = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}
@Test
public void search2() throws Exception {
// 搜索条件
String queryString = "用户";
// 进行搜索，得到结果 ？
// 1，把查询字符串转为Query对象
QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_30, new String[] { "title", "content" }, Configuration.getAnalyzer()); // 在title与content中查询
Query query = queryParser.parse(queryString);
// 2，查询，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(Configuration.getDirectory());
// TopDocs topDocs = indexSearcher.search(query, 100); // 按指定条件条询，只返回前n条结束
// ====================================================================
// indexSearcher.search(query, n);
// indexSearcher.search(query, filter, n);
// indexSearcher.search(query, filter, n, sort);
// 指定排序的字段
Sort sort = new Sort(new SortField("id", SortField.INT)); // 按id升序排列
// Sort sort = new Sort(new SortField("id", SortField.INT, true)); // 按id降序排列
TopDocs topDocs = indexSearcher.search(query, null, 100, sort);
// ====================================================================
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
// 3，处理结果
List<Article> list = new ArrayList<Article>();
for (int i = 0; i < scoreDocs.length; i++) {
System.out.println(scoreDocs[i].score); // 相关度得分
// 根据编号取出真正的Document数据
Document doc = indexSearcher.doc(scoreDocs[i].doc);
// 把Document转成Article
Article article = ArticleDocumentUtils.document2Article(doc);
list.add(article);
}
indexSearcher.close();
// 显示结果
System.out.println("总结果数量为：" + list.size());
for (Article article : list) {
System.out.println("--------> id = " + article.getId());
System.out.println("title = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}
}
过滤
使用Filter 可以对搜索结果进行过滤以获得更小范围的结果。使用Filter对性能的影响很大（有可能会使查询慢上百倍）。
代码示例：
package com.my.lucene;
import java.util.ArrayList;
import java.util.List;
import org.apache.lucene.document.Document;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.NumericRangeFilter;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.util.Version;
import org.junit.Test;
import com.my.bean.Article;
import com.my.utils.ArticleDocumentUtils;
import com.my.utils.Configuration;
public class FilterTest {
@Test
public void search() throws Exception {
// 搜索条件
String queryString = "用户";
// 1，把查询字符串转为Query对象
QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_30, new String[] { "title", "content" }, Configuration.getAnalyzer()); // 在title与content中查询
Query query = queryParser.parse(queryString);
// 2，查询，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(Configuration.getDirectory());
// TopDocs topDocs = indexSearcher.search(query, 100); // 按指定条件条询，只返回前n条结束
// indexSearcher.search(query, n);
// indexSearcher.search(query, filter, n);
// indexSearcher.search(query, filter, n, sort);
// 指定过滤的条件
Filter filter = NumericRangeFilter.newIntRange("id", 1, 15, true, true);
TopDocs topDocs = indexSearcher.search(query, filter, 100);
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
// 3，处理结果
List<Article> list = new ArrayList<Article>();
for (int i = 0; i < scoreDocs.length; i++) {
System.out.println(scoreDocs[i].score); // 相关度得分
// 根据编号取出真正的Document数据
Document doc = indexSearcher.doc(scoreDocs[i].doc);
// 把Document转成Article
Article article = ArticleDocumentUtils.document2Article(doc);
list.add(article);
}
indexSearcher.close();
// 显示结果
System.out.println("总结果数量为：" + list.size());
for (Article article : list) {
System.out.println("--------> id = " + article.getId());
System.out.println("title = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}
}
高亮
高亮的核心类为
org.apache.lucene.search.highlight.Formatter
org.apache.lucene.search.highlight.Highlighter
org.apache.lucene.search.highlight.Scorer
代码示例：
package com.my.lucene;
import java.util.ArrayList;
import java.util.List;
import org.apache.lucene.document.Document;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.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.search.highlight.Formatter;
import org.apache.lucene.search.highlight.Highlighter;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.search.highlight.Scorer;
import org.apache.lucene.search.highlight.SimpleFragmenter;
import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
import org.apache.lucene.util.Version;
import org.junit.Test;
import com.my.bean.Article;
import com.my.utils.ArticleDocumentUtils;
import com.my.utils.Configuration;
public class HighlighterTest {
@Test
public void search() throws Exception {
// 搜索条件
String queryString = "用户";
// 1，把查询字符串转为Query对象
QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_30, new String[] { "title", "content" }, Configuration.getAnalyzer()); // 在title与content中查询
Query query = queryParser.parse(queryString);
// 2，查询，得到中间结果
IndexSearcher indexSearcher = new IndexSearcher(Configuration.getDirectory());
TopDocs topDocs = indexSearcher.search(query, 100); // 按指定条件条询，只返回前n条结束
ScoreDoc[] scoreDocs = topDocs.scoreDocs; // 前n条结果的信息
// 创建并配置高亮器（前缀、后缀、摘要大小）
Formatter formatter = new SimpleHTMLFormatter("<font color='red'>", "</font>"); // 指定前缀与后缀，默认使用<b>与</b>
Scorer scorer = new QueryScorer(query);
Highlighter highlighter = new Highlighter(formatter, scorer);
highlighter.setTextFragmenter(new SimpleFragmenter(20)); // 指定摘要大小，默认是100个字符
// 3，处理结果
List<Article> list = new ArrayList<Article>();
for (int i = 0; i < scoreDocs.length; i++) {
// 根据编号取出真正的Document数据
Document doc = indexSearcher.doc(scoreDocs[i].doc);
// 进行高亮操作，一次只能高亮一个字段的值，返回高亮后的文本（一段摘要），如果当前高亮的属性值中没有出现要搜索的关键字，则返回null
String text = highlighter.getBestFragment(Configuration.getAnalyzer(), "content", doc.get("content"));
if (text != null) {
doc.getField("content").setValue(text); // 使用高亮后的文本替换原始内容
}
// 把Document转成Article
Article article = ArticleDocumentUtils.document2Article(doc);
list.add(article);
}
indexSearcher.close();
// 显示结果
System.out.println("总结果数量为：" + list.size());
for (Article article : list) {
System.out.println("--------> id = " + article.getId());
System.out.println("title = " + article.getTitle());
System.out.println("content= " + article.getContent());
}
}
}
扫一扫
4198
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
