最近在学习Lucene的过程中遇到了需要多域搜索并排序的问题,在网上找了找,资料不是很多,现在都列出来,又需要的可以自己认真看看,都是从其他网站粘贴过来的,所以比较乱,感谢原创的作者们! 
    使用MultiFieldQueryParser类即可。

示例代码:

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

注意: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. QueryParser parser = new QueryParser("title",分词器);
  3. Query titleQuery = parser .parser("中国人民共和国");
  4. booleanQuery.add(titleQuery,....SHOULD);
  5. QueryParser parser = new QueryParser("content",分词器);
  6. Query contentQuery = parser .parser("中国人民共和国");
  7. 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. ; 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. 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. query2 = parser2.parse("\"2\"");
  7. QueryParser parser3 = new QueryParser("adISELL", new Analyzer());
  8. query3 = parser3.parse("\"2\"");
  9. QueryParser parser4 = new QueryParser("adISELL", new Analyzer());
  10. query4 = parser4.parse("\"2\"");
  11. QueryParser parser4 = new QueryParser("adISELL", new Analyzer());
  12. query4 = parser4.parse("\"2\"");
  13. 。。。。
  14. QueryParser parser..n = new QueryParser("adISELL", new Analyzer());
  15. query..n = parser..n.parse("\"2\"");
  16. typeNegativeSearch.add(query,Occur.MUST);
  17. typeNegativeSearch.add(query2,Occur.MUST);
  18. typeNegativeSearch.add(query3,Occur.MUST);
  19. typeNegativeSearch.add(query4,Occur.MUST);
  20. .....
  21. typeNegativeSearch.add(query..n,Occur.MUST);
  22. 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:表示“或”关系,最终检索结果为所有检索子句的并集。

Lucene多字段搜索的更多相关文章

  1. Apache Lucene(全文检索引擎)—搜索

    目录 返回目录:http://www.cnblogs.com/hanyinglong/p/5464604.html 本项目Demo已上传GitHub,欢迎大家fork下载学习:https://gith ...

  2. Apache Solr采用Java开发、基于Lucene的全文搜索服务器

    http://docs.spring.io/spring-data/solr/ 首先介绍一下solr: Apache Solr (读音: SOLer) 是一个开源.高性能.采用Java开发.基于Luc ...

  3. elasticsearch多字段搜索

    https://blog.csdn.net/Ricky110/article/details/78888711 多字段搜索多字符串查询boost 参数 “最佳” 值,较为简单的方式就是不断试错,比较合 ...

  4. Lucene的其他搜索(三)

    生成索引: package com.wp.search; import java.nio.file.Paths; import org.apache.lucene.analysis.Analyzer; ...

  5. ElasticSearch 2 (15) - 深入搜索系列之多字段搜索

    ElasticSearch 2 (15) - 深入搜索系列之多字段搜索 摘要 查询很少是简单的一句话匹配(one-clause match)查询.很多时候,我们需要用相同或不同的字符串查询1个或多个字 ...

  6. 基于 Lucene 的桌面文件搜索

    开源2010年,自己在学习 Lucene 时开发的一款桌面文件搜索工具,这么多年过去了,代码一直静静存放在自己的硬盘上,与其让其沉睡,不如分享出来. 这款工具带有明显的模仿 Everything 的痕 ...

  7. Elasticsearch 全字段搜索_all,query_string查询,不进行分词

    最近在使用ELasitcsearch的时候,需要用到关键字搜索,因为是全字段搜索,就需要使用_all字段的query_string进行搜索. 但是在使用的时候,遇到问题了.我们的业务并不需要分词,我在 ...

  8. [Elasticsearch] 多字段搜索 (五) - 以字段为中心的查询

    以字段为中心的查询(Field-centric Queries) 上述提到的三个问题都来源于most_fields是以字段为中心(Field-centric),而不是以词条为中心(Term-centr ...

  9. [Elasticsearch] 多字段搜索 (一) - 多个及单个查询字符串

    多字段搜索(Multifield Search) 本文翻译自官方指南的Multifield Search一章. 查询很少是只拥有一个match查询子句的查询.我们经常需要对一个或者多个字段使用相同或者 ...

随机推荐

  1. Codeforces 527E Data Center Drama(欧拉回路)

    题意: 给定一个无向图连通图,把这个的无向边变成有向边,并添加最少的有向边使这个图每个结点的出度为偶数. Solution: 题目很长,并且很多条件说的不太直接,确实不太好懂. 首先先看得到的无向图, ...

  2. vim技巧和坑

    VIM的匹配替换功能很快很强大,但是要显示匹配个数就很苦情,要绕个弯子实现:%s/xxx//gn关键是最后的n,代表只报告匹配的个数,而不进行实际的替换. vim v5 强大.. 另外,如果你习惯了w ...

  3. 复制JAVABEAN中的属性到另外一个JAVABEAN中

    下午写了一个属性复制方法,记录如下: class POUtil{ /** * * Function : 将一个source中的属性到复制到dest * @author : Liaokailin * C ...

  4. MYSQL根据分类分组取每组一条数据且按条件能排序的写法

    之前在一个项目的开发中,有遇到要根据分类来分组获取每组一条按某个条件字段排序的数据结果,于是先自己写了一条语句: select * from `表A` GROUP BY `c`; 上面这个语句有可以根 ...

  5. Linux——搭建PHP开发环境第四步:composer

    原文链接:https://my.oschina.net/jiangbianwanghai/blog/473249 1.下载composer.phar [root#localhost opt]# cur ...

  6. springtest+juint开发测试如下:

    项目结构目录如下: UserMapper.java 为接口文件.User 为实体类.UserMapper.xml 为对应mybatis的xml文件.test为对应的测试包 applicationtes ...

  7. Unity问答——NGUI怎么使用按键模拟鼠标点击?

    这篇博客源自我在泰课在线的回答.链接:http://www.taikr.com/group/1/thread/248 问:NGUI怎么模拟用代码模拟控制点击 答: 1. 这个问题问得好.因为在使用按键 ...

  8. Node.js入门实例程序

    在使用Node.js创建实际“Hello, World!”应用程序之前,让我们看看Node.js的应用程序的部分.Node.js应用程序由以下三个重要组成部分: 导入需要模块: 我们使用require ...

  9. BZOJ 1087 互不侵犯

    Description 在\(N \times N\)的棋盘里面放\(K\)个国王,使他们互不攻击,共有多少种摆放方案.国王能攻击到它上下左右,以及左上左下右上右下八个方向上附近的各一个格子,共\(8 ...

  10. BZOJ 1208 宠物收养所

    Description 最近,阿Q开了一间宠物收养所.收养所提供两种服务:收养被主人遗弃的宠物和让新的主人领养这些宠物.每个领养者都希望领养到自己满意的宠物,阿Q根据领养者的要求通过他自己发明的一个特 ...