Lucene多字段搜索

最新推荐文章于 2021-03-15 06:42:40 发布
最新推荐文章于 2021-03-15 06:42:40 发布
阅读量784 收藏
点赞数
分类专栏： 搜索 文章标签： lucene Lucene多字段搜索

多域搜索并排序的问题，都是从其他网站粘贴过来的，所以比较乱，感谢原创的作者们！ 
  多字段搜索 使用MultiFieldQueryParser类即可。 

示例代码： 

  1. package com.lucene.search;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException; 54com.cn  
  5.   
  6. import org.apache.lucene.analysis.standard.StandardAnalyzer;  
  7. import org.apache.lucene.queryParser.MultiFieldQueryParser;  
  8. import org.apache.lucene.search.BooleanClause;  
  9. import org.apache.lucene.search.Hits;  
  10. import org.apache.lucene.search.IndexSearcher;  
  11. import org.apache.lucene.search.Query;  
  12. import org.apache.lucene.store.Directory;  
  13. import org.apache.lucene.store.FSDirectory;  
  14.   
  15. public class Searcher {  
  16.   
  17. feedom.net  
  18.     public static void main(String[] args) throws Exception {  
  19.         File indexDir = new File("C:\\target\\index\\book");  
  20.         if (!indexDir.exists() || !indexDir.isDirectory()) {  
  21.             throw new IOException();  
  22.         }  
  23.         search(indexDir);  
  24.     }  
  25.   
  26.     public static void search(File indexDir) throws Exception {  
  27.   
  28.         Directory fsDir = FSDirectory.getDirectory(indexDir);  
  29.         IndexSearcher searcher = new IndexSearcher(fsDir);  
  30.   
  31.         String[] queries = { "中文版", "8*" };  
  32.         String[] fields = { "name", "isbn" };  
  33.         BooleanClause.Occur[] clauses = { BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD };  
  34.         Query query = MultiFieldQueryParser.parse(queries, fields, clauses, new StandardAnalyzer());  
  35.   
  36.         Hits hits = searcher.search(query);  
  37.         System.out.println("共有" + searcher.maxDoc() + "条索引，命中" + hits.length() + "条");  
  38.         for (int i = 0; i < hits.length(); i++) {  
  39.             int DocId = hits.id(i);  
  40.             String DocName = hits.doc(i).get("name");  
  41.             String DocIsbn = hits.doc(i).get("isbn");  
  42.             String DocPblDt = hits.doc(i).get("pbl_dt");  
  43.             System.out.println(DocId + ":" + DocName + " ISBN:" + DocIsbn + " PBLDT:" + DocPblDt);  
  44.         }  
  45.     }  
  46. }  



  1. package com.lucene.search;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5.   
  6. import org.apache.lucene.analysis.standard.StandardAnalyzer;  
  7. import org.apache.lucene.queryParser.MultiFieldQueryParser;  
  8. import org.apache.lucene.search.BooleanClause;  
  9. import org.apache.lucene.search.Hits;  
  10. import org.apache.lucene.search.IndexSearcher;  
  11. import org.apache.lucene.search.Query;  
  12. import org.apache.lucene.store.Directory;  
  13. import org.apache.lucene.store.FSDirectory;  
  14.   
  15. public class Searcher {  
  16.   
  17.     public static void main(String[] args) throws Exception {  
  18.         File indexDir = new File("C:\\target\\index\\book");  
  19.         if (!indexDir.exists() || !indexDir.isDirectory()) {  
  20.             throw new IOException();  
  21.         }  
  22.         search(indexDir);  
  23.     }  
  24.   
  25.     public static void search(File indexDir) throws Exception {  
  26.   
  27.         Directory fsDir = FSDirectory.getDirectory(indexDir);  
  28.         IndexSearcher searcher = new IndexSearcher(fsDir);  
  29.   
  30.    String[] queries = { "中文版", "8*" };  
  31.    String[] fields = { "name", "isbn" };  
  32.    BooleanClause.Occur[] clauses = { BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD };  
  33.         Query query = MultiFieldQueryParser.parse(queries, fields, clauses, new StandardAnalyzer());  
  34.   
  35.         Hits hits = searcher.search(query);  
  36.         System.out.println("共有" + searcher.maxDoc() + "条索引，命中" + hits.length() + "条");  
  37.         for (int i = 0; i < hits.length(); i++) {  
  38.             int DocId = hits.id(i);  
  39.             String DocName = hits.doc(i).get("name");  
  40.             String DocIsbn = hits.doc(i).get("isbn");  
  41.             String DocPblDt = hits.doc(i).get("pbl_dt");  
  42.             System.out.println(DocId + ":" + DocName + " ISBN:" + DocIsbn + " PBLDT:" + DocPblDt);  
  43.         }  
  44.     }  
  45. }  


注意：BooleanClause.Occur[]数组,它表示多个条件之间的关系： 

BooleanClause.Occur.MUST表示and, feedom.net 

BooleanClause.Occur.MUST_NOT表示not, 54com.cn 

BooleanClause.Occur.SHOULD表示or. 

--------------------------------------------------------------------------------------------------------- 
多个关键字直接的关系是或，所以直接使用多域搜索对象查询出来的结果就是这样。 
更灵活的控制方式为： 

  1. BooleanQuery booleanQuery = new BooleanQuery();   
  2.   
  3. QueryParser parser = new QueryParser("title",分词器);   
  4. Query titleQuery = parser .parser("中国人民共和国");  
  5. booleanQuery.add(titleQuery,....SHOULD);  
  6.   
  7. QueryParser parser = new QueryParser("content",分词器);   
  8. Query contentQuery = parser .parser("中国人民共和国");  
  9. booleanQuery.add(contentQuery ,....SHOULD);   


-------------------------------------------------------------------------------------------------- 

  1. package com.lucene.search;  
  2. import org.apache.lucene.analysis.standard.StandardAnalyzer;   
  3. import org.apache.lucene.document.Document;   
  4. import org.apache.lucene.document.Field;  
  5. import org.apache.lucene.index.IndexWriter;  
  6. import org.apache.lucene.queryParser.MultiFieldQueryParser;  
  7. import org.apache.lucene.search.BooleanClause;  
  8. import org.apache.lucene.search.Hits; import org.apache.lucene.search.IndexSearcher;   
  9. import org.apache.lucene.search.MultiSearcher;   
  10. import org.apache.lucene.search.Query;   
  11. public class Multisearcher {   
  12. private static String INDEX_STORE_PATH1 = "C:\\multi\\1"; private static String INDEX_STORE_PATH2 = "C:\\multi\\2";   
  13. public static void main(String[] args) throws Exception {   
  14. Multisearcher.multisearcher();   
  15. }   
  16. public static void multisearcher() throws Exception {   
  17. IndexWriter writer = new IndexWriter(INDEX_STORE_PATH1, new StandardAnalyzer(), true);   
  18. writer.setUseCompoundFile(false);   
  19. Document doc1 = new Document();   
  20. Field f1 = new Field("bookname", "钢铁是怎样炼成的", Field.Store.YES, Field.Index.TOKENIZED);   
  21. Field f11 = new Field("price", "20.5", Field.Store.YES, Field.Index.UN_TOKENIZED);   
  22. doc1.add(f1); doc1.add(f11);   
  23. Document doc2 = new Document();   
  24. Field f2 = new Field("bookname", "钢铁战士", Field.Store.YES, Field.Index.TOKENIZED);   
  25. Field f22 = new Field("price", "18.4", Field.Store.YES, Field.Index.UN_TOKENIZED);   
  26. doc2.add(f2);   
  27. doc2.add(f22);   
  28. Document doc3 = new Document();   
  29. Field f3 = new Field("bookname", "钢和铁是两种不同的元素", Field.Store.YES, Field.Index.TOKENIZED);   
  30. Field f33 = new Field("price", "7.6", Field.Store.YES, Field.Index.UN_TOKENIZED);   
  31. doc3.add(f3);   
  32. doc3.add(f33);   
  33. writer.addDocument(doc1);   
  34. writer.addDocument(doc2);   
  35. writer.addDocument(doc3);   
  36. writer.close(); //创建第二个索引器；   
  37. IndexWriter writer2 = new IndexWriter(INDEX_STORE_PATH2, new StandardAnalyzer(), true);   
  38. writer2.setUseCompoundFile(false);   
  39. Document doc4 = new Document();   
  40. Field f4 = new Field("bookname", "钢要比铁有更多的元素", Field.Store.YES, Field.Index.TOKENIZED);   
  41. Field f44 = new Field("price", "22.5", Field.Store.YES, Field.Index.UN_TOKENIZED);   
  42. doc4.add(f4); doc4.add(f44);   
  43. Document doc5 = new Document();   
  44. Field f5 = new Field("bookname", "钢和铁是两种重要的金属", Field.Store.YES, Field.Index.TOKENIZED);   
  45. Field f55 = new Field("price", "15.9", Field.Store.YES, Field.Index.UN_TOKENIZED);   
  46. doc5.add(f5); doc5.add(f55); Document doc6 = new Document();   
  47. Field f6 = new Field("bookname", "钢铁是两种重要的金属", Field.Store.YES, Field.Index.TOKENIZED);   
  48. Field f66 = new Field("price", "19.00", Field.Store.YES, Field.Index.UN_TOKENIZED);   
  49. doc6.add(f6);   
  50. doc6.add(f66);   
  51. writer2.addDocument(doc4);   
  52. writer2.addDocument(doc5);   
  53. writer2.addDocument(doc6);   
  54. writer2.close();   
  55. String query1 = "钢";   
  56. String query2 = "[10 TO 20]";//注意格式：中括号还有关键字TO是大写的   
  57. String[] queries = { query1, query2 }; //指定两个域  
  58. Field String field1 = "bookname";   
  59. String field2 = "price";   
  60. String[] fields = { field1, field2 }; //指定查询字句之间的关系   
  61. BooleanClause.Occur[] clauses = {   
  62. BooleanClause.Occur.MUST, BooleanClause.Occur.MUST   
  63. }; //转成多域查询  
  64. MultiFieldQuery Query q = MultiFieldQueryParser.parse(queries, fields, clauses, new StandardAnalyzer()); //打印Query的内容 System.out.println(q.toString()); //创建两个IndexSearcher，以实现在多个索引目录进行查询   
  65. IndexSearcher searcher1 = new IndexSearcher(INDEX_STORE_PATH1);   
  66. IndexSearcher searcher2 = new IndexSearcher(INDEX_STORE_PATH2);   
  67. IndexSearcher[] searchers = { searcher1, searcher2 }; //使用MultiSearcher进行多域搜索   
  68. MultiSearcher searcher = new MultiSearcher(searchers);   
  69. Hits hits = searcher.search(q);   
  70. for (int i = 0; i < hits.length(); i++) {   
  71. System.out.println(hits.doc(i));   
  72. }   
  73. }  
  74. }  


------------------------------------------------------------------------------------------------------------------------------------------ 
默认情况下,IndexSearcher类的search方法返回查询结果时,是按文档的分值排序的,可以使用重载的search方法对结果排序 

IndexSearcher.search(Query,Sort); 

new Sort() 和 Sort.RELEVANCE,以及null一样,采用默认排序,要定义排序字段,方法是将字段传入Sort对象 

  1. Sort sort = new Sort(String field);  



也可以对多个字段排序

  1. Sort sort = new Sort(String[] fields);  



例: 

  1. Sort sort = new Sort(new SortField[]{new SortField(“title”),new SortField(“name”)});  
  2.   
  3. Hits hits=searcher.search(query,Sort);  



多字段查找MultiFieldQueryParser 

只在某些Term中查找,不关心在哪个字段 

  1. Query query = new MultiFieldQueryParser.parse(“word”,new String[]{“title”,”content”},analyzer);  

//在title和content中找word 

多字段时默认是OR关系,要改变它,使用以下方法: 

  1. Query query = MultiFieldQueryParser.parse(“word”,new String[]{“title”,”content”},new int[]{MultiFieldQueryParser.REQUIRED_FIELD,MultiFieldQueryParser.PROHIBITED_FIELD},analyzer);  



其中: 

REQUIRED_FIELD 表示该条件必须有 

PROHIBITED_FIELD 表示必须不含 

搜索多个索引文件MultiSearcher 

1)       建立多个索引:使用不同的索引目录,实例化不同的IndexWriter 

2)       建立多索引搜索器: 

Searcher[] searchers = new SEARCHER[2]; 

Searchers[0] = new IndexSearcher(dir1); //搜索索引目录一 

Searchers[1]= new IndexSearcher(dir2);//搜索索引目录二 

Searcher searcher = new MultiSearcher(serarchers); 

3) 开始查询:Hits hits = searcher.search(query); 
--------------------------------------------------------------------------------------------------------------------------------------- 

  1. BooleanQuery typeNegativeSearch = new BooleanQuery();  
  2. QueryParser parser = new QueryParser("contents", new Analyzer());  
  3.                 parser.setDefaultOperator(QueryParser.AND_OPERATOR);  
  4.                 query = parser.parse(queryString);  
  5.                 QueryParser parser2 = new QueryParser("adISELL", new Analyzer());    
  6.   
  7.               
  8.                 query2 = parser2.parse("\"2\"");     
  9. QueryParser parser3 = new QueryParser("adISELL", new Analyzer());                 
  10.                 query3 = parser3.parse("\"2\"");                
  11. QueryParser parser4 = new QueryParser("adISELL", new Analyzer());                 
  12.                 query4 = parser4.parse("\"2\"");                
  13. QueryParser parser4 = new QueryParser("adISELL", new Analyzer());                 
  14.                 query4 = parser4.parse("\"2\"");     
  15. 。。。。  
  16.      QueryParser parser..n = new QueryParser("adISELL", new Analyzer());             
  17.   
  18.      
  19.                 query..n = parser..n.parse("\"2\"");     
  20.                    
  21.                 typeNegativeSearch.add(query,Occur.MUST);  
  22.                 typeNegativeSearch.add(query2,Occur.MUST);  
  23. typeNegativeSearch.add(query3,Occur.MUST);  
  24.                 typeNegativeSearch.add(query4,Occur.MUST);  
  25. .....  
  26. typeNegativeSearch.add(query..n,Occur.MUST);  
  27.   
  28. hits = searcher.search(typeNegativeSearch);  



1, 几种span的querySpanTermQuery：检索效果完全同TermQuery，但内部会记录一些位置信息 

，供SpanQuery的其它API使用，是其它属于SpanQuery的Query的基础。 
SpanFirstQuery：查找方式为从Field的内容起始位置开始，在一个固定的宽度内查找所指定的 

词条。 
SpanNearQuery：功能类似PharaseQuery。SpanNearQuery查找所匹配的不一定是短语，还有可 

能是另一个SpanQuery的查询结果作为整体考虑，进行嵌套查询。 
SpanOrQuery：把所有SpanQuery查询结果综合起来，作为检索结果。 
SpanNotQuery：从第一个SpanQuery查询结果中，去掉第二个SpanQuery查询结果，作为检索结 

果。 

2, 多条件索引关系 

BooleanClause用于表示布尔查询子句关系的类，包括：BooleanClause.Occur.MUST， 

BooleanClause.Occur.MUST_NOT，BooleanClause.Occur.SHOULD。有以下6种组合： 
1．MUST和MUST：取得连个查询子句的交集。 
2．MUST和MUST_NOT：表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。 
3．MUST_NOT和MUST_NOT：无意义，检索无结果。 
4．SHOULD与MUST、SHOULD与MUST_NOT：SHOULD与MUST连用时，无意义，结果为MUST子句的检索 

结果。与MUST_NOT连用时，功能同MUST。 
5．SHOULD与SHOULD：表示“或”关系，最终检索结果为所有检索子句的并集。

nickname_oo
关注
专栏目录
lucene 多字段查询+文字高亮显示
07-27
NULL 博文链接：https://navylee.iteye.com/blog/740128
Lucene时间区间搜索
08-05
总之，Lucene在C#中的时间区间搜索是通过构建和执行RangeQuery来实现的，这涉及到索引构建、查询解析、时间值的转换和比较等多个环节。合理地利用这些技术，可以有效地提升数据检索的效率和准确性。在实际应用中，还...
lucene简单应用--多字段内容检索
zxw394的专栏
06-26 650
package lucene; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.apache.lucene.analysis.Analyzer; import org.ap
java在文件里搜字段,java – Lucene – 检索文档中多值字段的所有值
weixin_39605278的博客
03-15 121
我在Lucene中添加了一个多值的字段：String categoriesForItem = getCategories(); // returns "category1, category2, cat3" from a DB callString [] categoriesForItems = categoriesForItem.split(",";for(String cat : catego...
多字段搜索策略：Lucene多字段查询优化
本文旨在研究Lucene多字段搜索的优化技术，通过对Lucene的多字段搜索功能进行深入分析，并根据实验结果提出相应的优化方法，从而提高搜索的性能和效果。 ## 1.3 研究意义 对于信息检索系统而言，提高搜索效率和...
用lucene3实现搜索多字段并排序功能.txt
最新发布
09-22
用lucene3实现搜索多字段并排序功能（设置权重）
Lucene全文搜索_LuceneJava全文搜索_
09-30
首先，Lucene的核心概念包括文档（Document）、字段（Field）、索引（Index）和搜索（Search）。文档是信息的基本单位，可以包含多个字段，如标题、内容、作者等。每个字段可以设置不同的分析器来处理不同类型的文本...
Lucene多字段查询&高亮显示
Bart_G的博客
04-08 3440
在百度搜索的时候，查询的关键词会高亮显示 在搜索一个关键词的时候，有可能这个关键词在title和content中，搜索的时候要把结果全部显示出来 实例说明package com.bart.lucene.mutilseacher;import java.util.ArrayList; import java.util.List; import org.apache.lucene.document.Do
Lucene进阶操作，单字段、多字段和布尔搜索
starjuly的专栏
08-30 1645
上一篇文章是入门，现在是进阶，通过项目用到的例子给大家呈现较好的方法。本方法基于Lucene-4.7.2因为项目要用到JDK1.6。 这里使用几个很好用的类，是经过多次试验整理出来的，分别是单字段搜索，多字段搜索以及布尔搜索。
Lucene 多字段，多关键字 查询
yekui的专栏
08-29 1119
mysql 多字段模糊查询   MySQLJava 在最近的一个项目需要实现在单表中对多字段进行同一关键字的模糊查询,查了一下有点收获    Java代码   select * from table where `字段`='值' and concat(`title`,`content`) like '%关键字%'      MySQL单表多字段模糊查询解决方法 2008-...
lucene多字段查询
cool_rain_man的专栏
04-30 2213
BooleanQuery typeNegativeSearch = new BooleanQuery();QueryParser parser = new QueryParser("contents", new Analyzer());parser.setDefaultOperator(QueryParser.AND_OPERATOR);query = parser.parse(queryStri
Lucene之模糊、精确、匹配、范围、多条件查询-yellowcong
热门推荐
12-03 2万+
Lucene的查询方式很 丰富，对于数值类型的数据，采取TermRangeQuery的方式，对于String类型的，就可以采取TermQuery等，查询方式了，可以通过采取合适的查询方式，检索到数据。Queryparser这个查询方式包含了其他几种查询方式。
[ lucene扩展 ] spellChecker原理分析
weixin_34038293的博客
02-14 284
spellChecker是用来对用户输入的“检索内容”进行校正，例如百度上搜索“麻辣将”，他的提示如下图所示：  我们首先借用lucene简单实现该功能。 本文内容如下（简单实现、原理简介、现有问题）     lucene中spellchecker简述 lucene 的扩展包中包含了spellchecker，利用它我们可以方便的实现拼写检查的功能，但是检查的效果（推荐的准确程度...
lucene关于中文分词的问题
tao_wei162的博客
01-11 271
关于中文分词的问题，因为Lucene毕竟是国外的大牛们开发的，显然会比较侧重英文文章，不过还好，在Lucene的下载包里同步了SmartCN的分词器针对中文发行的，每一次Lucene有新的版本发行，这个包同时更新。 笔者比较推荐的中文分词器是IK分词器，在进入正式的讲解之前，我们首先对Lucene里面内置的几个分析器做个了解. 分析器类型 基本介绍 WhitespaceAn...
Lucene实战：多字段、多条件与过滤搜索的关键代码
首先，多字段搜索是通过`MultifieldQueryParser`实现的，它允许用户指定多个搜索字段，以便更全面地匹配查询条件。例如： ```java Query query = multifieldqueryparser.parse("name*", new String[] { "fieldName...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值