安科网

Lucene多字段搜索

ReganHoo

ReganHoo

2011-10-24

关注 关注

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

使用MultiFieldQueryParser类即可。

示例代码：

package com.lucene.search;

import java.io.File;
import java.io.IOException; 54com.cn

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

public class Searcher {

feedom.net
    public static void main(String[] args) throws Exception {
        File indexDir = new File("C:\\target\\index\\book");
        if (!indexDir.exists() || !indexDir.isDirectory()) {
            throw new IOException();
        }
        search(indexDir);
    }

    public static void search(File indexDir) throws Exception {

        Directory fsDir = FSDirectory.getDirectory(indexDir);
        IndexSearcher searcher = new IndexSearcher(fsDir);

        String[] queries = { "中文版", "8*" };
        String[] fields = { "name", "isbn" };
        BooleanClause.Occur[] clauses = { BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD };
        Query query = MultiFieldQueryParser.parse(queries, fields, clauses, new StandardAnalyzer());

        Hits hits = searcher.search(query);
        System.out.println("共有" + searcher.maxDoc() + "条索引，命中" + hits.length() + "条");
        for (int i = 0; i < hits.length(); i++) {
            int DocId = hits.id(i);
            String DocName = hits.doc(i).get("name");
            String DocIsbn = hits.doc(i).get("isbn");
            String DocPblDt = hits.doc(i).get("pbl_dt");
            System.out.println(DocId + ":" + DocName + " ISBN:" + DocIsbn + " PBLDT:" + DocPblDt);
        }
    }
}
package com.lucene.search;

import java.io.File;
import java.io.IOException;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

public class Searcher {

    public static void main(String[] args) throws Exception {
        File indexDir = new File("C:\\target\\index\\book");
        if (!indexDir.exists() || !indexDir.isDirectory()) {
            throw new IOException();
        }
        search(indexDir);
    }

    public static void search(File indexDir) throws Exception {

        Directory fsDir = FSDirectory.getDirectory(indexDir);
        IndexSearcher searcher = new IndexSearcher(fsDir);

   String[] queries = { "中文版", "8*" };
   String[] fields = { "name", "isbn" };
   BooleanClause.Occur[] clauses = { BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD };
        Query query = MultiFieldQueryParser.parse(queries, fields, clauses, new StandardAnalyzer());

        Hits hits = searcher.search(query);
        System.out.println("共有" + searcher.maxDoc() + "条索引，命中" + hits.length() + "条");
        for (int i = 0; i < hits.length(); i++) {
            int DocId = hits.id(i);
            String DocName = hits.doc(i).get("name");
            String DocIsbn = hits.doc(i).get("isbn");
            String DocPblDt = hits.doc(i).get("pbl_dt");
            System.out.println(DocId + ":" + DocName + " ISBN:" + DocIsbn + " PBLDT:" + DocPblDt);
        }
    }
}

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

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

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

BooleanClause.Occur.SHOULD表示or.

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

多个关键字直接的关系是或，所以直接使用多域搜索对象查询出来的结果就是这样。

更灵活的控制方式为：

BooleanQuery booleanQuery = new BooleanQuery(); 

QueryParser parser = new QueryParser("title",分词器); 
Query titleQuery = parser .parser("中国人民共和国");
booleanQuery.add(titleQuery,....SHOULD);

QueryParser parser = new QueryParser("content",分词器); 
Query contentQuery = parser .parser("中国人民共和国");
booleanQuery.add(contentQuery ,....SHOULD);

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

package com.lucene.search;
import org.apache.lucene.analysis.standard.StandardAnalyzer; 
import org.apache.lucene.document.Document; 
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.Hits; import org.apache.lucene.search.IndexSearcher; 
import org.apache.lucene.search.MultiSearcher; 
import org.apache.lucene.search.Query; 
public class Multisearcher { 
private static String INDEX_STORE_PATH1 = "C:\\multi\\1"; private static String INDEX_STORE_PATH2 = "C:\\multi\\2"; 
public static void main(String[] args) throws Exception { 
Multisearcher.multisearcher(); 
} 
public static void multisearcher() throws Exception { 
IndexWriter writer = new IndexWriter(INDEX_STORE_PATH1, new StandardAnalyzer(), true); 
writer.setUseCompoundFile(false); 
Document doc1 = new Document(); 
Field f1 = new Field("bookname", "钢铁是怎样炼成的", Field.Store.YES, Field.Index.TOKENIZED); 
Field f11 = new Field("price", "20.5", Field.Store.YES, Field.Index.UN_TOKENIZED); 
doc1.add(f1); doc1.add(f11); 
Document doc2 = new Document(); 
Field f2 = new Field("bookname", "钢铁战士", Field.Store.YES, Field.Index.TOKENIZED); 
Field f22 = new Field("price", "18.4", Field.Store.YES, Field.Index.UN_TOKENIZED); 
doc2.add(f2); 
doc2.add(f22); 
Document doc3 = new Document(); 
Field f3 = new Field("bookname", "钢和铁是两种不同的元素", Field.Store.YES, Field.Index.TOKENIZED); 
Field f33 = new Field("price", "7.6", Field.Store.YES, Field.Index.UN_TOKENIZED); 
doc3.add(f3); 
doc3.add(f33); 
writer.addDocument(doc1); 
writer.addDocument(doc2); 
writer.addDocument(doc3); 
writer.close(); //创建第二个索引器； 
IndexWriter writer2 = new IndexWriter(INDEX_STORE_PATH2, new StandardAnalyzer(), true); 
writer2.setUseCompoundFile(false); 
Document doc4 = new Document(); 
Field f4 = new Field("bookname", "钢要比铁有更多的元素", Field.Store.YES, Field.Index.TOKENIZED); 
Field f44 = new Field("price", "22.5", Field.Store.YES, Field.Index.UN_TOKENIZED); 
doc4.add(f4); doc4.add(f44); 
Document doc5 = new Document(); 
Field f5 = new Field("bookname", "钢和铁是两种重要的金属", Field.Store.YES, Field.Index.TOKENIZED); 
Field f55 = new Field("price", "15.9", Field.Store.YES, Field.Index.UN_TOKENIZED); 
doc5.add(f5); doc5.add(f55); Document doc6 = new Document(); 
Field f6 = new Field("bookname", "钢铁是两种重要的金属", Field.Store.YES, Field.Index.TOKENIZED); 
Field f66 = new Field("price", "19.00", Field.Store.YES, Field.Index.UN_TOKENIZED); 
doc6.add(f6); 
doc6.add(f66); 
writer2.addDocument(doc4); 
writer2.addDocument(doc5); 
writer2.addDocument(doc6); 
writer2.close(); 
String query1 = "钢"; 
String query2 = "[10 TO 20]";//注意格式：中括号还有关键字TO是大写的 
String[] queries = { query1, query2 }; //指定两个域
Field String field1 = "bookname"; 
String field2 = "price"; 
String[] fields = { field1, field2 }; //指定查询字句之间的关系 
BooleanClause.Occur[] clauses = { 
BooleanClause.Occur.MUST, BooleanClause.Occur.MUST 
}; //转成多域查询
MultiFieldQuery Query q = MultiFieldQueryParser.parse(queries, fields, clauses, new StandardAnalyzer()); //打印Query的内容 System.out.println(q.toString()); //创建两个IndexSearcher，以实现在多个索引目录进行查询 
IndexSearcher searcher1 = new IndexSearcher(INDEX_STORE_PATH1); 
IndexSearcher searcher2 = new IndexSearcher(INDEX_STORE_PATH2); 
IndexSearcher[] searchers = { searcher1, searcher2 }; //使用MultiSearcher进行多域搜索 
MultiSearcher searcher = new MultiSearcher(searchers); 
Hits hits = searcher.search(q); 
for (int i = 0; i < hits.length(); i++) { 
System.out.println(hits.doc(i)); 
} 
}
}

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

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

IndexSearcher.search(Query,Sort);

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

Sort sort = new Sort(String field);
也可以对多个字段排序
Sort sort = new Sort(String[] fields);

例:

Sort sort = new Sort(new SortField[]{new SortField(“title”),new SortField(“name”)});

Hits hits=searcher.search(query,Sort);

多字段查找MultiFieldQueryParser

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

Query query = new MultiFieldQueryParser.parse(“word”,new String[]{“title”,”content”},analyzer);
//在title和content中找word

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

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=newSEARCHER[2];

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

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

Searchersearcher=newMultiSearcher(serarchers);

3)开始查询:Hitshits=searcher.search(query);

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

BooleanQuery typeNegativeSearch = new BooleanQuery();
QueryParser parser = new QueryParser("contents", new Analyzer());
                parser.setDefaultOperator(QueryParser.AND_OPERATOR);
                query = parser.parse(queryString);
                QueryParser parser2 = new QueryParser("adISELL", new Analyzer());  

            
                query2 = parser2.parse("\"2\"");   
QueryParser parser3 = new QueryParser("adISELL", new Analyzer());               
                query3 = parser3.parse("\"2\"");              
QueryParser parser4 = new QueryParser("adISELL", new Analyzer());               
                query4 = parser4.parse("\"2\"");              
QueryParser parser4 = new QueryParser("adISELL", new Analyzer());               
                query4 = parser4.parse("\"2\"");   
。。。。
     QueryParser parser..n = new QueryParser("adISELL", new Analyzer());           

   
                query..n = parser..n.parse("\"2\"");   
                 
                typeNegativeSearch.add(query,Occur.MUST);
                typeNegativeSearch.add(query2,Occur.MUST);
typeNegativeSearch.add(query3,Occur.MUST);
                typeNegativeSearch.add(query4,Occur.MUST);
.....
typeNegativeSearch.add(query..n,Occur.MUST);

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：表示“或”关系，最终检索结果为所有检索子句的并集。

string lucene apache

ReganHoo

ReganHoo

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

消费消息+手动提交+同步异步

package com.perfect.kafka;import java.util.Arrays;Properties props = new Properties();KafkaConsumer<String,String> c = new

hanwentan 2020-07-21

golang的序列化与反序列化的几种方式

golang用来序列化的模块有很多，我们来介绍3个。首先登场的是json，这个几乎毋庸置疑。"Where": "东方地灵殿",当然golang的大小写我们知道是具有含义的，如果改成小写， 那么该字段是无法被序列化的。

Lzs 2020-10-23

Redis中的String类型及使用Redis解决订单秒杀超卖问题

本系列将和大家分享Redis分布式缓存，本章主要简单介绍下Redis中的String类型，以及如何使用Redis解决订单秒杀超卖问题。Redis中5种数据结构之String类型：key-value的缓存，支持过期，value不超过512M。Redis是单线

聚合室 2020-11-16

springboot +redis 实现点赞、浏览、收藏、评论等数量的增减操作

最近做了一个帖子的收藏、点赞数量的功能，其实之前也做过类似的功能，因为之前一直使用的mysql 总是感觉对于这种频繁需要改变的值，不应该给予Mysql过大的压力，本文章采用的是redis 做了持久化。下面贴出关键代码：DataResponse是项目中使用的

零 2020-09-18

Ajax实现登录案例

// String jsonStr = "{\"flag\":false,\"info\":\"用户名已经注册\"}";

baiwen 2020-09-21

php使用event扩展的io复用测试的示例

//sock_set_option; //复用还处于 TIME_WAIT

Nicolase 2020-10-20

Golang和Rust语言常见功能/库

时下最流行、最具发展前途的的两门语言是Golang和Rust。Golang语言简洁、高效、并发、并且有个强大的囊括了常见功能标准库。与之相对比，Rust语言则主要是安全、高性能。虽然Rust没有golang那种"内置电池"的标准库，但是

Justhavefun 2020-10-22

好用到哭！请记住这20段Python代码

Python是一种非BS编程语言。设计简单和易读性是它广受欢迎的两大原因。正如Python的宗旨：美丽胜于丑陋，显式胜于隐式。记住一些帮助提高编码设计的常用小诀窍是有用的。在必要时刻，这些小诀窍能够减少你上网查Stack Overflow的麻烦。而且它们

jacktangj 2020-10-14

[Typescript] Function Overloads

Function overload doesn‘t compile to Javascript, it is just a way to tell typescript about type information

ChaITSimpleLove 2020-10-06

JDBC连接MySQL

String sql = "select * from users where name=?String id = rs.getString;//1代表数据库中表的列数，id在第一列也可以！！！

Andrea0 2020-09-18

Golang面试make和new的用法

在golang中，make和new都分配内存，但是它们之间仍然存在一些差异。只有了解它们之间的差异，才能在适当的场合使用它们。所谓的初始化就是给一个类型赋一个初始值，例如，字符为空，整数为0，逻辑值为false。从Golang的官方文档的builtin中可

周游列国之仕子 2020-09-15

Redis migrate数据迁移工具的使用教程

在工作中可能会遇到单点Redis向Redis集群迁移数据的问题，但又不能老麻烦运维来做。为了方便研发自己迁移数据，我这里写了一个简单的Redis迁移工具，希望对有需要的人有用。该工具已经编译成了多平台命令，直接从Github下载二进制文件执行就好了。把代码

afanti 2020-09-16

关于 JavaScript 错误处理的最完整指南(下半部)

因为使用了 Promise ，所以可以使用 then 来接收返回的内容，或者用 catch 来捕获出现的错误。除了 then 和 catch , Promise 中还有 finally 方法，这类似于try/catch 中的 finally。如果我们失败了

88234852 2020-09-15

基于thinkphp5框架实现微信小程序支付 退款 订单查询 退款查询操作

$return['info'] = '此产品已售完';'out_trade_no' => $order_no_ssh,//$order_no, //订单号 商户订单号

YClimb 2020-09-15

Golang 如何解析和生成json

JSON是一种轻量级的数据交换语言，以文字为基础，具有自我描述性且易于让人阅读。尽管JSON是JavaScript的一个子集，但JSON是独立于语言的文本格式，并且采用了类似于C语言家族的一些习惯。JSON与XML最大的不同在于XML是一个完整的标记语言，

风雨断肠人 2020-09-04

PHP执行普通shell命令流程解析

echo "shell命令{$shell}成功执行";　　注意，system()会将shell命令执行之后，立马显示结果，这一点会比较不方便，因为我们有时候不需要结果立马输出，甚至不需要输出，于是可以用到exec()

卖口粥湛蓝的天空 2020-09-15

php判断IP地址是否在多个IP段内

$int = $ips[0]*256*256*256+$ips[1]*256*256+$ips[2]*256+$ips[3]; //根据IP,a,b,c类进行计算。//将不同的IP段存储到数组中..format=js&ip=".$ip.&

stulen 2020-09-15

Python初学者必学的20个重要技巧

Python是世界上使用最广泛的编程语言之一，原因有很多：易理解、用途非常广泛、包含了大量的模块和库等等。其中，简洁和较高的可读性使Python在所有软件中非常突出。作为一名数据科学家，笔者每天都在使用Python，这是笔者工作的一个重要部分。在这个过程中

pythonxuexi 2020-09-06

源码分析C++的string的实现

我们平时使用C++开发过程中或多或少都会使用std::string，但您了解string具体是如何实现的吗，这里程序喵给大家从源码角度分析一下。string的常见的实现方式有几种？string类的内部结构是什么样子？string内部使用的内存是如何分配管理

abfdada 2020-08-26

想要在JS中把正则玩得飘逸，学会这几个函数的使用必不可少

在之前的一系列文章中，我们讲解了很多关于正则表达式的知识。那么作为一个前端工程师，如果想要把这些知识应用到我们平时的开发中去的话，就需要知道在JavaScript中，能够使用正则的函数有哪些？然后它们各自的功能是什么？有哪些需要注意的地方？只有掌握好了每一

梦的天空 2020-08-25
ReganHoo

ReganHoo

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号