热门搜索：
* TermQuery是最简单、也是最常用的Query。TermQuery可以理解成为“词条搜索”，
* 在搜索引擎中最基本的搜索就是在索引中搜索某一词条，而TermQuery就是用来完成这项工作的。
* 在Lucene中词条是最基本的搜索单位，从本质上来讲一个词条其实就是一个名/值对。
* 只不过这个“名”是字段名，而“值”则表示字段中所包含的某个关键字。
*
* @throws IOException
*/
@Test
public void termQueryTest() throws IOException {
String searchField = "title";
//这是一个条件查询的api，用于添加条件
TermQuery query = new TermQuery(new Term(searchField, "Spark"));
//执行查询，并打印查询到的记录数
executeQuery(query);
}
响应
总共查询到1个文档
id：1
title：Spark
content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
多条件查询
/**
* 多条件查询
*
* BooleanQuery也是实际开发过程中经常使用的一种Query。
* 它其实是一个组合的Query，在使用时可以把各种Query对象添加进去并标明它们之间的逻辑关系。
* BooleanQuery本身来讲是一个布尔子句的容器，它提供了专门的API方法往其中添加子句，
* 并标明它们之间的关系，以下代码为BooleanQuery提供的用于添加子句的API接口：
*
* @throws IOException
*/
@Test
public void BooleanQueryTest() throws IOException {
String searchField1 = "title";
String searchField2 = "content";
Query query1 = new TermQuery(new Term(searchField1, "Spark"));
Query query2 = new TermQuery(new Term(searchField2, "Apache"));
BooleanQuery.Builder builder = new BooleanQuery.Builder();
// BooleanClause用于表示布尔查询子句关系的类，
// 包 括：
// BooleanClause.Occur.MUST，
// BooleanClause.Occur.MUST_NOT，
// BooleanClause.Occur.SHOULD。
// 必须包含,不能包含,可以包含三种.有以下6种组合：
//
// 1．MUST和MUST：取得连个查询子句的交集。
// 2．MUST和MUST_NOT：表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。
// 3．SHOULD与MUST_NOT：连用时，功能同MUST和MUST_NOT。
// 4．SHOULD与MUST连用时，结果为MUST子句的检索结果,但是SHOULD可影响排序。
// 5．SHOULD与SHOULD：表示“或”关系，最终检索结果为所有检索子句的并集。
// 6．MUST_NOT和MUST_NOT：无意义，检索无结果。
builder.add(query1, BooleanClause.Occur.SHOULD);
builder.add(query2, BooleanClause.Occur.SHOULD);
BooleanQuery query = builder.build();
//执行查询，并打印查询到的记录数
executeQuery(query);
}
响应
总共查询到1个文档
id：1
title：Spark
content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
匹配前缀
/**
* 匹配前缀
*
* PrefixQuery用于匹配其索引开始以指定的字符串的文档。就是文档中存在xxx%
*
*
* @throws IOException
*/
@Test
public void prefixQueryTest() throws IOException {
String searchField = "title";
Term term = new Term(searchField, "Spar");
Query query = new PrefixQuery(term);
//执行查询，并打印查询到的记录数
executeQuery(query);
}
响应
总共查询到1个文档
id：1
title：Spark
content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
短语搜索
/**
* 短语搜索
*
* 所谓PhraseQuery，就是通过短语来检索，比如我想查“big car”这个短语，
* 那么如果待匹配的document的指定项里包含了"big car"这个短语，
* 这个document就算匹配成功。可如果待匹配的句子里包含的是“big black car”，
* 那么就无法匹配成功了，如果也想让这个匹配，就需要设定slop，
* 先给出slop的概念：slop是指两个项的位置之间允许的最大间隔距离
*
* @throws IOException
*/
@Test
public void phraseQueryTest() throws IOException {
String searchField = "content";
String query1 = "apache";
String query2 = "spark";
PhraseQuery.Builder builder = new PhraseQuery.Builder();
builder.add(new Term(searchField, query1));
builder.add(new Term(searchField, query2));
builder.setSlop(0);
PhraseQuery phraseQuery = builder.build();
//执行查询，并打印查询到的记录数
executeQuery(phraseQuery);
}
响应
总共查询到1个文档
id：1
title：Spark
content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
相近词语搜索
/**
* 相近词语搜索
*
* FuzzyQuery是一种模糊查询，它可以简单地识别两个相近的词语。
*
* @throws IOException
*/
@Test
public void fuzzyQueryTest() throws IOException {
String searchField = "content";
Term t = new Term(searchField, "大规模");
Query query = new FuzzyQuery(t);
//执行查询，并打印查询到的记录数
executeQuery(query);
}
响应
总共查询到1个文档
id：1
title：Spark
content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
通配符搜索
/**
* 通配符搜索
*
* Lucene也提供了通配符的查询，这就是WildcardQuery。
* 通配符“?”代表1个字符，而“*”则代表0至多个字符。
*
* @throws IOException
*/
@Test
public void wildcardQueryTest() throws IOException {
String searchField = "content";
Term term = new Term(searchField, "大*规模");
Query query = new WildcardQuery(term);
//执行查询，并打印查询到的记录数
executeQuery(query);
}
响应
总共查询到1个文档
id：1
title：Spark
content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
分词查询
/**
* 分词查询
*
* @throws IOException
* @throws ParseException
*/
@Test
public void queryParserTest() throws IOException, ParseException {
//Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文
//Analyzer analyzer = new SmartChineseAnalyzer();//中文分词
//Analyzer analyzer = new ComplexAnalyzer();//中文分词
//Analyzer analyzer = new IKAnalyzer();//中文分词
Analyzer analyzer = new IKAnalyzer();//中文分词
String searchField = "content";
//指定搜索字段和分析器
QueryParser parser = new QueryParser(searchField, analyzer);
//用户输入内容
Query query = parser.parse("计算引擎");
//执行查询，并打印查询到的记录数
executeQuery(query);
}
响应
总共查询到1个文档
id：1
title：Spark
content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
多个 Field 分词查询
/**
* 多个 Field 分词查询
*
* @throws IOException
* @throws ParseException
*/
@Test
public void multiFieldQueryParserTest() throws IOException, ParseException {
//Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文
//Analyzer analyzer = new SmartChineseAnalyzer();//中文分词
//Analyzer analyzer = new ComplexAnalyzer();//中文分词
//Analyzer analyzer = new IKAnalyzer();//中文分词
Analyzer analyzer = new IKAnalyzer();//中文分词
String[] filedStr = new String[]{"title", "content"};
//指定搜索字段和分析器
QueryParser queryParser = new MultiFieldQueryParser(filedStr, analyzer);
//用户输入内容
Query query = queryParser.parse("Spark");
//执行查询，并打印查询到的记录数
executeQuery(query);
}
响应
总共查询到1个文档
id：1
title：Spark
content：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
中文分词器
/**
* IKAnalyzer 中文分词器
* SmartChineseAnalyzer smartcn分词器 需要lucene依赖 且和lucene版本同步
*
* @throws IOException
*/
@Test
public void AnalyzerTest() throws IOException {
//Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文
//Analyzer analyzer = new SmartChineseAnalyzer();//中文分词
//Analyzer analyzer = new ComplexAnalyzer();//中文分词
//Analyzer analyzer = new IKAnalyzer();//中文分词
Analyzer analyzer = null;
String text = "Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎";
analyzer = new IKAnalyzer();//IKAnalyzer 中文分词
printAnalyzerDoc(analyzer, text);
System.out.println();
analyzer = new ComplexAnalyzer();//MMSeg4j 中文分词
printAnalyzerDoc(analyzer, text);
System.out.println();
analyzer = new SmartChineseAnalyzer();//Lucene 中文分词器
printAnalyzerDoc(analyzer, text);
}
三种分词响应
apache
spark
专为
大规模
规模
模数
数据处理
数据
处理
而设
设计
快速
通用
计算
引擎
apache
spark
是
专为
大规模
数据处理
而
设计
的
快速
通用
的
计算
引擎
apach
spark
是
专
为
大规模
数据
处理
而
设计
的
快速
通用
的
计算
引擎
高亮处理
/**
* 高亮处理
*
* @throws IOException
*/
@Test
public void HighlighterTest() throws IOException, ParseException, InvalidTokenOffsetsException {
//Analyzer analyzer = new StandardAnalyzer(); // 标准分词器，适用于英文
//Analyzer analyzer = new SmartChineseAnalyzer();//中文分词
//Analyzer analyzer = new ComplexAnalyzer();//中文分词
//Analyzer analyzer = new IKAnalyzer();//中文分词
Analyzer analyzer = new IKAnalyzer();//中文分词
String searchField = "content";
String text = "Apache Spark 大规模数据处理";
//指定搜索字段和分析器
QueryParser parser = new QueryParser(searchField, analyzer);
//用户输入内容
Query query = parser.parse(text);
TopDocs topDocs = indexSearcher.search(query, 100);
// 关键字高亮显示的html标签，需要导入lucene-highlighter-xxx.jar
SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("", "");
Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));
for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
//取得对应的文档对象
Document document = indexSearcher.doc(scoreDoc.doc);
// 内容增加高亮显示
TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(document.get("content")));
String content = highlighter.getBestFragment(tokenStream, document.get("content"));
System.out.println(content);
}
}
响应
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎!
代码我已放到 Github ，导入spring-boot-lucene-demo 项目
github spring-boot-lucene-demo
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持中文源码网。
QQ客服
公众号
手机版
帮助中心
