`

Lucene多字段搜索

lucene 
阅读更多
最近在学习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);

new Sort() 和 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 = new SEARCHER[2];

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

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

Searcher searcher = new MultiSearcher(serarchers);

3) 开始查询:Hits hits = 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：表示“或”关系，最终检索结果为所有检索子句的并集。
分享到：
| 大型高并发高负载网站的系统架构
评论
1 楼 dh6129 2011-11-16  
你好，我最近也正在学习lucene，想做一个对数据库中所有表进行索引的应用，但是其中有个问题困扰我很久，特向你请教一下。首先，在建立索引的时候，我们针对每个表都建立了一些Field，然后在检索的时候输入关键字，并在对应的Field中查询。现在困扰我的问题是：当输入关键字的时候，我们如何知道这些关键字对应的是哪个Field？单个字段可以通过遍历每个Doc的Field来解决，但是多个字段的检索呢？如何保证关键字与Field的对应？MultiFieldQueryParser中Field和Key两个数组应该是一一对应的吧。期待您的帮助。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    lucene 多字段查询+文字高亮显示

    总的来说，Lucene的多字段查询和文字高亮显示是提高用户体验和增强搜索功能的关键技术。它们使得用户能够更快地找到相关信息，并且更直观地看到搜索结果中的关键匹配点。通过深入学习和实践，你可以在自己的项目中...

    Lucene全文搜索_LuceneJava全文搜索_

    首先，Lucene的核心概念包括文档（Document）、字段（Field）、索引（Index）和搜索（Search）。文档是信息的基本单位，可以包含多个字段，如标题、内容、作者等。每个字段可以设置不同的分析器来处理不同类型的文本...

    lucene站内搜索

    3. **文档（Document）**: 在Lucene中，每个要搜索的信息被视为一个Document，包含多个Field，如标题、内容、作者等。 4. **字段（Field）**: Field是文档的组成部分，每个字段有特定的属性，如是否存储原始值、...

    Lucene 搜索方法（模糊搜索）

    在IT领域，搜索引擎技术是不可或缺的一部分，而Apache Lucene是一个高性能、全文本搜索库，它为开发者提供了构建自定义搜索引擎应用程序所需的所有工具。本篇我们将深入探讨如何在Lucene中实现模糊搜索，以及相关的...

    Lucene时间区间搜索

    总之，Lucene在C#中的时间区间搜索是通过构建和执行RangeQuery来实现的，这涉及到索引构建、查询解析、时间值的转换和比较等多个环节。合理地利用这些技术，可以有效地提升数据检索的效率和准确性。在实际应用中，还...

    如何使用Lucene的中文分词搜索

    **标题：“如何使用Lucene的中文分词搜索”** 在信息检索和文本处理领域，Apache Lucene是一个强大的全文搜索引擎库，它提供了高级的索引和搜索功能。在处理中文文本时，由于中文句子是由词语组成的，而非单个字符...

    用lucene3实现搜索多字段并排序功能.txt

    用lucene3实现搜索多字段并排序功能（设置权重）

    SpringBoot+Lucene搜索结果高亮显示Demo

    这个SpringBoot+Lucene的Demo为开发者提供了一个起点，可以在此基础上进一步扩展，比如增加对多字段的索引和搜索、支持多种类型的文档、优化查询性能等。通过熟练掌握这些知识，你可以构建出更加强大的全文搜索引擎...

    lucene实现企业搜索实例

    Lucene还提供了许多高级功能，如近实时搜索（NRT）、多字段搜索、模糊查询、短语查询、通配符查询、正向索引、倒排索引等。同时，Lucene支持分布式搜索，通过Solr或Elasticsearch等工具，可以构建大规模的企业级搜索...

    利用Lucene 实现高级搜索

    例如，若文档由多个字段组成，如标题（Title）和内容（Content），则可以通过“Title:Lucene AND Content:Java”这样的查询，精确查找标题中包含“Lucene”，同时内容中包含“Java”的文档。 #### 代码示例 以下是...

    lucene开发WEB搜索引擎

    总结，利用LUCENE.NET开发WEB搜索引擎是一项技术含量高的工作，涉及到数据爬取、文本处理、索引构建、搜索算法等多个环节。通过深入理解和实践，开发者可以构建出高效、灵活的搜索引擎，满足不同场景的需求。

    Lucene 搜索方法（短语搜索）

    本文将聚焦于Lucene中的短语搜索，一种能精确匹配多个词汇顺序的搜索方法。通过分析和实践`DemoData.java`和`PhraseQueryDemo.java`这两个示例代码，我们将深入探讨这一主题。 首先，短语搜索是Lucene中的一种高级...

    Lucene 搜索方法（多短语搜索）

    “Lucene 搜索方法（多短语搜索）”这一标题指出我们要讨论的是如何在Lucene中执行多短语搜索。Lucene是一个高性能、全文本搜索库，它提供了一个强大的文本检索框架，使得开发者能够为他们的应用程序添加高级搜索...

    lucene3.6 搜索例子

    1. 文档创建：在Lucene中，所有的数据都被转化为文档对象，每个文档可以包含多个字段，如标题、正文等。每个字段都有自己的特性，比如是否被索引、是否可搜索、是否存储等。 2. 分析器：在将文本数据添加到索引之前...

    lucene 高级搜索项目

    **Lucene 高级搜索项目概述** Lucene 是一个高性能、全文检索库，它提供了文本分析、索引和搜索功能，被广泛应用于各种搜索引擎的构建。在这个“Lucene 高级搜索项目”中，我们将深入探讨如何利用Lucene实现附件...

    lucene实现全文搜索

    Lucene是一个由Java编写的高性能、可扩展的全文搜索引擎库。它提供了一种机制，使得开发者能够轻松地为自己的应用程序添加索引和搜索功能。作为Apache软件基金会的项目，Lucene具有开源和免费的特性，受到Apache软件...

    基于lucene 的简单搜索引擎.rar

    可以构造复杂的Query，同时搜索多个字段。 **4.4 更新和删除索引** `IndexWriter`允许对已有索引进行更新和删除操作，保持数据同步。 ### 5. 应用场景与挑战 Lucene广泛应用于各种信息检索系统，如网站的站内搜索...

    lucene 实现类似百度搜索

    7. **多字段搜索（Multi-Field Search）**：同时在多个字段中搜索，扩大查询范围。 ### 四、性能调优 1. **内存管理**：合理设置缓存大小，避免内存溢出。 2. **索引分片（Sharding）**：大型数据集时，将索引分散...

    Java搜索引擎 Lucene

    4. **多字段搜索**：允许用户对文档的不同字段进行独立或组合的搜索。 5. **模糊搜索**：支持通配符、短语、近似和模糊搜索，提高搜索灵活性。 6. **高可用性**：Lucene可以与其他Java项目无缝集成，支持多线程和...

    基于LUCENE的搜索引擎的设计与实现源代码

    《基于LUCENE的搜索引擎设计与实现》 在信息技术飞速发展的今天，搜索引擎已经成为人们获取信息的重要工具。本文将深入探讨如何使用Apache LUCENE这一强大的全文搜索引擎库，设计并实现一个高效的搜索引擎。LUCENE...

Magicbox
Global site tag (gtag.js) - Google Analytics