lucene 查询 (转载)

原网址:http://hi.baidu.com/lszhuhaichao/blog/item/ccffc7cb858f1514bf09e66f.html

Lucene3.0之查询处理(1):原理2010-03-06 23:37Lucene3.0之查询处理(1):原理

1、 查询的三种方式

①     顺序查询:简单,但查询效率低

②     索引查询:快速,需要基础索引结构支撑

2、 理论模型

①     布尔模型:基于集合论和布尔代数的一种简单检索模型

②     向量模型:查询串和文档之间分配不同的权值,权值大小放映了文档库中的文档与用户查询串的相关度。查询得到的结果文档按照权值计算相关度有关排序,所以向量模型得到的匹配文档可以是全部精确匹配,也可以是部分匹配查询串。

3、 查询流程

用户查询请求输入->查询词频->查询词频出现->查询词格式化->文本库索引匹配->相似度和排序计算->结果排重与生成。

4、 Lucence3.0查询概述

1、 主要利用查询工具IndexSearcher类

这是检索的主要控制和工具,也是所有搜索操作的入口。其构造方法主要有:

IndexSearcher(Directory path)

IndexSearcher(Directory path, boolean readOnly)

IndexSearcher(IndexReader r)

IndexSearcher(IndexReader reader, IndexReader[] subReaders, int[] docStarts)

这里推荐主要使用第1个和第2个构造方法。

2、 其它相关的类

①     Query:抽象类,必须通过一系列子类来表述检索的具体需求。

②     QueryParser:查询分析器。处理用户输入的查询条件。把用户输入的非格式化检索词转化成后台检索可以理解的Query对象

查询最基本的结果返回方式是通过Hits对象来提供。Hits提供了检索查询结果的缓冲,为结果的展示和返回提供支持。Hits中的结果集已经按照相关性进行了排序,前面的文档结果表明与查询词更为相似。

Lucene3.0之查询(2):查询类型1

1、 查询Query对象

Lucnce查询主要有两种方式。一是通过Query子类构造函数方法生成子类。这种方法最大的好处是非常直观,可以根据自己的功能目标挑选合适的子类来够着具体的Query对象。

另一种查询方式是通过QueryParse动态构造查询对象。这种方法使用了parse方法,具体构造的对象类型需要根据查询词的内容来确定。除了少数特殊查询,几乎所有的查询检索都可以通过QueryParser来代替特定子类的构造函数来查询对象生成功能。

2、 最小项查询TermQuery

适合关键字查询文档,大小写敏感。

①     Term term = new Term(“content”, “星期一”);

TermQueryquery = new TermQuery(term);

②     String str = “星期一”;

Analyzer analyzer = new Analyzer();

QueryParser parser = new QueryParser(“content”, analyzer);

Query query = parser.parse(str);

3、 区域范围查询RangeQuery

在年龄、日期、分数、数量等情况下经常会使用到。通常的模式使用起始值和终止值来确定区间。有点类似SQL语句中的between…and…语 句。生成RangeQuery的实例需要两个对应的Term对象分别描述起始点和终止点。另外还要有一个标志参数,用来表明是否包含区间范围的边界。如果 标志参数为true,表明检索查询匹配时需要包含边界,否则为不包含边界。

①     Term termStart = new Term(“weight”, ”40”);

Term termEnd = new Term(“weight”, “50”);

TermRangeQuery query = new TermRangeQuery("numval",lowerTerm,upperTerm,true,true);

②     String str = “{40 TO 50}”;

Analyzer analyzer = new Analyzer();

QueryParser parser = new QueryParser(“content”, analyzer);

Query query = parser.parse(str);

4、 逻辑组合搜索BooleanQuery

①   Term term1 = new Term(“content”, “星期一”);

Term term2 = new Term(“content”, “五月一日”);

TermQuery query1 = new TermQuery(term1);

TermQuery query2 = new TermQuery(term2);

BooleanQuery query = new BooleanQuery();

Query.add(query1.BooleanClause.Occur.MUST);

Query.add(query2.BooleanClause.Occur.MUST);

AND查询:MUST+MUST;NO查询:MUST+MUST_NOT或者SHOULD+MUST_NOT;OR查询:SHOULD+SHOULD;

②     String str = ”(星期一 AND 五月一日)”

Analyzer analyzer = new Analyzer();

QueryParser parser = new QueryParser(“content”, analyzer);

Query query = parser.parse(str);

5、 字串前缀查询RefixQuery

①     使用PrefixQuery构造前缀查询

前缀查询的直接构造方法是使用Term构造一个最小项对象,同时把它作为前缀的生成参数。构造的查询对象提交检索查询,得到的结果以Term项内的文本值为开头字符的所有文章。

Term term = new Term(“content”, “五月一日”);

PrefixQuery query = new PrefixQuery(term);

②     String str = “(五月一日)”;

Analyzer analyzer = new Analyzer();

QueryParser parser = new QueryParser(“content”, analyzer);

Query query = parser.parse(str);

6、 短语搜索PhraseQuery

①     PhraseQuery构造短语查询

Term term1 = new Term(“content”, “星期”);

Term term2 = new Term(“content”, “一”);

PhraseQuery query = new PhraseQuery();

query.add(term1);

query.add(term2);

query.setSlop(1);

PhraseQuery和Boolean的区别:

PhraseQuery对象的查询结果符合关键词的添加次序。BooleanQuery的与检索查询结果范围更大,检索项次序相反的文档也会检索 到。严格的检索词次序匹配会限制使用范围。为了能找到最相近的结果,可以使用setSlop方法,指定小于编辑距离的匹配文档也作为结果出现。

②     QueryParser构造短语查询

用户输入的单个检索项的查询词会通过QueryParser的Parse方法生成TermQuery对象,带空格的多个检索项会生成BooleanQuery对象的与检索。如果要生成PhraseQuery对象,需要给查询间加上双引号。

String str = “\”星期一\””;

Analyzer analyzer = new Analyzer();

QueryParser parser = new QueryParser(“content”, analyzer);

Query query = parser.parse(str);



Lucene3.0之查询(3):查询类型2

7、 模糊查询FuzzyQuery

这种模糊查询搜索是按照检索文本的形似度进行判断的。两个检索器或者字符串的相似是通过编辑距离来判定的。这种编辑距离实际上是表明两个不同的字 符串需要经过多少次编辑和变换才能变为对方。通常的编辑行为包括了增加一个检索项,删除一个检索项,修改一个检索项,与普通的字符串匹配函数不同,模糊搜 索里的编辑距离是以索引项为单位的。

①     FuzzyQuery()

Term term = new Term(“content”, “星期”);

FuzzyQuery query = new FuzzyQuery(term);

②     QueryParser:

查询词后携带“~0.1f”格式的限定。整个查询词不需要专门使用双引号。

String str = “星期一 ~0.1f”;

8、 通配符查询WildcardQuery

?:1个特定字符;*:0个或者多个待定字符。

①     Term term = new Term(“content”, “星期*”);

WildcardQuery query = new WildcardQuery(term);

②     String str = “0*1”;

9、 位置跨度查询SpanQuery

①     SpanTermQuery

SpanTermQuery携带了位置信息的Term对象查询类,单独使用时输出地结果与TermQuery相同。但是它携带的位置信息可以为其 它复杂的SpanQuery提供支持,是跨度检索的基础类。也可以为后续的自定义排序规则提供位置信息,或者用来特殊显示相关结果。

②     SpanFirstQuery

SpanFirstQuery用来指定查询域中前面指定数量索引项的范围内进行检索,提高查询检索效率。如果匹配的检索项在指定范围之外,查询中不会返回该文档作为结果。

Term t = new Term(“content”, str);

SpanTermQuery query = new SpanTermQuery(t);

SpanFirstQuery firstquery = new SpanFirstQuery(query, 2);

③     SpanNearQuery

SpanNearQuery用来指定不同查询检索项在文本中的间隔距离,如果间隔太久,以致超出了参数指定的距离。即使所有检索引都存在,也不能作为结果输出。

查询过程需要生成多个Term对象,利用每个Term对象分别构造SpanTermQuery对象并形成数组。

Term t1 = new Term(“content”, “星期一”);

Term t2 = new Term(“content”, “星期二”);

Term t3 = new Term(“content”, “星期三”);

SpanTermQuery query1 = new SpanTermQuery(t1);

SpanTermQuery query2 = new SpanTermQuery(t2);

SpanTermQuery query3 = new SpanTermQuery(t3);

SpanQuery[] queryarray = new SpanQuery[]{query1, query2, query3};

SpanNearQuery nearQUery = new SpanNearQuery(queryarray, 1, true);

④     SpanNotQuery

SpanNotQuery用来指定查询中,某两个查询对内容会不会发生重叠,如果特定索引项落入到查询的跨度范围内,就把该文档以结果集中排除

使用SpanNearQuery相同。

⑤     SpanOrQuery

SpanOrQuery用来对SpanOrQuery对象进行封装,用来组合其它SpanQuery对象得到满足任一个跨度的查询结果合并后作为整体输出。

使用SpanNearQuery相同。



Lucene3.0之查询(4):实例

package luceneQuery;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Date;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.FuzzyQuery;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.PrefixQuery;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TermRangeQuery;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.search.spans.SpanFirstQuery;
import org.apache.lucene.search.spans.SpanNearQuery;
import org.apache.lucene.search.spans.SpanNotQuery;
import org.apache.lucene.search.spans.SpanOrQuery;
import org.apache.lucene.search.spans.SpanQuery;
import org.apache.lucene.search.spans.SpanTermQuery;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.RAMDirectory;

public class QueryTest {

static String sIndex_Path="E:/index";
static String sText_path="E:/textbook";
static protected String[] keywords = {"001","002","003","004","005"};
static protected String[] textdetail = {"记录 一","记录 二","记录 三","一 2345 记录","记录 新 一"};
static File fIndex_Path=new File(sIndex_Path);
/**===========================================================
* 名称:IndexBuilder
* 功能:构造磁盘索引,添加内容到指定目录,为后继检索查询做好准备
=============================================================**/
public static void IndexBuilder(){
   try{
    Date start = new Date();
    File f=new File(sText_path);
    File[] list=f.listFiles();
    File file2 = new File(sIndex_Path);
    //创建磁盘索引目录
    Directory dir = FSDirectory.open(file2);
    Directory ramdir = new RAMDirectory();
    Analyzer TextAnalyzer = new SimpleAnalyzer();
    //创建磁盘索引
    IndexWriter TextIndex = new IndexWriter(dir, TextAnalyzer, true, IndexWriter.MaxFieldLength.LIMITED);
    //创建内存索引
    IndexWriter RAMTextIndex = new IndexWriter(ramdir,TextAnalyzer,true, IndexWriter.MaxFieldLength.LIMITED);
    for(int i=0;i<list.length;i++){
     Document document = new Document();
     Field field_name = new Field("name", list[1].getName(),
       Field.Store.YES, Field.Index.NOT_ANALYZED);
     document.add(field_name);
     FileInputStream inputfile = new FileInputStream(list[i]);
     int len = inputfile.available();
     byte[] buffer = new byte[len];
     inputfile.read(buffer);
     inputfile.close();

     String contenttext = new String(buffer);
     Field field_content = new Field("content", contenttext,
       Field.Store.YES, Field.Index.ANALYZED);
     document.add(field_content);
   
     Field field_size = new Field("size",String.valueOf(len),Field.Store.YES,Field.Index.NOT_ANALYZED);
     document.add(field_size);
     TextIndex.addDocument(document);
     TextIndex.optimize();
    }
      //关闭磁盘索引
      TextIndex.close();
      Date end = new Date();
      long tm_index = end.getTime()-start.getTime();
      System.out.print("Total Time:(ms)");
      System.out.println(tm_index);
   }catch(IOException e){
    e.printStackTrace();
   }
   System.out.println("index Sccess");
}
/**===================================================================
*名称:LuceneTermQuery
*功能:构造检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
===================================================================**/
public static void LuceneTermQuery(String word){
   try{
    Directory Index_Dir=FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term t = new Term("id", "002");
    TermQuery query = new TermQuery(t);
    System.out.print(query.toString());
    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   }catch(IOException e){
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**===================================================================
*名称:LuceneRangeQuery
*功能:构造范围检索查询器,对指定的索引进行查询,找到指定的文档,并输
===================================================================**/
public static void LuceneRangeQuery(String lowerTerm, String upperTerm){
   try{
    Directory Index_Dir=FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    TermRangeQuery query = new TermRangeQuery("numval",lowerTerm,upperTerm,true,true);
    System.out.print(query.toString());
    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   }catch(IOException e){
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
*名称:LuceneBooleanQuery
*功能:构造布尔检索查询器,对指定的索引进行查询,找到指定的值,并输出相应的结果
=========================================================================**/
public static void LuceneBooleanQuery(){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term1 = new Term("content","记录");
    Term term2 = new Term("content","二");
    TermQuery query1 = new TermQuery(term1);
    TermQuery query2 = new TermQuery(term2);
    BooleanQuery query = new BooleanQuery();
    query.add(query1,BooleanClause.Occur.MUST);
    query.add(query2,BooleanClause.Occur.MUST);
    System.out.println(query.toString());
    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
* 名称:LucenePrefixQuery
* 功能:构造前缀检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
==========================================================================*/
public static void LucenePrefixQuery(String word){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term = new Term("content",word);
    PrefixQuery query = new PrefixQuery(term);
    System.out.println(query.toString());
    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
* 名称:LucenePhraseQuery
* 功能:构造短语检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
==========================================================================*/
public static void LucenePhraseQuery(String word1, String word2){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term1 = new Term("content",word1);
    Term term2 = new Term("content",word2);
    PhraseQuery query = new PhraseQuery();
    query.add(term1);
    query.add(term2);
    System.out.println(query.toString());
    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
* 名称:LuceneFuzzyQuery
* 功能:构造模糊检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
==========================================================================*/
public static void LuceneFuzzyQuery(String word){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term = new Term("content",word);
    FuzzyQuery query = new FuzzyQuery(term);
    System.out.println(query.toString());
    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
* 名称:LuceneWildcardQuery
* 功能:构造通配符检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
==========================================================================*/
public static void LuceneWildcardQuery(String word){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term = new Term("content",word);
    WildcardQuery query = new WildcardQuery(term);
    System.out.println(query.toString());
    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
* 名称:LuceneSpanFirstQuery
* 功能:构造SpanQuery检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
==========================================================================*/
public static void LuceneSpanFirstQuery(String word){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term = new Term("content",word);
    SpanTermQuery query = new SpanTermQuery(term);
    SpanFirstQuery firstquery = new SpanFirstQuery(query,2);
    System.out.println(firstquery.toString());
    ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
* 名称:LuceneSpanNearQuery
* 功能:构造SpanQuery检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
==========================================================================*/
public static void LuceneSpanNearQuery(String word1,String word2,String word3){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term1 = new Term("content",word1);
    Term term2 = new Term("content",word2);
    Term term3 = new Term("content",word3);
    SpanTermQuery query1 = new SpanTermQuery(term1);
    SpanTermQuery query2 = new SpanTermQuery(term2);
    SpanTermQuery query3 = new SpanTermQuery(term3);
    SpanQuery[] queryarray = new SpanQuery[]{query1,query2,query3};
    SpanNearQuery nearquery = new SpanNearQuery(queryarray,1,true);
    System.out.println(nearquery.toString());
    ScoreDoc[] hits = searcher.search(nearquery, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
* 名称:LuceneSpanNotQuery
* 功能:构造SpanQuery检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
==========================================================================*/
public static void LuceneSpanNotQuery(String word1,String word2,String word3){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term1 = new Term("content",word1);
    Term term2 = new Term("content",word2);
    Term term3 = new Term("content",word3);
    SpanTermQuery query1 = new SpanTermQuery(term1);
    SpanTermQuery query2 = new SpanTermQuery(term2);
    SpanTermQuery query3 = new SpanTermQuery(term3);
    SpanQuery[] queryarray = new SpanQuery[]{query1,query2};
    SpanNearQuery nearquery = new SpanNearQuery(queryarray,1,true);
    SpanNotQuery notquery = new SpanNotQuery(nearquery,query3);
    System.out.println(notquery.toString());
    ScoreDoc[] hits = searcher.search(notquery, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}
/**=========================================================================
* 名称:LuceneSpanOrQuery
* 功能:构造SpanQuery检索查询器,对指定的目录进行查询,找到指定的值,并输出相应结果
==========================================================================*/
public static void LuceneSpanOrQuery(String word1,String word2,String word3){
   try {
    Directory Index_Dir = FSDirectory.open(fIndex_Path);
    IndexSearcher searcher = new IndexSearcher(Index_Dir);
    Term term1 = new Term("content",word1);
    Term term2 = new Term("content",word2);
    Term term3 = new Term("content",word3);
    SpanTermQuery query1 = new SpanTermQuery(term1);
    SpanTermQuery query2 = new SpanTermQuery(term2);
    SpanTermQuery query3 = new SpanTermQuery(term3);
    SpanQuery[] queryarray1 = new SpanQuery[]{query1,query2};
    SpanQuery[] queryarray2 = new SpanQuery[]{query2,query3};
    SpanNearQuery nearquery1 = new SpanNearQuery(queryarray1,1,true);
    SpanNearQuery nearquery2 = new SpanNearQuery(queryarray2,1,true);
    SpanOrQuery orquery = new SpanOrQuery(new SpanNearQuery[]{nearquery1,nearquery2});
    System.out.println(orquery.toString());
    ScoreDoc[] hits = searcher.search(orquery, null, 1000).scoreDocs;
    System.out.println("Search result:");
    for (int i = 0; i < hits.length; i++) {
     Document hitDoc = searcher.doc(hits[i].doc);
        System.out.println(hitDoc.get("fieldname"));
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   System.out.println("Search Success");
}

}

posted on 2015-12-10 10:19  1130136248  阅读(206)  评论(0编辑  收藏  举报

导航