lucene-构建各种Lucene Query

搜索流程中的第二步就是构建一个Query。下面就来介绍Query及其构建。

当用户输入一个关键字,搜索引擎接收到后,并不是立刻就将它放入后台开始进行关键字的检索,而应当首先对这个关键字进行一定的分析和处理,使之成为一种后台可以理解的形式,只有这样,才能提高检索的效率,同时检索出更加有效的结果。那么,在Lucene中,这种处理,其实就是构建一个Query对象。

就Query对象本身言,它只是Lucene的search包中的一个抽象类,这个抽象类有许多子类,代表了不同类型的检索。如常见的TermQuery就是将一个简单的关键字进行封装后的对象,类似的还有BooleanQuery,即布尔型的查找。

IndexSearcher对象的search方法中总是需要一个Query对象(或是Query子类的对象),本节就来介绍各种Query类。

11.4.1按词条搜索—TermQuery

TermQuery是最简单、也是最常用的Query。TermQuery可以理解成为“词条搜索”,在搜索引擎中最基本的搜索就是在索引中搜索某一词条,而TermQuery就是用来完成这项工作的。

在Lucene中词条是最基本的搜索单位,从本质上来讲一个词条其实就是一个名/值对。只不过这个“名”是字段名,而“值”则表示字段中所包含的某个关键字。

要使用TermQuery进行搜索首先需要构造一个Term对象,示例代码如下:

TermaTerm=newTerm("contents","java");

然后使用aTerm对象为参数来构造一个TermQuery对象,代码设置如下:

Queryquery=newTermQuery(aTerm);

这样所有在“contents”字段中包含有“java”的文档都会在使用TermQuery进行查询时作为符合查询条件的结果返回。

下面就通过代码11.4来介绍TermQuery的具体实现过程。

代码11.4TermQueryTest.java

packagech11;

importorg.apache.lucene.analysis.standard.StandardAnalyzer;

importorg.apache.lucene.document.Document;

importorg.apache.lucene.document.Field;

importorg.apache.lucene.index.IndexWriter;

importorg.apache.lucene.index.Term;

importorg.apache.lucene.search.Hits;

importorg.apache.lucene.search.IndexSearcher;

importorg.apache.lucene.search.Query;

importorg.apache.lucene.search.TermQuery;

publicclassTermQueryTest

{

publicstaticvoidmain(String[]args)throwsException

{

//生成Document对象

Documentdoc1=newDocument();

//添加“name”字段的内容

doc1.add(Field.Text("name","word1word2word3"));

//添加“title”字段的内容

doc1.add(Field.Keyword("title","doc1"));

//生成索引书写器

IndexWriterwriter=newIndexWriter("c:\\index",newStandardAnalyzer(),true);

//将文档添加到索引中

writer.addDocument(doc1);

//关闭索引

writer.close();

//生成查询对象query

Queryquery=null;

//生成hits结果对象,保存返回的检索结果

Hitshits=null;

//生成检索器

IndexSearchersearcher=newIndexSearcher("c:\\index");

//构造一个TermQuery对象

query=newTermQuery(newTerm("name","word1"));

//开始检索,并返回检索结果到hits中

hits=searcher.search(query);

//输出检索结果中的相关信息

printResult(hits,"word1");

//再次构造一个TermQuery对象,只不过查询的字段变成了"title"

query=newTermQuery(newTerm("title","doc1"));

//开始第二次检索,并返回检索结果到hits中

hits=searcher.search(query);

//输出检索结果中的相关信息

printResult(hits,"doc1");

}

publicstaticvoidprintResult(Hitshits,Stringkey)throwsException

{

System.out.println("查找\""+key+"\":");

if(hits!=null)

{

if(hits.length()==0)

{

System.out.println("没有找到任何结果");

}

else

{

System.out.println("找到"+hits.length()+"个结果");

for(inti=0;i<hits.length();i++)

{

Documentd=hits.doc(i);

Stringdname=d.get("title");

System.out.print(dname+"");

}

System.out.println();

System.out.println();

}

}

}

}

在代码11.4中使用TermQuery进行检索的运行结果如图11-8所示。

文本框:图11-8TermQuery的测试注意:字段值是区分大小写的,因此在查询时必须注意大小写的匹配。

从图11-8中可以看出,代码11.4两次分别以“word1”和“doc1”为关键字进行检索,并且都只得到了一个检索结果。

在代码11.4中通过构建TermQuery的对象,两次完成了对关键字的查找。两次查找过程中不同的是,第一次构建的TermQuery是查找“name”这个字段,而第二次构建的TermQuery则查找的是“title”这个字段。

11.4.2“与或”搜索—BooleanQuery

BooleanQuery也是实际开发过程中经常使用的一种Query。它其实是一个组合的Query,在使用时可以把各种Query对象添加进去并标明它们之间的逻辑关系。在本节中所讨论的所有查询类型都可以使用BooleanQuery综合起来。BooleanQuery本身来讲是一个布尔子句的容器,它提供了专门的API方法往其中添加子句,并标明它们之间的关系,以下代码为BooleanQuery提供的用于添加子句的API接口:

publicvoidadd(Queryquery,booleanrequired,booleanprohibited);

注意:BooleanQuery是可以嵌套的,一个BooleanQuery可以成为另一个BooleanQuery的条件子句。

下面以11.5为例来介绍进行“与”操作的布尔型查询。

代码11.5BooleanQueryTest1.java

packagech11;

importorg.apache.lucene.analysis.standard.StandardAnalyzer;

importorg.apache.lucene.document.Document;

importorg.apache.lucene.document.Field;

importorg.apache.lucene.index.IndexWriter;

importorg.apache.lucene.index.Term;

importorg.apache.lucene.search.BooleanQuery;

importorg.apache.lucene.search.Hits;

importorg.apache.lucene.search.IndexSearcher;

importorg.apache.lucene.search.Query;

importorg.apache.lucene.search.TermQuery;

publicclassBooleanQueryTest1

{

publicstaticvoidmain(String[]args)throwsException{

//生成新的Document对象

Documentdoc1=newDocument();

doc1.add(Field.Text("name","word1word2word3"));

doc1.add(Field.Keyword("title","doc1"));

Documentdoc2=newDocument();

doc2.add(Field.Text("name","word1word4word5"));

doc2.add(Field.Keyword("title","doc2"));

Documentdoc3=newDocument();

doc3.add(Field.Text("name","word1word2word6"));

doc3.add(Field.Keyword("title","doc3"));

//生成索引书写器

IndexWriterwriter=newIndexWriter("c:\\index",newStandardAnalyzer(),true);

//添加到索引中

writer.addDocument(doc1);

writer.addDocument(doc2);

writer.addDocument(doc3);

writer.close();

Queryquery1=null;

Queryquery2=null;

BooleanQueryquery=null;

Hitshits=null;

//生成IndexSearcher对象

IndexSearchersearcher=newIndexSearcher("c:\\index");

query1=newTermQuery(newTerm("name","word1"));

query2=newTermQuery(newTerm("name","word2"));

//构造一个布尔查询

query=newBooleanQuery();

//添加两个子查询

query.add(query1,true,false);

query.add(query2,true,false);

hits=searcher.search(query);

printResult(hits,"word1和word2");

}

publicstaticvoidprintResult(Hitshits,Stringkey)throwsException

{

System.out.println("查找\""+key+"\":");

if(hits!=null)

{

if(hits.length()==0)

{

System.out.println("没有找到任何结果");

}

else

{

System.out.println("找到"+hits.length()+"个结果");

for(inti=0;i<hits.length();i++)

{

Documentd=hits.doc(i);

Stringdname=d.get("title");

System.out.print(dname+"");

}

System.out.println();

System.out.println();

}

}

}

}

代码11.5首先构造了两个TermQuery,然后构造了一个BooleanQuery的对象,并将两个TermQuery当成它的查询子句加入Boolean查询中。

再来看一下BooleanQuery的add方法,除了它的第一个参数外,它还有另外两个布尔型的参数。第1个参数的意思是当前所加入的查询子句是否必须满足,第2个参数的意思是当前所加入的查询子句是否不需要满足。这样,当这两个参数分别选择true和false时,会有4种不同的组合。

true&false:表明当前加入的子句是必须要满足的。

false&true:表明当前加入的子句是不可以被满足的。

false&false:表明当前加入的子句是可选的。

true&true:错误的情况。

由前面的示例可以看出由于加入的两个子句都选用了true&false的组合,因此它们两个都是需要被满足的,也就构成了实际上的“与”关系,运行效果如图11-9所示。

如果是要进行“或”运算,则可按如下代码来构建查询子句:

query.add(query1,false,false);

query.add(query2,false,false);

代码的运行效果如图11-10所示。

图11-9BooleanQuery测试1图11-10BooleanQuery测试2

由于布尔型的查询是可以嵌套的,因此可以表示多种条件下的组合。不过,如果子句的数目太多,可能会导致查找效率的降低。因此,Lucene给出了一个默认的限制,就是布尔型Query的子句数目不能超过1024。

11.4.3在某一范围内搜索—RangeQuery

有时用户会需要一种在一个范围内查找某个文档,比如查找某一时间段内的所有文档,此时,Lucene提供了一种名为RangeQuery的类来满足这种需求。

RangeQuery表示在某范围内的搜索条件,实现从一个开始词条到一个结束词条的搜索功能,在查询时“开始词条”和“结束词条”可以被包含在内也可以不被包含在内。它的具体用法如下:

RangeQueryquery=newRangeQuery(begin,end,included);

在参数列表中,最后一个boolean值表示是否包含边界条件本身,即当其为TRUE时,表示包含边界值,用字符可以表示为“[beginTOend]”;当其为FALSE时,表示不包含边界值,用字符可以表示为“{beginTOend}”。

下面通过代码11.6介绍RangeQuery使用的方法。

代码11.6RangeQueryTest.java

packagech11;

importorg.apache.lucene.analysis.standard.StandardAnalyzer;

importorg.apache.lucene.document.Document;

importorg.apache.lucene.document.Field;

importorg.apache.lucene.index.IndexWriter;

importorg.apache.lucene.index.Term;

importorg.apache.lucene.search.Hits;

importorg.apache.lucene.search.IndexSearcher;

importorg.apache.lucene.search.RangeQuery;

publicclassRangeQueryTest{

publicstaticvoidmain(String[]args)throwsException{

//生成文档对象,下同

Documentdoc1=newDocument();

//添加“time”字段中的内容,下同

doc1.add(Field.Text("time","200001"));

//添加“title”字段中的内容,下同

doc1.add(Field.Keyword("title","doc1"));

Documentdoc2=newDocument();

doc2.add(Field.Text("time","200002"));

doc2.add(Field.Keyword("title","doc2"));

Documentdoc3=newDocument();

doc3.add(Field.Text("time","200003"));

doc3.add(Field.Keyword("title","doc3"));

Documentdoc4=newDocument();

doc4.add(Field.Text("time","200004"));

doc4.add(Field.Keyword("title","doc4"));

Documentdoc5=newDocument();

doc5.add(Field.Text("time","200005"));

doc5.add(Field.Keyword("title","doc5"));

//生成索引书写器

IndexWriterwriter=newIndexWriter("c:\\index",newStandardAnalyzer(),true);

//设置为混合索引格式

writer.setUseCompoundFile(true);

//将文档对象添加到索引中

writer.addDocument(doc1);

writer.addDocument(doc2);

writer.addDocument(doc3);

writer.addDocument(doc4);

writer.addDocument(doc5);

//关闭索引

writer.close();

//生成索引搜索器

IndexSearchersearcher=newIndexSearcher("c:\\index");

//构造词条

TermbeginTime=newTerm("time","200001");

TermendTime=newTerm("time","200005");

//用于保存检索结果

Hitshits=null;

//生成RangeQuery对象,初始化为null

RangeQueryquery=null;

//构造RangeQuery对象,检索条件中不包含边界值

query=newRangeQuery(beginTime,endTime,false);

//开始检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"从200001~200005的文档,不包括200001和200005");

//再构造一个RangeQuery对象,检索条件中包含边界值

query=newRangeQuery(beginTime,endTime,true);

//开始第二次检索

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"从200001~200005的文档,包括200001和200005");

}

publicstaticvoidprintResult(Hitshits,Stringkey)throwsException

{System.out.println("查找\""+key+"\":");

if(hits!=null){

if(hits.length()==0){

System.out.println("没有找到任何结果");

}else{

System.out.print("找到");

for(inti=0;i<hits.length();i++){

Documentd=hits.doc(i);

Stringdname=d.get("title");

System.out.print(dname+"");

}

System.out.println();

System.out.println();

}

}

}

}

在上述代码中首先构造了两个Term词条,然后构造了一个RangeQuery对象。在初始化RangeQuery对象的时候,使用构造的两个Term词条作为RangeQuery构造函数的参数。前面已经说过,RangeQuery的构造函数中的两个参数分别称为“开始词条”和“结束词条”,它的含义也就是查找介于这两者之间的所有Document。

构建的Document的“time”字段值均介于200001~200005之间,其检索结果如图11-11所示。

图11-11RangeQuery测试结果

从图11-11中可以看出,在代码11.6中使用RangeQuery共进行了两次检索,第一次的检索条件中不包括边界值,第二次的检索条件中包括边界值。

从代码11.6和图11-11中可以看出,第1次使用FALSE参数构造的RangeQuery对象不包括2个边界值,因此只返回3个Document,而第2次使用TRUE参数构造的RangeQuery则包括2个边界值,因此将5个Document全部返回了。

11.4.4使用前缀搜索—PrefixQuery

PrefixQuery就是使用前缀来进行查找的。通常情况下,首先定义一个词条Term。该词条包含要查找的字段名以及关键字的前缀,然后通过该词条构造一个PrefixQuery对象,就可以进行前缀查找了。

下面以代码11.7为例来介绍使用PrefixQuery进行检索的运行过程。

代码11.7PrefixQueryTest.java

packagech11;

importorg.apache.lucene.analysis.standard.StandardAnalyzer;

importorg.apache.lucene.document.Document;

importorg.apache.lucene.document.Field;

importorg.apache.lucene.index.IndexWriter;

importorg.apache.lucene.index.Term;

importorg.apache.lucene.search.Hits;

importorg.apache.lucene.search.IndexSearcher;

importorg.apache.lucene.search.PrefixQuery;

importorg.apache.lucene.search.RangeQuery;

publicclassPrefixQueryTest{

publicstaticvoidmain(String[]args)throwsException{

//生成Document对象,下同

Documentdoc1=newDocument();

//添加“name”字段的内容,下同

doc1.add(Field.Text("name","David"));

//添加“title”字段的内容,下同

doc1.add(Field.Keyword("title","doc1"));

Documentdoc2=newDocument();

doc2.add(Field.Text("name","Darwen"));

doc2.add(Field.Keyword("title","doc2"));

Documentdoc3=newDocument();

doc3.add(Field.Text("name","Smith"));

doc3.add(Field.Keyword("title","doc3"));

Documentdoc4=newDocument();

doc4.add(Field.Text("name","Smart"));

doc4.add(Field.Keyword("title","doc4"));

//生成索引书写器

IndexWriterwriter=newIndexWriter("c:\\index",

newStandardAnalyzer(),true);

//设置为混合索引模式

writer.setUseCompoundFile(true);

//依次将文档添加到索引中

writer.addDocument(doc1);

writer.addDocument(doc2);

writer.addDocument(doc3);

writer.addDocument(doc4);

//关闭索引书写器

writer.close();

//生成索引搜索器对象

IndexSearchersearcher=newIndexSearcher("c:\\index");

//构造词条

Termpre1=newTerm("name","Da");

Termpre2=newTerm("name","da");

Termpre3=newTerm("name","sm");

//用于保存检索结果

Hitshits=null;

//生成PrefixQuery类型的对象,初始化为null

PrefixQueryquery=null;

query=newPrefixQuery(pre1);

//开始第一次检索,并返回检索结果

hits=searcher.search(query);

//输出相应的检索结果

printResult(hits,"前缀为'Da'的文档");

query=newPrefixQuery(pre2);

//开始第二次检索,并返回检索结果

hits=searcher.search(query);

//输出相应的检索结果

printResult(hits,"前缀为'da'的文档");

query=newPrefixQuery(pre3);

//开始第二次检索,并返回检索结果

hits=searcher.search(query);

//输出相应的检索结果

printResult(hits,"前缀为'sm'的文档");

}

publicstaticvoidprintResult(Hitshits,Stringkey)throwsException

{System.out.println("查找\""+key+"\":");

if(hits!=null){

if(hits.length()==0){

System.out.println("没有找到任何结果");

System.out.println();

}else{

System.out.print("找到");

for(inti=0;i<hits.length();i++){

//取得文档

Documentd=hits.doc(i);

//取得“title”字段的内容

Stringdname=d.get("title");

System.out.print(dname+"");

}

System.out.println();

System.out.println();

}

}

}

}

在上述代码中,首先构造了4个不同的Document。每个Document都有一个名为“name”的字段,其中存储了人物的名称。然后,代码构建了3个不同的词条,分别为“Da”、“da”和“sm”,可以看到,它们正好都是“name”字段中关键字的前缀。

代码的运行结果如图11-12所示。

文本框:图11-12PrefixQuery测试结果从图11-12中可以看出,使用PrefixQuery共进行了3次检索,关键字分别为“Da”、“da”和“sm”,返回的检索结果情况在图中已经有明确的说明。不过,如果使用“Da”作为关键字会没有任何的检索结果,而使用“da”就有检索结果,这个问题将在后面作详细介绍。

从代码11.7和图11-12中可以看出,“da”前缀和“sm”前缀都顺利地找到了它们所在的文档,可是为什么与文档中关键字大小写一致的“Da”却没有找到呢?这是因为Lucene的标准分析器在进行分词过滤时将所有的关键字一律转成了小写,所以才会出现这样的结果。这也是开发者应当引起注意的地方。

11.4.5多关键字的搜索—PhraseQuery

除了普通的TermQuery外,Lucene还提供了一种Phrase查询的功能。用户在搜索引擎中进行搜索时,常常查找的并非是一个简单的单词,很有可能是几个不同的关键字。这些关键字之间要么是紧密相联,成为一个精确的短语,要么是可能在这几个关键字之间还插有其他无关的关键字。此时,用户希望将它们找出来。不过很显然,从评分的角度看,这些关键字之间拥有与查找内容无关短语所在的文档的分值一般会较低一些。

PhraseQuery正是Lucene所提供的满足上述需求的一种Query对象。它的add方法可以让用户往其内部添加关键字,在添加完毕后,用户还可以通过setSlop()方法来设定一个称之为“坡度”的变量来确定关键字之间是否允许、允许多少个无关词汇的存在。

下面以代码11.8为例对PhraseQuery进行介绍。

代码11.8PhraseQueryTest.java

packagech11;

importorg.apache.lucene.analysis.standard.StandardAnalyzer;

importorg.apache.lucene.document.Document;

importorg.apache.lucene.document.Field;

importorg.apache.lucene.index.IndexWriter;

importorg.apache.lucene.index.Term;

importorg.apache.lucene.search.Hits;

importorg.apache.lucene.search.IndexSearcher;

importorg.apache.lucene.search.PhraseQuery;

importorg.apache.lucene.search.PrefixQuery;

publicclassPhraseQueryTest{

publicstaticvoidmain(String[]args)throwsException{

//生成Document对象

Documentdoc1=newDocument();

//添加“content”字段的内容

doc1.add(Field.Text("content","davidmarysmithrobert"));

//添加“title”字段的内容

doc1.add(Field.Keyword("title","doc1"));

//生成索引书写器

IndexWriterwriter=newIndexWriter("c:\\index",

newStandardAnalyzer(),true);

//设置为混合索引格式

writer.setUseCompoundFile(true);

//将文档添加到索引中

writer.addDocument(doc1);

//关闭索引

writer.close();

//生成索引搜索器

IndexSearchersearcher=newIndexSearcher("c:\\index");

//构造词条

Termword1=newTerm("content","david");

Termword2=newTerm("content","mary");

Termword3=newTerm("content","smith");

Termword4=newTerm("content","robert");

//用于保存检索结果

Hitshits=null;

//生成PhraseQuery对象,初始化为null

PhraseQueryquery=null;

//第一种情况,两个词本身紧密相连,先设置坡度为0,再设置坡度为2

query=newPhraseQuery();

query.add(word1);

query.add(word2);

//设置坡度

query.setSlop(0);

//开始检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"'david'与'mary'紧紧相隔的Document");

//再次设置坡度

query.setSlop(2);

//开始第二次检索

hits=searcher.search(query);

//输出检索结果

printResult(hits,"'david'与'mary'中相隔两个词的短语");

//第二种情况,两个词本身相隔两个词,先设置坡度为0,再设置坡度为2

query=newPhraseQuery();

query.add(word1);

query.add(word4);

//设置坡度

query.setSlop(0);

//开始第三次检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果

printResult(hits,"'david'与'robert'紧紧相隔的Document");

//设置坡度

query.setSlop(2);

//开始第四次检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果

printResult(hits,"'david'与'robert'中相隔两个词的短语");

}

publicstaticvoidprintResult(Hitshits,Stringkey)throwsException

{System.out.println("查找\""+key+"\":");

if(hits!=null){

if(hits.length()==0){

System.out.println("没有找到任何结果");

System.out.println();

}else{

System.out.print("找到");

for(inti=0;i<hits.length();i++){

//取得文档对象

Documentd=hits.doc(i);

//取得“title”字段的内容

Stringdname=d.get("title");

//输出相关的信息

System.out.print(dname+"");

}

System.out.println();

System.out.println();

}

}

}

}

在上述代码中创建了一个Document,这个Document的“content”域中含有4个关键字。接下来,代码创建了一个PhraseQuery对象,首先将前两个紧紧相连关键字放入其中,并设置它们的坡度值分别为0和2,接下来,又将第一个和最后一个关键字放入其中,同样设置它们的坡度值为0和2。

代码11.8的运行效果,如图11-13所示。

文本框:图11-13PhraseQuery的测试效果从图11.8中可以看出,代码11.8共进行了4次检索测试,并且分两组分别对检索结果进行对比。

从代码11.8和图11-13中可以看出,对两个紧连的关键字来说无论将坡度设置为多少,Lucene总能找到它所在的文档,而对两个不紧连的关键字,如果坡度值小于它们之间无关词的数量,那么则无法找到。其实,当两个关键字之间的无关词数小于等于坡度值时,总是可以被找到。

11.4.6使用短语缀搜索—PhrasePrefixQuery

PhrasePrefixQuery与Phrase有些类似。在PhraseQuery中,如果用户想查找短语“davidrobert”,又想查找短语“maryrobert”。那么,他就只能构建两个PhraseQuery,然后再使用BooleanQuery将它们作为其中的子句,并使用“或”操作符来连接,这样就能达到需要的效果。PhrasePrefixQuery可以让用户很方便地实现这种需要。

接下来看看在代码11.9中是如何使用PhrasePrefixQuery来实现的。

代码11.9PhrasePrefixQueryTest.java

packagech11;

importorg.apache.lucene.analysis.standard.StandardAnalyzer;

importorg.apache.lucene.document.Document;

importorg.apache.lucene.document.Field;

importorg.apache.lucene.index.IndexWriter;

importorg.apache.lucene.index.Term;

importorg.apache.lucene.search.Hits;

importorg.apache.lucene.search.IndexSearcher;

importorg.apache.lucene.search.PhrasePrefixQuery;

importorg.apache.lucene.search.PhraseQuery;

importorg.apache.lucene.search.RangeQuery;

publicclassPhrasePrefixQueryTest{

publicstaticvoidmain(String[]args)throwsException{

//生成Document对象

Documentdoc1=newDocument();

//添加“content”字段的内容

doc1.add(Field.Text("content","davidmarysmithrobert"));

//添加“title”字段的内容

doc1.add(Field.Keyword("title","doc1"));

//生成索引书写器对象

IndexWriterwriter=newIndexWriter("c:\\index",

newStandardAnalyzer(),true);

//将文档添加到索引中

writer.addDocument(doc1);

//关闭索引书写器

writer.close();

//生成索引检索器

IndexSearchersearcher=newIndexSearcher("c:\\index");

//构造词条

Termword1=newTerm("content","david");

Termword2=newTerm("content","mary");

Termword3=newTerm("content","smith");

Termword4=newTerm("content","robert");

//用于保存检索结果

Hitshits=null;

//生成PhrasePrefixQuery对象,初始化为null

PhrasePrefixQueryquery=null;

query=newPhrasePrefixQuery();

//加入可能的所有不确定的词

query.add(newTerm[]{word1,word2});

//加入确定的词

query.add(word4);

//设置坡度

query.setSlop(2);

//开始检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"存在短语'davidrobert'或'maryrobert'的文档");

}

publicstaticvoidprintResult(Hitshits,Stringkey)throwsException

{System.out.println("查找\""+key+"\":");

if(hits!=null){

if(hits.length()==0){

System.out.println("没有找到任何结果");

System.out.println();

}else{

System.out.print("找到");

for(inti=0;i<hits.length();i++){

//获取文档对象

Documentd=hits.doc(i);

//取得“title”字段内容

Stringdname=d.get("title");

System.out.print(dname+"");

}

System.out.println();

System.out.println();

}

}

}

}

在上述代码中,首先构建了一个Document,它的“content”字段中包含4个关键字。接下来,构建了一个PhrasePrefixQuery的对象,调用它的add(Term[])方法设定出现在短语中的第一个关键词。由于这个方法的参数类型为一个Term型的数组,所以,它可以设置多个Term,即出现在短语中的第一个词就在这个数组中进行选择。然后,再使用add(Term)方法设置出现在短语中的后一个词。代码的运行结果如图11-14所示。

图11-14PhrasePrefixQuery的测试结果

从图11-14中可以看出,使用PhrasePrefixQuery可以非常容易的实现相关短语的检索功能。

11.4.7相近词语的搜索—FuzzyQuery

FuzzyQuery是一种模糊查询,它可以简单地识别两个相近的词语。下面以11.10为例进行详细介绍。

代码11.10FuzzyQueryTest.java

packagech11;

importorg.apache.lucene.analysis.standard.StandardAnalyzer;

importorg.apache.lucene.document.Document;

importorg.apache.lucene.document.Field;

importorg.apache.lucene.index.IndexWriter;

importorg.apache.lucene.index.Term;

importorg.apache.lucene.search.FuzzyQuery;

importorg.apache.lucene.search.Hits;

importorg.apache.lucene.search.IndexSearcher;

publicclassFuzzyQueryTest{

publicstaticvoidmain(String[]args)throwsException{

//生成Document对象

Documentdoc1=newDocument();

//添加“content”字段的内容

doc1.add(Field.Text("content","david"));

//添加“title”字段的内容

doc1.add(Field.Keyword("title","doc1"));

Documentdoc2=newDocument();

doc2.add(Field.Text("content","sdavid"));

doc2.add(Field.Keyword("title","doc2"));

Documentdoc3=newDocument();

doc3.add(Field.Text("content","davie"));

doc3.add(Field.Keyword("title","doc3"));

//生成索引书写器

IndexWriterwriter=newIndexWriter("c:\\index",

newStandardAnalyzer(),true);

//将文档添加到索引中

writer.addDocument(doc1);

writer.addDocument(doc2);

writer.addDocument(doc3);

//关闭索引写器

writer.close();

//生成索引搜索器

IndexSearchersearcher=newIndexSearcher("c:\\index");

Termword1=newTerm("content","david");

//用于保存检索结果

Hitshits=null;

//生成FuzzyQuery对象,初始化为null

FuzzyQueryquery=null;

query=newFuzzyQuery(word1);

//开始检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"与'david'相似的词");

}

publicstaticvoidprintResult(Hitshits,Stringkey)throwsException

{System.out.println("查找\""+key+"\":");

if(hits!=null){

if(hits.length()==0){

System.out.println("没有找到任何结果");

System.out.println();

}else{

System.out.print("找到");

for(inti=0;i<hits.length();i++){

//取得文档对象

Documentd=hits.doc(i);

//取得“title”字段的内容

Stringdname=d.get("title");

System.out.print(dname+"");

}

System.out.println();

System.out.println();

}

}

}

}

在上述代码中,首先构建了3个Document,这3个Document的“content”字段中都有一个与“david”较为相似的关键字(其中第一个就是david)。然后使用FuzzyQuery来对其进行检索。运行效果如图11-15所示。

文本框:图11-15FuzzyQuery.java从图11-15中可以看出,使用FuzzyQuery可以检索到索引中所有包含与“david”相近词语的文档。

11.4.8使用通配符搜索—WildcardQuery

Lucene也提供了通配符的查询,这就是WildcardQuery。下面以代码11.11为例进行介绍。

代码11.11WildcardQueryTest.java

packagech11;

importorg.apache.lucene.analysis.standard.StandardAnalyzer;

importorg.apache.lucene.document.Document;

importorg.apache.lucene.document.Field;

importorg.apache.lucene.index.IndexWriter;

importorg.apache.lucene.index.Term;

importorg.apache.lucene.search.Hits;

importorg.apache.lucene.search.IndexSearcher;

importorg.apache.lucene.search.WildcardQuery;

publicclassWildcardQueryTest{

publicstaticvoidmain(String[]args)throwsException{

//生成Document对象,下同

Documentdoc1=newDocument();

//添加“content”字段的内容,下同

doc1.add(Field.Text("content","whatever"));

//添加“title”字段的内容,下同

doc1.add(Field.Keyword("title","doc1"));

Documentdoc2=newDocument();

doc2.add(Field.Text("content","whoever"));

doc2.add(Field.Keyword("title","doc2"));

Documentdoc3=newDocument();

doc3.add(Field.Text("content","however"));

doc3.add(Field.Keyword("title","doc3"));

Documentdoc4=newDocument();

doc4.add(Field.Text("content","everest"));

doc4.add(Field.Keyword("title","doc4"));

//生成索引书写器

IndexWriterwriter=newIndexWriter("c:\\index",

newStandardAnalyzer(),true);

//将文档对象添加到索引中

writer.addDocument(doc1);

writer.addDocument(doc2);

writer.addDocument(doc3);

writer.addDocument(doc4);

//关闭索引书写器

writer.close();

//生成索引书写器

IndexSearchersearcher=newIndexSearcher("c:\\index");

//构造词条

Termword1=newTerm("content","*ever");

Termword2=newTerm("content","wh?ever");

Termword3=newTerm("content","h??ever");

Termword4=newTerm("content","ever*");

//生成WildcardQuery对象,初始化为null

WildcardQueryquery=null;

//用于保存检索结果

Hitshits=null;

query=newWildcardQuery(word1);

//开始第一次检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"*ever");

query=newWildcardQuery(word2);

//开始第二次检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"wh?ever");

query=newWildcardQuery(word3);

//开始第三次检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"h??ever");

query=newWildcardQuery(word4);

//开始第四次检索,并返回检索结果

hits=searcher.search(query);

//输出检索结果的相关信息

printResult(hits,"ever*");

}

publicstaticvoidprintResult(Hitshits,Stringkey)throwsException

{System.out.println("查找\""+key+"\":");

if(hits!=null){

if(hits.length()==0){

System.out.println("没有找到任何结果");

System.out.println();

}else{

System.out.print("找到");

for(inti=0;i<hits.length();i++){

//取得文档对象

Documentd=hits.doc(i);

//取得“title”字段的内容

Stringdname=d.get("title");

System.out.print(dname+"");

}

System.out.println();

System.out.println();

}

}

}

}

代码11.11的运行结果如图11-16所示。

文本框:图11-16WildcardQuery的测试结果由上述代码可以看出,通配符“?”代表1个字符,而“*”则代表0至多个字符。不过通配符检索和上面的FuzzyQuery由于需要对字段关键字进行字符串匹配,所以,在搜索的性能上面会受到一些影响。

相关推荐