原网址：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");
}
}