1.1. Lucene查询
在学习Lucene的查询方法前，先了解一下下面几个类：
1.1.1. Query
封装某种查询类型的具体子类，配置查询的查询条件。Query实例将被传递给IndexSearcher的search方法。下面是常用的Query子类：
l 通过项进行搜索 TermQuery类
l 在指定的项范围内搜索 TermRangeQuery类
l 通过字符串搜索 PrefixQuery类
l 组合查询 BooleanQuery类
l 通过短语搜索 PhraseQuery类
l 通配符查询 WildcardQuery类
l 搜索类似项 FuzzyQuery类
l 匹配所有文档 MatchAllDocsQuery类
l 不匹配文档 MatchNoDocsQuery类
l 解析查询表达式 QueryParser类
l 多短语查询 MultiPhraseQuery类
l 查询所有 MatchAllDocsQuery类
l 不匹配所有文档 MatchNoDocsQuery类
1.1.2. QueryParser
将用户输入的可读的查询表达式处理成具体的Query对象
示例：
1 @Test 2 3 public void testQueryParser() throws ParseException, IOException { 4 5 //使用WhitespaceAnalyzer分析器不会忽略大小写，也就是说大小写敏感 6 7 QueryParser queryParser = new QueryParser("bookcontent", new IKAnalyzer()); 8 9 Query query = queryParser.parse("2018"); 10 11 IndexSearcher searcher = getIndexSearcher(); 12 13 TopDocs topDocs = searcher.search(query, 10); 14 15 16 17 // 返回查询结果。遍历查询结果并输出。 18 19 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 20 21 for (ScoreDoc scoreDoc : scoreDocs) { 22 23 int doc = scoreDoc.doc; 24 25 Document document = searcher.doc(doc); 26 27 // 打印content字段的值 28 29 System.out.println("bookid: "+document.get("bookid")); 30 31 System.out.println("bookname: "+document.get("bookname")); 32 33 System.out.println("booktype: "+document.get("booktype")); 34 35 System.out.println("bookcontent: "+document.get("bookcontent")); 36 37 } 38 39 }
1.1.3. MultiFieldQueryParser
1 /** 2 3 * 传统解析器-多默认字段 4 5 * B. 基于新的 flexible 框架的解析器：StandardQueryParser 6 7 */ 8 9 @Test 10 11 public void MultiFieldQueryParser() { 12 13 try { 14 15 String[] multiDefaultFields = { "bookname", "booktype", "bookcontent" }; 16 17 org.apache.lucene.queryparser.classic.MultiFieldQueryParser multiFieldQueryParser = new org.apache.lucene.queryparser.classic.MultiFieldQueryParser( 18 19 multiDefaultFields, new IKAnalyzer()); 20 21 // 设置默认的组合操作，默认是 OR 22 23 multiFieldQueryParser.setDefaultOperator(Operator.OR); 24 25 Query query = multiFieldQueryParser.parse("西游记》又称央视86版《西游记》，改编自明12345678901"); 26 27 doSearch(query); 28 29 } catch (Exception e) { 30 31 e.printStackTrace(); 32 33 } 34 35 }
1.1.4. TermQuery
1 /** 2 3 * 词项查询 4 5 * 最基本、最常用的查询。用来查询指定字段包含指定词项的文档。 6 7 */ 8 9 @Test 10 11 public void termQuery() { 12 13 try { 14 15 IndexSearcher searcher = getIndexSearcher(); 16 17 18 19 TermQuery tq = new TermQuery(new Term("bookname", "西游记")); 20 21 TopDocs topDocs = searcher.search(tq, 10); 22 23 printTopDocs(topDocs); 24 25 } catch (Exception e) { 26 27 e.printStackTrace(); 28 29 } 30 31 }
1.1.5. booleanQuery
1 /** 2 3 * 布尔查询 4 5 * 搜索的条件往往是多个的，如要查询名称包含“电脑” 或 “thinkpad”的商品，就需要两个词项查询做或合并。布尔查询就是用来组合多个子查询的。 6 7 * 每个子查询称为布尔字句 BooleanClause，布尔字句自身也可以是组合的。 组合关系支持如下四种： 8 9 * Occur.SHOULD 或 10 11 * Occur.MUST 且 12 13 * Occur.MUST_NOT 且非 14 15 * Occur.FILTER 同 MUST，但该字句不参与评分 16 17 * 布尔查询默认的最大字句数为1024，在将通配符查询这样的查询rewriter为布尔查询时，往往会产生很多的字句，可能抛出TooManyClauses 异常。 18 19 * 可通过BooleanQuery.setMaxClauseCount(int)设置最大字句数。 20 21 */ 22 23 @Test 24 25 public void booleanQuery() { 26 27 try { 28 29 // 创建一个indexsearcher对象 30 31 IndexSearcher searcher = getIndexSearcher(); 32 33 34 35 BooleanQuery.Builder builder = new BooleanQuery.Builder(); 36 37 // 书内容 38 39 QueryParser queryParser = new QueryParser("bookcontent", new IKAnalyzer()); 40 41 Query query1 = queryParser.parse("西游记"); 42 43 builder.add(query1, Occur.MUST); 44 45 46 47 // 书名称 48 49 Query qymc = new FuzzyQuery(new Term("bookname", "西游记")); 50 51 builder.add(qymc, Occur.MUST); 52 53 54 55 // 书类型 56 57 Query gmsfhm = new TermQuery(new Term("booktype", "小说")); 58 59 builder.add(gmsfhm, Occur.MUST); 60 61 62 63 BooleanQuery booleanQuery = builder.build(); 64 65 66 67 TopDocs topDocs = searcher.search(booleanQuery, 10); 68 69 printTopDocs(topDocs); 70 71 } catch (Exception e) { 72 73 e.printStackTrace(); 74 75 } 76 77 }
1.1.5.1. Occur
Occur是用来决定各个条件的逻辑关系，具体如下：
l Occur.SHOULD 或
l Occur.MUST 且
l Occur.MUST_NOT 且非
l Occur.FILTER 同 MUST，但该字句不参与评分
而这些逻辑组合之间也有要关注的地方(下面几点关注一下即可，跟版本有关，在8.1.0的版本中是直接意思，并没有出现下面的情况。应该是新版已经更新，6版本之前的可以关注下面的信息。)：
- MUST和MUST：取得连个查询子句的交集。
- MUST和MUST_NOT：表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。
- SHOULD与MUST_NOT：连用时，功能同MUST和MUST_NOT。
- SHOULD与MUST连用时，结果为MUST子句的检索结果,但是SHOULD可影响排序。
- SHOULD与SHOULD：表示“或”关系，最终检索结果为所有检索子句的并集。
- MUST_NOT和MUST_NOT：无意义，检索无结果。
1.1.6. phraseQuery
1 /** 2 3 * 短语查询 4 5 * 最常用的查询，匹配特定序列的多个词项。PhraserQuery使用一个位置移动因子（slop）来决定任意两个词项的位置可最大移动多少个位置来进行匹配，默认为0。 6 7 * 有两种方式来构建对象： 8 9 * 注意：所有加入的词项都匹配才算匹配（即使是你在同一位置加入多个词项）。如果需要在同一位置匹配多个同义词中的一个，适合用MultiPhraseQuery 10 11 */ 12 13 @Test 14 15 public void phraseQuery() { 16 17 try { 18 19 PhraseQuery phraseQuery1 = new PhraseQuery("bookcontent", "根据", "明代"); 20 21 22 23 PhraseQuery phraseQuery2 = new PhraseQuery(0, "bookcontent", "根据", "明代"); 24 25 26 27 PhraseQuery phraseQuery3 = new PhraseQuery("bookcontent", "笔记本电脑", "联想"); 28 29 30 31 PhraseQuery phraseQuery4 = new PhraseQuery.Builder() 32 33 .add(new Term("bookcontent", "根据"), 4) 34 35 .add(new Term("bookcontent", "施耐"), 5).build(); 36 37 // 这两句等同 38 39 PhraseQuery phraseQuery5 = new PhraseQuery.Builder() 40 41 .add(new Term("bookcontent", "笔记本电脑"), 0) 42 43 .add(new Term("bookcontent", "联想"), 1).build(); 44 45 46 47 doSearch(phraseQuery2); 48 49 } catch (Exception e) { 50 51 e.printStackTrace(); 52 53 } 54 55 }
1.1.7. multiPhraseQuery
1 /** 2 3 * 多重短语查询 4 5 * 短语查询的一种更通用的用法，支持同位置多个词的OR匹配。通过里面的Builder来构建MultiPhraseQuery： 6 7 */ 8 9 @Test 10 11 public void multiPhraseQuery() { 12 13 try { 14 15 // 4 MultiPhraseQuery 多重短语查询 16 17 Term[] terms = new Term[2]; 18 19 terms[0] = new Term("bookcontent", "根据"); 20 21 terms[1] = new Term("bookcontent", "根据明代"); 22 23 Term t = new Term("bookcontent", "施耐"); 24 25 MultiPhraseQuery multiPhraseQuery = new MultiPhraseQuery.Builder() 26 27 .add(terms).add(t).build(); 28 29 30 31 // 对比 PhraseQuery在同位置加入多个词 ，同位置的多个词都需匹配，所以查不出。 32 33 PhraseQuery pquery = new PhraseQuery.Builder().add(terms[0], 0) 34 35 .add(terms[1], 0).add(t, 1).build(); 36 37 38 39 doSearch(multiPhraseQuery); 40 41 } catch (Exception e) { 42 43 e.printStackTrace(); 44 45 } 46 47 }
1.1.8. spanNearQuery
1 /** 2 3 * 临近查询（跨度查询） 4 5 * 用于更复杂的短语查询，可以指定词间位置的最大间隔跨度。通过组合一系列的SpanQuery 实例来进行查询，可以指定是否按顺序匹配、slop、gap 6 7 */ 8 9 @Test 10 11 public void spanNearQuery() { 12 13 try { 14 15 // SpanNearQuery 临近查询 16 17 SpanTermQuery tq1 = new SpanTermQuery(new Term("bookcontent", "中央电视台")); 18 19 SpanTermQuery tq2 = new SpanTermQuery(new Term("bookcontent", "无锡")); 20 21 SpanNearQuery spanNearQuery = new SpanNearQuery( 22 23 new SpanQuery[] { tq1, tq2 }, 0, true); 24 25 26 27 // SpanNearQuery 临近查询 gap slop 使用 28 29 SpanNearQuery.Builder spanNearQueryBuilder = SpanNearQuery 30 31 .newOrderedNearQuery("bookcontent"); 32 33 spanNearQueryBuilder.addClause(tq1).addGap(0).setSlop(1) 34 35 .addClause(tq2); 36 37 SpanNearQuery spanNearQuery5 = spanNearQueryBuilder.build(); 38 39 // IndexSearcher searcher = getIndexSearcher(); 40 41 // TopDocs topDocs = searcher.search(spanNearQueryBuilder, 10); 42 43 doSearch(spanNearQuery); 44 45 } catch (Exception e) { 46 47 e.printStackTrace(); 48 49 } 50 51 }
1.1.9. termRangeQuery
1 /** 2 3 * 词项范围查询 4 5 * 用于查询包含某个范围内的词项的文档，如以字母开头a到c的词项。词项在反向索引中是排序的，只需指定的开始词项、结束词项，就可以查询该范围的词项。 6 7 * 如果是做数值的范围查询则用 PointRangeQuery 8 9 * 参数说明: 10 11 * 第1个参数：要查询的字段-field 12 13 * 第2个参数:：下边界词-lowerTerm 14 15 * 第3个参数：上边界词-upperTerm 16 17 * 第4个参数：是否包含下边界-includeLower 18 19 * 第5个参数：是否包含上边界 includeUpper 20 21 */ 22 23 @Test 24 25 public void termRangeQuery() { 26 27 try { 28 29 // TermRangeQuery 词项范围查询 30 31 TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange("bookcontent", 32 33 "中央电视台", "同名小说改编", false, true); 34 35 doSearch(termRangeQuery); 36 37 } catch (Exception e) { 38 39 e.printStackTrace(); 40 41 } 42 43 }
1.1.10. prefixQuery
1 /** 2 3 * 前缀查询 4 5 * PrefixQuery：前缀查询，查询包含以xxx为前缀的词项的文档，是通配符查询，如 app，实际是 app* 6 7 */ 8 9 @Test 10 11 public void prefixQuery() { 12 13 try { 14 15 // PrefixQuery 前缀查询 16 17 PrefixQuery prefixQuery = new PrefixQuery(new Term("bookcontent", "中国")); 18 19 doSearch(prefixQuery); 20 21 } catch (Exception e) { 22 23 e.printStackTrace(); 24 25 } 26 27 }
1.1.11. wildcardQuery
1 /** 2 3 * 通配符查询 4 5 * WildcardQuery：通配符查询， *表示0个或多个字符，?表示1个字符，\是转义符。通配符查询可能会比较慢，不可以通配符开头（那样就是所有词项了） 6 7 */ 8 9 @Test 10 11 public void wildcardQuery() { 12 13 try { 14 15 // WildcardQuery 通配符查询 16 17 WildcardQuery wildcardQuery = new WildcardQuery( 18 19 new Term("bookcontent", "中国*")); 20 21 doSearch(wildcardQuery); 22 23 } catch (Exception e) { 24 25 e.printStackTrace(); 26 27 } 28 29 }
1.1.12. regexpQuery
1 /** 2 3 * 正则表达式查询 4 5 * RegexpQuery：正则表达式查询，词项符合某正则表达式 6 7 */ 8 9 @Test 10 11 public void regexpQuery() { 12 13 try { 14 15 // RegexpQuery 正则表达式查询 16 17 RegexpQuery regexpQuery = new RegexpQuery(new Term("bookcontent", "厉害.{4}")); 18 19 doSearch(regexpQuery); 20 21 } catch (Exception e) { 22 23 e.printStackTrace(); 24 25 } 26 27 }
1.1.13. fuzzyQuery
1 /** 2 3 * 模糊查询 4 5 * 简单地与索引词项进行相近匹配，允许最大2个不同字符。常用于拼写错误的容错：如把 “thinkpad” 拼成 “thinkppd”或 “thinkd”，使用FuzzyQuery 仍可搜索到正确的结果。 6 7 */ 8 9 @Test 10 11 public void fuzzyQuery() { 12 13 try { 14 15 // FuzzyQuery 模糊查询 16 17 FuzzyQuery fuzzyQuery = new FuzzyQuery(new Term("bookcontent", "猪八戒")); 18 19 20 21 FuzzyQuery fuzzyQuery2 = new FuzzyQuery(new Term("bookcontent", "thinkd"), 2); 22 23 24 25 FuzzyQuery fuzzyQuery3 = new FuzzyQuery(new Term("bookcontent", "thinkpaddd")); 26 27 28 29 FuzzyQuery fuzzyQuery4 = new FuzzyQuery(new Term("bookcontent", "thinkdaddd")); 30 31 doSearch(fuzzyQuery); 32 33 } catch (Exception e) { 34 35 e.printStackTrace(); 36 37 } 38 39 }
1.1.14. 高亮
1 /** 2 3 * 高亮排序查询 4 5 * @throws InvalidTokenOffsetsException 6 7 */ 8 9 private void highLightSearch(Query query) throws InvalidTokenOffsetsException { 10 11 // 获取一个indexReader对象 12 13 try { 14 15 Analyzer ikanalyzer = new IKAnalyzer(); 16 17 IndexSearcher searcher = getIndexSearcher(); 18 19 //true表示降序 20 21 //SortField.Type.SCORE 根据相关度进行排序(默认) 22 23 //SortField.Type.DOC 根据文档编号或者说是索引顺序 24 25 //SortField.Type.FLOAT(Long等),根据fieldName的数值类型进行排序 26 27 SortField sortField = new SortField("bookprice",SortField.Type.INT,false); 28 29 Sort sort = new Sort(sortField); 30 31 32 33 TopDocs topDocs = searcher.search(query, 10, sort); 34 35 System.out.println("数字查询"); 36 37 System.out.println("命中结果数为: "+ topDocs.totalHits); 38 39 // 返回查询结果。遍历查询结果并输出。 40 41 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 42 43 for (ScoreDoc scoreDoc : scoreDocs) { 44 45 int doc = scoreDoc.doc; 46 47 Document document = searcher.doc(doc); 48 49 String text = document.get("bookcontent"); 50 51 SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<font color='red'>", "</font>"); 52 53 Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query)); 54 55 highlighter.setTextFragmenter(new SimpleFragmenter(text.length())); 56 57 if (text != null) { 58 59 TokenStream tokenStream = ikanalyzer.tokenStream("bookcontent", new StringReader(text)); 60 61 String highLightText = highlighter.getBestFragment(tokenStream,text); 62 63 System.out.println("高亮显示第 " + (doc + 1) + " 条检索结果如下所示："); 64 65 System.out.println("bookcontent: "+highLightText); 66 67 } 68 69 70 71 // 打印content字段的值 72 73 System.out.println("bookid: "+document.get("bookid")); 74 75 System.out.println("bookname: "+document.get("bookname")); 76 77 System.out.println("booktype: "+document.get("booktype")); 78 79 System.out.println("bookprice: "+document.get("bookprice")); 80 81 System.out.println("bookdate: "+document.get("bookdate")); 82 83 // System.out.println("bookcontent: "+document.get("bookcontent")); 84 85 System.out.println("查询得分是: "+scoreDoc.score); 86 87 System.out.println("--------------我是分割线------------------"); 88 89 } 90 91 } catch (IOException e) { 92 93 e.printStackTrace(); 94 95 } 96 97 }
1.1.15. 排序
1 /** 2 3 * 排序查询 4 5 */ 6 7 private void sortSearch(Query query) { 8 9 // 获取一个indexReader对象 10 11 try { 12 13 IndexSearcher searcher = getIndexSearcher(); 14 15 //true表示降序 16 17 //SortField.Type.SCORE 根据相关度进行排序(默认) 18 19 //SortField.Type.DOC 根据文档编号或者说是索引顺序 20 21 //SortField.Type.FLOAT(Long等),根据fieldName的数值类型进行排序 22 23 SortField sortField = new SortField("bookcontent",SortField.Type.SCORE,false); 24 25 Sort sort = new Sort(sortField); 26 27 28 29 TopDocs topDocs = searcher.search(query, 10, sort); 30 31 System.out.println("数字查询"); 32 33 System.out.println("命中结果数为: "+ topDocs.totalHits); 34 35 // 返回查询结果。遍历查询结果并输出。 36 37 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 38 39 for (ScoreDoc scoreDoc : scoreDocs) { 40 41 int doc = scoreDoc.doc; 42 43 Document document = searcher.doc(doc); 44 45 // 打印content字段的值 46 47 System.out.println("bookid: "+document.get("bookid")); 48 49 System.out.println("bookname: "+document.get("bookname")); 50 51 System.out.println("booktype: "+document.get("booktype")); 52 53 System.out.println("bookprice: "+document.get("bookprice")); 54 55 System.out.println("bookcontent: "+document.get("bookcontent")); 56 57 System.out.println("查询得分是: "+scoreDoc.score); 58 59 System.out.println("--------------我是分割线------------------"); 60 61 } 62 63 } catch (IOException e) { 64 65 e.printStackTrace(); 66 67 } 68 69 }
1.1.15.1. SortField
l SortField.Type.SCORE 根据相关度进行排序(默认)
l SortField.Type.DOC 根据文档编号或者说是索引顺序
l SortField.Type.FLOAT(Long等),根据fieldName的数值类型进行排序
1.1.16. 代码集合
1 import java.io.IOException; 2 import java.io.StringReader; 3 import org.apache.lucene.analysis.Analyzer; 4 import org.apache.lucene.analysis.TokenStream; 5 import org.apache.lucene.analysis.core.WhitespaceAnalyzer; 6 import org.apache.lucene.analysis.standard.StandardAnalyzer; 7 import org.apache.lucene.document.Document; 8 import org.apache.lucene.document.Field; 9 import org.apache.lucene.document.IntPoint; 10 import org.apache.lucene.document.NumericDocValuesField; 11 import org.apache.lucene.document.StoredField; 12 import org.apache.lucene.document.StringField; 13 import org.apache.lucene.document.TextField; 14 import org.apache.lucene.index.DirectoryReader; 15 import org.apache.lucene.index.IndexWriter; 16 import org.apache.lucene.index.IndexWriterConfig; 17 import org.apache.lucene.index.Term; 18 import org.apache.lucene.queryparser.classic.ParseException; 19 import org.apache.lucene.queryparser.classic.QueryParser; 20 import org.apache.lucene.queryparser.classic.QueryParser.Operator; 21 import org.apache.lucene.queryparser.simple.SimpleQueryParser; 22 import org.apache.lucene.search.BooleanQuery; 23 import org.apache.lucene.search.FuzzyQuery; 24 import org.apache.lucene.search.IndexSearcher; 25 import org.apache.lucene.search.MultiPhraseQuery; 26 import org.apache.lucene.search.PhraseQuery; 27 import org.apache.lucene.search.PrefixQuery; 28 import org.apache.lucene.search.Query; 29 import org.apache.lucene.search.RegexpQuery; 30 import org.apache.lucene.search.ScoreDoc; 31 import org.apache.lucene.search.Sort; 32 import org.apache.lucene.search.SortField; 33 import org.apache.lucene.search.TermQuery; 34 import org.apache.lucene.search.TermRangeQuery; 35 import org.apache.lucene.search.TopDocs; 36 import org.apache.lucene.search.WildcardQuery; 37 import org.apache.lucene.search.highlight.Highlighter; 38 import org.apache.lucene.search.highlight.InvalidTokenOffsetsException; 39 import org.apache.lucene.search.highlight.QueryScorer; 40 import org.apache.lucene.search.highlight.SimpleFragmenter; 41 import org.apache.lucene.search.highlight.SimpleHTMLFormatter; 42 import org.apache.lucene.search.spans.SpanNearQuery; 43 import org.apache.lucene.search.spans.SpanQuery; 44 import org.apache.lucene.search.spans.SpanTermQuery; 45 import org.apache.lucene.search.BooleanClause.Occur; 46 import org.apache.lucene.store.Directory; 47 import org.apache.lucene.store.RAMDirectory; 48 import org.junit.Before; 49 import org.junit.Test; 50 import org.wltea.analyzer.lucene.IKAnalyzer; 51 public class FullTextRetrieval { 52 private Directory directory = new RAMDirectory(); 53 private IndexWriterConfig indexWriterConfig = new IndexWriterConfig(new IKAnalyzer()); 54 private IndexWriter indexWriter; 55 @Before 56 public void createIndex() { 57 try { 58 indexWriter = new IndexWriter(directory, indexWriterConfig); 59 Document doc = new Document(); 60 // 书主键 61 doc = new Document(); 62 doc.add(new StringField("bookid", "1345678", Field.Store.YES)); 63 // 书名 64 doc.add(new StringField("bookname", "西游记", Field.Store.YES)); 65 // 书的类型 66 doc.add(new StringField("booktype", "小说", Field.Store.YES)); 67 // 书的价格 68 doc.add(new NumericDocValuesField("bookprice", 123)); 69 // 书的日期年份 70 Field intPoint = new IntPoint("bookdate", 1066); 71 doc.add(intPoint); 72 intPoint = new StoredField("bookdate", 1066); 73 doc.add(intPoint); 74 // doc.add(new NumericDocValuesField("bookdate", 123)); 75 // 书的内容 76 doc.add(new TextField("bookcontent", "《西游记》又称央视86版《西游记》，改编自明代小说家吴承恩同名文学古典名著。是由中央电视台、中国电视剧制作中心出品的一部25集古装神话剧。由杨洁执导，戴英禄，杨洁，邹忆青共同编剧，六小龄童、徐少华、迟重瑞、汪粤、马德华、闫怀礼等主演，李世宏、李扬、张云明、里坡等担任主要配音。 [1] \r\n" + 77 78 "该剧讲述的是孙悟空、猪八戒、沙僧辅保大唐高僧玄奘去西天取经，师徒四人一路抢滩涉险，降妖伏怪，历经八十一难，取回真经，终修正果的故事。\r\n" + 79 80 "《西游记》于1982年7月3日开机，同年10月1日首播试集《除妖乌鸡国》。1986年春节在央视首播前11集，1988年25集播出。\r\n" + 81 82 "1986年春节一经播出，轰动全国，老少皆宜，获得了极高评价，造就了89.4%的收视率神话，至今仍是寒暑假被重播最多的电视剧，重播次数超过3000次，依然百看不厌，成为一部公认的无法超越的经典。", Field.Store.YES)); 83 84 // 添加文档 85 indexWriter.addDocument(doc); 86 // 书主键 87 doc = new Document(); 88 doc.add(new StringField("bookid", "12345678", Field.Store.YES)); 89 // 书名 90 doc.add(new StringField("bookname", "水浒传", Field.Store.YES)); 91 // 书的类型 92 doc.add(new StringField("booktype", "小说", Field.Store.YES)); 93 // 书的价格 94 doc.add(new NumericDocValuesField("bookprice", 432)); 95 // 书的日期年份 96 Field intPoint1 = new IntPoint("bookdate", 1666); 97 doc.add(intPoint1); 98 intPoint = new StoredField("bookdate", 1666); 99 doc.add(intPoint1); 100 // 书的内容 101 doc.add(new TextField("bookcontent", "中国大陆，中央电视台无锡太湖影视城 43集\r\n" + 102 "《水浒传》是由中央电视台与中国电视剧制作中心联合出品的43集电视连续剧，根据明代施耐庵的同名小说改编。 [1] 由张绍林执导，杨争光 、冉平改编，李雪健、周野芒、臧金生、丁海峰、赵小锐领衔主演。\r\n" + 103 104 "该剧讲述的是宋朝徽宗时皇帝昏庸、奸臣当道、官府腐败、贪官污吏陷害忠良，弄得民不聊生，许多正直善良的人被官府逼得无路可走，被迫奋起反抗，最终108条好汉聚义梁山泊，但随后宋江对朝廷的投降使得一场轰轰烈烈的农民起义最后走向失败的故事。 [2] \r\n" + 105 "《水浒传》于1998年1月8日在中央电视台一套首播。 [3] \r\n" + 106 "2018年9月8日，9月15日，9月22日，央视四台《中国文艺》“向经典致敬”栏目播出《水浒传》20周年聚首专题节目", Field.Store.YES)); 107 indexWriter.addDocument(doc); 108 indexWriter.close(); 109 } catch (IOException e) { 110 e.printStackTrace(); 111 } 112 } 113 private IndexSearcher getIndexSearcher() throws IOException { 114 return new IndexSearcher(DirectoryReader.open(directory)); 115 } 116 117 /** 118 * 全文检索 119 * @throws ParseException 120 * @throws IOException 121 */ 122 @Test 123 public void testQueryParser() throws ParseException, IOException { 124 //使用WhitespaceAnalyzer分析器不会忽略大小写，也就是说大小写敏感 125 QueryParser queryParser = new QueryParser("bookcontent", new IKAnalyzer()); 126 Query query = queryParser.parse("2018"); 127 IndexSearcher searcher = getIndexSearcher(); 128 TopDocs topDocs = searcher.search(query, 10); 129 // 返回查询结果。遍历查询结果并输出。 130 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 131 132 for (ScoreDoc scoreDoc : scoreDocs) { 133 134 int doc = scoreDoc.doc; 135 136 Document document = searcher.doc(doc); 137 138 // 打印content字段的值 139 140 System.out.println("bookid: "+document.get("bookid")); 141 142 System.out.println("bookname: "+document.get("bookname")); 143 144 System.out.println("booktype: "+document.get("booktype")); 145 146 System.out.println("bookcontent: "+document.get("bookcontent")); 147 148 } 149 } 150 /** 151 * 词项查询 152 * 最基本、最常用的查询。用来查询指定字段包含指定词项的文档。 153 */ 154 @Test 155 public void termQuery() { 156 try { 157 IndexSearcher searcher = getIndexSearcher(); 158 TermQuery tq = new TermQuery(new Term("bookname", "西游记")); 159 TopDocs topDocs = searcher.search(tq, 10); 160 printTopDocs(topDocs); 161 } catch (Exception e) { 162 e.printStackTrace(); 163 } 164 } 165 /** 166 * 布尔查询 167 * 搜索的条件往往是多个的，如要查询名称包含“电脑” 或 “thinkpad”的商品，就需要两个词项查询做或合并。布尔查询就是用来组合多个子查询的。 168 * 每个子查询称为布尔字句 BooleanClause，布尔字句自身也可以是组合的。 组合关系支持如下四种： 169 * Occur.SHOULD 或 170 * Occur.MUST 且 171 * Occur.MUST_NOT 且非 172 * Occur.FILTER 同 MUST，但该字句不参与评分 173 * 布尔查询默认的最大字句数为1024，在将通配符查询这样的查询rewriter为布尔查询时，往往会产生很多的字句，可能抛出TooManyClauses 异常。 174 * 可通过BooleanQuery.setMaxClauseCount(int)设置最大字句数。 175 */ 176 @Test 177 public void booleanQuery() { 178 try { 179 // 创建一个indexsearcher对象 180 IndexSearcher searcher = getIndexSearcher(); 181 BooleanQuery.Builder builder = new BooleanQuery.Builder(); 182 // 书内容 183 QueryParser queryParser = new QueryParser("bookcontent", new IKAnalyzer()); 184 Query query1 = queryParser.parse("西游记"); 185 builder.add(query1, Occur.MUST); 186 // 书名称 187 Query qymc = new FuzzyQuery(new Term("bookname", "西游记")); 188 builder.add(qymc, Occur.MUST); 189 // 书类型 190 Query gmsfhm = new TermQuery(new Term("booktype", "小说")); 191 builder.add(gmsfhm, Occur.MUST); 192 BooleanQuery booleanQuery = builder.build(); 193 TopDocs topDocs = searcher.search(booleanQuery, 10); 194 printTopDocs(topDocs); 195 } catch (Exception e) { 196 e.printStackTrace(); 197 } 198 } 199 200 /** 201 * 短语查询 202 * 最常用的查询，匹配特定序列的多个词项。PhraserQuery使用一个位置移动因子（slop）来决定任意两个词项的位置可最大移动多少个位置来进行匹配，默认为0。 203 * 有两种方式来构建对象： 204 * 注意：所有加入的词项都匹配才算匹配（即使是你在同一位置加入多个词项）。如果需要在同一位置匹配多个同义词中的一个，适合用MultiPhraseQuery 205 */ 206 @Test 207 public void phraseQuery() { 208 try { 209 PhraseQuery phraseQuery1 = new PhraseQuery("bookcontent", "根据", "明代"); 210 PhraseQuery phraseQuery2 = new PhraseQuery(0, "bookcontent", "根据", "明代"); 211 PhraseQuery phraseQuery3 = new PhraseQuery("bookcontent", "笔记本电脑", "联想"); 212 PhraseQuery phraseQuery4 = new PhraseQuery.Builder() 213 214 .add(new Term("bookcontent", "根据"), 4) 215 216 .add(new Term("bookcontent", "施耐"), 5).build(); 217 // 这两句等同 218 PhraseQuery phraseQuery5 = new PhraseQuery.Builder() 219 220 .add(new Term("bookcontent", "笔记本电脑"), 0) 221 222 .add(new Term("bookcontent", "联想"), 1).build(); 223 224 225 226 doSearch(phraseQuery2); 227 } catch (Exception e) { 228 e.printStackTrace(); 229 } 230 } 231 /** 232 * 多重短语查询 233 * 短语查询的一种更通用的用法，支持同位置多个词的OR匹配。通过里面的Builder来构建MultiPhraseQuery： 234 */ 235 @Test 236 public void multiPhraseQuery() { 237 try { 238 // 4 MultiPhraseQuery 多重短语查询 239 240 Term[] terms = new Term[2]; 241 242 terms[0] = new Term("bookcontent", "根据"); 243 244 terms[1] = new Term("bookcontent", "根据明代"); 245 246 Term t = new Term("bookcontent", "施耐"); 247 248 MultiPhraseQuery multiPhraseQuery = new MultiPhraseQuery.Builder() 249 250 .add(terms).add(t).build(); 251 252 // 对比 PhraseQuery在同位置加入多个词 ，同位置的多个词都需匹配，所以查不出。 253 254 PhraseQuery pquery = new PhraseQuery.Builder().add(terms[0], 0) 255 256 .add(terms[1], 0).add(t, 1).build(); 257 258 doSearch(multiPhraseQuery); 259 260 } catch (Exception e) { 261 262 e.printStackTrace(); 263 } 264 } 265 /** 266 267 * 临近查询（跨度查询） 268 269 * 用于更复杂的短语查询，可以指定词间位置的最大间隔跨度。通过组合一系列的SpanQuery 实例来进行查询，可以指定是否按顺序匹配、slop、gap 270 271 */ 272 @Test 273 public void spanNearQuery() { 274 try { 275 // SpanNearQuery 临近查询 276 SpanTermQuery tq1 = new SpanTermQuery(new Term("bookcontent", "中央电视台")); 277 SpanTermQuery tq2 = new SpanTermQuery(new Term("bookcontent", "无锡")); 278 SpanNearQuery spanNearQuery = new SpanNearQuery( 279 new SpanQuery[] { tq1, tq2 }, 0, true); 280 // SpanNearQuery 临近查询 gap slop 使用 281 SpanNearQuery.Builder spanNearQueryBuilder = SpanNearQuery 282 .newOrderedNearQuery("bookcontent"); 283 spanNearQueryBuilder.addClause(tq1).addGap(0).setSlop(1) 284 .addClause(tq2); 285 SpanNearQuery spanNearQuery5 = spanNearQueryBuilder.build(); 286 // IndexSearcher searcher = getIndexSearcher(); 287 // TopDocs topDocs = searcher.search(spanNearQueryBuilder, 10); 288 doSearch(spanNearQuery); 289 } catch (Exception e) { 290 e.printStackTrace(); 291 } 292 } 293 294 /** 295 * 词项范围查询 296 * 用于查询包含某个范围内的词项的文档，如以字母开头a到c的词项。词项在反向索引中是排序的，只需指定的开始词项、结束词项，就可以查询该范围的词项。 297 298 * 如果是做数值的范围查询则用 PointRangeQuery 299 300 * 参数说明: 301 302 * 第1个参数：要查询的字段-field 303 304 * 第2个参数:：下边界词-lowerTerm 305 306 * 第3个参数：上边界词-upperTerm 307 308 * 第4个参数：是否包含下边界-includeLower 309 310 * 第5个参数：是否包含上边界 includeUpper 311 312 */ 313 314 @Test 315 316 public void termRangeQuery() { 317 318 try { 319 320 // TermRangeQuery 词项范围查询 321 322 TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange("bookcontent", 323 324 "中央电视台", "同名小说改编", false, true); 325 326 doSearch(termRangeQuery); 327 328 } catch (Exception e) { 329 330 e.printStackTrace(); 331 332 } 333 334 } 335 336 337 338 /** 339 340 * 前缀查询 341 342 * PrefixQuery：前缀查询，查询包含以xxx为前缀的词项的文档，是通配符查询，如 app，实际是 app* 343 344 */ 345 346 @Test 347 348 public void prefixQuery() { 349 350 try { 351 352 // PrefixQuery 前缀查询 353 354 PrefixQuery prefixQuery = new PrefixQuery(new Term("bookcontent", "中国")); 355 356 doSearch(prefixQuery); 357 358 } catch (Exception e) { 359 360 e.printStackTrace(); 361 362 } 363 364 } 365 366 367 368 /** 369 370 * 通配符查询 371 372 * WildcardQuery：通配符查询， *表示0个或多个字符，?表示1个字符，\是转义符。通配符查询可能会比较慢，不可以通配符开头（那样就是所有词项了） 373 374 */ 375 376 @Test 377 378 public void wildcardQuery() { 379 380 try { 381 382 // WildcardQuery 通配符查询 383 384 WildcardQuery wildcardQuery = new WildcardQuery( 385 386 new Term("bookcontent", "中国*")); 387 388 doSearch(wildcardQuery); 389 390 } catch (Exception e) { 391 392 e.printStackTrace(); 393 394 } 395 396 } 397 398 399 400 /** 401 402 * 正则表达式查询 403 404 * RegexpQuery：正则表达式查询，词项符合某正则表达式 405 406 */ 407 408 @Test 409 410 public void regexpQuery() { 411 412 try { 413 414 // RegexpQuery 正则表达式查询 415 416 RegexpQuery regexpQuery = new RegexpQuery(new Term("bookcontent", "厉害.{4}")); 417 418 doSearch(regexpQuery); 419 420 } catch (Exception e) { 421 422 e.printStackTrace(); 423 424 } 425 426 } 427 428 429 430 431 432 /** 433 434 * 模糊查询 435 436 * 简单地与索引词项进行相近匹配，允许最大2个不同字符。常用于拼写错误的容错：如把 “thinkpad” 拼成 “thinkppd”或 “thinkd”，使用FuzzyQuery 仍可搜索到正确的结果。 437 438 */ 439 440 @Test 441 442 public void fuzzyQuery() { 443 444 try { 445 446 // FuzzyQuery 模糊查询 447 448 FuzzyQuery fuzzyQuery = new FuzzyQuery(new Term("bookcontent", "猪八戒")); 449 450 451 452 FuzzyQuery fuzzyQuery2 = new FuzzyQuery(new Term("bookcontent", "thinkd"), 2); 453 454 455 456 FuzzyQuery fuzzyQuery3 = new FuzzyQuery(new Term("bookcontent", "thinkpaddd")); 457 458 459 460 FuzzyQuery fuzzyQuery4 = new FuzzyQuery(new Term("bookcontent", "thinkdaddd")); 461 462 doSearch(fuzzyQuery); 463 464 } catch (Exception e) { 465 466 e.printStackTrace(); 467 468 } 469 470 } 471 472 473 474 475 476 /** 477 478 * 数值查询 479 480 * 前提：查询的数值字段必须索引。通过 IntPoint, LongPoint, FloatPoint, or DoublePoint 中的方法构建对应的查询。以IntPoint为例： 481 482 */ 483 484 @Test 485 486 public void pointQuery() { 487 488 try { 489 490 // 精确值查询 491 492 Query exactQuery = IntPoint.newExactQuery("bookprice", 123); 493 494 495 496 // 数值范围查询 497 498 Query pointRangeQuery = IntPoint.newRangeQuery("bookprice", 111,134); 499 500 501 502 // 集合查询 503 504 Query setQuery = IntPoint.newSetQuery("bookprice", 1999900, 1000000,2000000); 505 506 doSearch(exactQuery); 507 508 } catch (Exception e) { 509 510 e.printStackTrace(); 511 512 } 513 514 } 515 516 517 518 /** 519 520 * 查询解析生成器 521 522 * QueryParser 查询解析生成器 523 524 * Lucene QueryPaser包中提供了两类查询解析器： 525 526 * A. 传统的解析器：QueryParser和MultiFieldQueryParser 527 528 * B. 基于新的 flexible 框架的解析器：StandardQueryParser 529 530 */ 531 532 @Test 533 534 public void QueryParser() { 535 536 try { 537 538 QueryParser parser = new QueryParser("bookcontent", new IKAnalyzer()); 539 540 //parser.setPhraseSlop(2); 541 542 Query query = parser.parse("中国文艺央视"); 543 544 // sortSearch(query); 545 546 highLightSearch(query); 547 548 } catch (Exception e) { 549 550 e.printStackTrace(); 551 552 } 553 554 } 555 556 557 558 /** 559 560 * 传统解析器-多默认字段 561 562 * B. 基于新的 flexible 框架的解析器：StandardQueryParser 563 564 */ 565 566 @Test 567 568 public void MultiFieldQueryParser() { 569 570 try { 571 572 String[] multiDefaultFields = { "bookname", "booktype", "bookcontent" }; 573 574 org.apache.lucene.queryparser.classic.MultiFieldQueryParser multiFieldQueryParser = new org.apache.lucene.queryparser.classic.MultiFieldQueryParser( 575 576 multiDefaultFields, new IKAnalyzer()); 577 578 // 设置默认的组合操作，默认是 OR 579 580 multiFieldQueryParser.setDefaultOperator(Operator.OR); 581 582 Query query = multiFieldQueryParser.parse("西游记》又称央视86版《西游记》，改编自明12345678901"); 583 584 doSearch(query); 585 586 } catch (Exception e) { 587 588 e.printStackTrace(); 589 590 } 591 592 } 593 594 595 596 /** 597 598 * 新解析框架的标准解析器 599 600 * B. 基于新的 flexible 框架的解析器：StandardQueryParser 601 602 */ 603 604 @Test 605 606 public void StandardQueryParser() { 607 608 try { 609 610 SimpleQueryParser queryParserHelper = new SimpleQueryParser(new IKAnalyzer(),"bookcontent"); 611 612 // 设置默认字段 613 614 // queryParserHelper.setMultiFields(CharSequence[] fields); 615 616 // queryParserHelper.setPhraseSlop(8); 617 618 // Query query = queryParserHelper.parse("a AND b", "defaultField"); 619 620 Query query5 = queryParserHelper.parse("央视"); 621 622 sortSearch(query5); 623 624 } catch (Exception e) { 625 626 e.printStackTrace(); 627 628 } 629 630 } 631 632 633 634 /** 635 636 * 高亮排序查询 637 638 * @throws InvalidTokenOffsetsException 639 640 */ 641 642 private void highLightSearch(Query query) throws InvalidTokenOffsetsException { 643 644 // 获取一个indexReader对象 645 646 try { 647 648 Analyzer ikanalyzer = new IKAnalyzer(); 649 650 IndexSearcher searcher = getIndexSearcher(); 651 652 //true表示降序 653 654 //SortField.Type.SCORE 根据相关度进行排序(默认) 655 656 //SortField.Type.DOC 根据文档编号或者说是索引顺序 657 658 //SortField.Type.FLOAT(Long等),根据fieldName的数值类型进行排序 659 660 SortField sortField = new SortField("bookprice",SortField.Type.INT,false); 661 662 Sort sort = new Sort(sortField); 663 664 665 666 TopDocs topDocs = searcher.search(query, 10, sort); 667 668 System.out.println("数字查询"); 669 670 System.out.println("命中结果数为: "+ topDocs.totalHits); 671 672 // 返回查询结果。遍历查询结果并输出。 673 674 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 675 676 for (ScoreDoc scoreDoc : scoreDocs) { 677 678 int doc = scoreDoc.doc; 679 680 Document document = searcher.doc(doc); 681 682 String text = document.get("bookcontent"); 683 684 SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<font color='red'>", "</font>"); 685 686 Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query)); 687 688 highlighter.setTextFragmenter(new SimpleFragmenter(text.length())); 689 690 if (text != null) { 691 692 TokenStream tokenStream = ikanalyzer.tokenStream("bookcontent", new StringReader(text)); 693 694 String highLightText = highlighter.getBestFragment(tokenStream,text); 695 696 System.out.println("高亮显示第 " + (doc + 1) + " 条检索结果如下所示："); 697 698 System.out.println("bookcontent: "+highLightText); 699 700 } 701 702 703 704 // 打印content字段的值 705 706 System.out.println("bookid: "+document.get("bookid")); 707 708 System.out.println("bookname: "+document.get("bookname")); 709 710 System.out.println("booktype: "+document.get("booktype")); 711 712 System.out.println("bookprice: "+document.get("bookprice")); 713 714 System.out.println("bookdate: "+document.get("bookdate")); 715 716 // System.out.println("bookcontent: "+document.get("bookcontent")); 717 718 System.out.println("查询得分是: "+scoreDoc.score); 719 720 System.out.println("--------------我是分割线------------------"); 721 722 } 723 724 } catch (IOException e) { 725 726 e.printStackTrace(); 727 728 } 729 730 } 731 732 733 734 /** 735 736 * 排序查询 737 738 */ 739 740 private void sortSearch(Query query) { 741 742 // 获取一个indexReader对象 743 744 try { 745 746 IndexSearcher searcher = getIndexSearcher(); 747 748 //true表示降序 749 750 //SortField.Type.SCORE 根据相关度进行排序(默认) 751 752 //SortField.Type.DOC 根据文档编号或者说是索引顺序 753 754 //SortField.Type.FLOAT(Long等),根据fieldName的数值类型进行排序 755 756 SortField sortField = new SortField("bookcontent",SortField.Type.SCORE,false); 757 758 Sort sort = new Sort(sortField); 759 760 761 762 TopDocs topDocs = searcher.search(query, 10, sort); 763 764 System.out.println("数字查询"); 765 766 System.out.println("命中结果数为: "+ topDocs.totalHits); 767 768 // 返回查询结果。遍历查询结果并输出。 769 770 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 771 772 for (ScoreDoc scoreDoc : scoreDocs) { 773 774 int doc = scoreDoc.doc; 775 776 Document document = searcher.doc(doc); 777 778 // 打印content字段的值 779 780 System.out.println("bookid: "+document.get("bookid")); 781 782 System.out.println("bookname: "+document.get("bookname")); 783 784 System.out.println("booktype: "+document.get("booktype")); 785 786 System.out.println("bookprice: "+document.get("bookprice")); 787 788 System.out.println("bookcontent: "+document.get("bookcontent")); 789 790 System.out.println("查询得分是: "+scoreDoc.score); 791 792 System.out.println("--------------我是分割线------------------"); 793 794 } 795 796 } catch (IOException e) { 797 798 e.printStackTrace(); 799 800 } 801 802 } 803 804 805 806 /** 807 808 * 查询打印结果 809 810 */ 811 812 private void doSearch(Query query) { 813 814 // 获取一个indexReader对象 815 816 try { 817 818 IndexSearcher searcher = getIndexSearcher(); 819 820 TopDocs topDocs = searcher.search(query, 10); 821 822 System.out.println("数字查询"); 823 824 System.out.println("命中结果数为: "+ topDocs.totalHits); 825 826 // 返回查询结果。遍历查询结果并输出。 827 828 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 829 830 for (ScoreDoc scoreDoc : scoreDocs) { 831 832 int doc = scoreDoc.doc; 833 834 Document document = searcher.doc(doc); 835 836 // 打印content字段的值 837 838 System.out.println("bookid: "+document.get("bookid")); 839 840 System.out.println("bookname: "+document.get("bookname")); 841 842 System.out.println("booktype: "+document.get("booktype")); 843 844 System.out.println("bookcontent: "+document.get("bookcontent")); 845 846 System.out.println("查询得分是: "+scoreDoc.score); 847 848 System.out.println("--------------我是分割线------------------"); 849 850 } 851 852 } catch (IOException e) { 853 854 e.printStackTrace(); 855 856 } 857 858 } 859 860 861 862 /** 863 864 * 打印查询结果 865 866 */ 867 868 private void printTopDocs(TopDocs topDocs) { 869 870 // 获取一个indexReader对象 871 872 try { 873 874 IndexSearcher searcher = getIndexSearcher(); 875 876 System.out.println("数字查询"); 877 878 System.out.println("命中结果数为: "+ topDocs.totalHits); 879 880 // 返回查询结果。遍历查询结果并输出。 881 882 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 883 884 for (ScoreDoc scoreDoc : scoreDocs) { 885 886 int doc = scoreDoc.doc; 887 888 Document document = searcher.doc(doc); 889 890 // 打印content字段的值 891 892 System.out.println("bookid: "+document.get("bookid")); 893 894 System.out.println("bookname: "+document.get("bookname")); 895 896 System.out.println("booktype: "+document.get("booktype")); 897 898 System.out.println("bookcontent: "+document.get("bookcontent")); 899 900 } 901 902 } catch (IOException e) { 903 904 e.printStackTrace(); 905 906 } 907 908 } 909 910 911 912 }
1.1.17. MatchAllDocsQuery
1 /** 2 3 * 查询所有文档 4 5 * @throws ParseException 6 7 * @throws IOException 8 9 */ 10 11 @Test 12 13 public void testMatchAllDocsQuery() throws ParseException, IOException { 14 15 Query query = new MatchAllDocsQuery(); 16 17 IndexSearcher searcher = getIndexSearcher(); 18 19 TopDocs topDocs = searcher.search(query, 10); 20 21 22 23 // 返回查询结果。遍历查询结果并输出。 24 25 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 26 27 for (ScoreDoc scoreDoc : scoreDocs) { 28 29 int doc = scoreDoc.doc; 30 31 Document document = searcher.doc(doc); 32 33 // 打印content字段的值 34 35 System.out.println("bookid: "+document.get("bookid")); 36 37 System.out.println("bookname: "+document.get("bookname")); 38 39 System.out.println("booktype: "+document.get("booktype")); 40 41 System.out.println("bookcontent: "+document.get("bookcontent")); 42 43 } 44 45 }
1.1.18. MatchNoDocsQuery
1 /** 2 3 * 不匹配任何文档（好像没什么用） 4 5 * @throws ParseException 6 7 * @throws IOException 8 9 */ 10 11 @Test 12 13 public void testMatchNoDocsQuery() throws ParseException, IOException { 14 15 Query query = new MatchNoDocsQuery(); 16 17 IndexSearcher searcher = getIndexSearcher(); 18 19 TopDocs topDocs = searcher.search(query, 10); 20 21 22 23 // 返回查询结果。遍历查询结果并输出。 24 25 ScoreDoc[] scoreDocs = topDocs.scoreDocs; 26 27 for (ScoreDoc scoreDoc : scoreDocs) { 28 29 int doc = scoreDoc.doc; 30 31 Document document = searcher.doc(doc); 32 33 // 打印content字段的值 34 35 System.out.println("bookid: "+document.get("bookid")); 36 37 System.out.println("bookname: "+document.get("bookname")); 38 39 System.out.println("booktype: "+document.get("booktype")); 40 41 System.out.println("bookcontent: "+document.get("bookcontent")); 42 43 } 44 45 }