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");
}

}