IndexSearcher类继承自Searcher基类,是Lucene中最重要的一个检索用类。
IndexSearcher类时最重要的就是要告诉它索引存放的路径,只有这样,检索工具才可以定位索引,从而完成查找的任
务。以下是IndexSearcher的所有构造函数:
public IndexSearcher(String path) throws IOException {
this(IndexReader.open(path), true);
}
public IndexSearcher(Directory directory) throws IOException {
this(IndexReader.open(directory), true);
}
public IndexSearcher(IndexReader r) {
this(r, false);
}
private IndexSearcher(IndexReader r, boolean closeReader) {
reader = r;
this.closeReader = closeReader;
}
可以看到,IndexSearcher一共提供了四种构造函数来初始化一个IndexSearcher对象。
第一个方法最为简单,它直接使用了索引存放的路径作为参数来构造对象。
第二种方式则是使用Directory类型的对象来构建IndexSearcher
第三种是直接使用IndexReader来初始化一个IndexSearcher对象。
第四种则是在第三种的基础上加了一个布尔型的开关,用于判断在关闭IndexSearcher时是否要关闭所带的IndexReader对象。
大家可以看出,实际上,无论传入的参数类型是什么,IndexSearcher最终都还是使用IndexReader来作为实际的索引目录读取器。
前三种构造函数均首先根据传入的参数生成一个IndexReader对象,然后调用了第四种构造方法来完成IndexSearcher的初始化工作。在初始化的工作完成后,在进行搜索前还需要构建一个Query对象。关于Query对象的构建将在后面的章节进行详细介绍,这里只介绍IndexSearcher的查找功能使用IndexSearcher来进行检索,首先要初始化IndexSearcher对象,下面以代码11.1为例进行详细介绍。
在初始化的工作完成后,在进行搜索前还需要构建一个Query对象。关于Query对象的构建将在后面的章节进行详细介绍,这里只介绍IndexSearcher的查找功能
使用IndexSearcher来进行检索,首先要初始化IndexSearcher对象,下面以代码11.1为例进行详细介绍。
代码11.1 IndexSearcher的查找
package ch11;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
public class IndexSearcherTest1 {
public static void main(String[] args) throws Exception {
// 构建5个不同的document,每个含有两个字段,其中
// title字段中为该document的名称
// name字段中为索引信息
//新生成一个Document对象doc1
Document doc1 = new Document();
//添加“name”字段的内容
doc1.add(Field.Text("name", "word1 word2 word3"));
//添加“title”字段的内容
doc1.add(Field.Keyword("title", "doc1"));
//新生成一个Document对象doc2
Document doc2 = new Document();
//添加“name”字段的内容
doc2.add(Field.Text("name", "word4 word5 word6"));
//添加“title”字段的内容
doc2.add(Field.Keyword("title", "doc2"));
//新生成一个Document对象doc3
Document doc3 = new Document();
//添加“name”字段的内容
doc3.add(Field.Text("name", "word1 word4"));
//添加“title”字段的内容
doc3.add(Field.Keyword("title", "doc3"));
//新生成一个Document对象doc4
Document doc4 = new Document();
//添加“name”字段的内容
doc4.add(Field.Text("name", "word2 word5"));
//添加“title”字段的内容
doc4.add(Field.Keyword("title", "doc4"));
//新生成一个Document对象doc5
Document doc5 = new Document();
//添加“name”字段的内容
doc5.add(Field.Text("name", "word3 word6"));
//添加“title”字段的内容
doc5.add(Field.Keyword("title", "doc5"));
//生成一个索引书写器
IndexWriter writer = new IndexWriter("c:\\index",
new StandardAnalyzer(), true);
//依次将前面生成的Document对象添加到索引中
writer.addDocument(doc1);
writer.addDocument(doc2);
writer.addDocument(doc3);
writer.addDocument(doc4);
writer.addDocument(doc5);
writer.close();
//生成查询对象
Query query = null;
//生成Hits对象,保存检索返回的结果
Hits hits = null;
// 定义六个查找的关键字
String key1 = "word1";
String key2 = "word2";
String key3 = "word3";
String key4 = "word4";
String key5 = "word5";
String key6 = "word6";
// 初始化IndexSearcher
IndexSearcher searcher = new IndexSearcher("c:\\index");
//第一次检索
query = QueryParser.parse(key1, "name", new StandardAnalyzer());
//返回第一次的检索结果
hits = searcher.search(query);
//输出检索结果的相关信息
printResult(hits, key1);
//第二次检索
query = QueryParser.parse(key2, "name", new StandardAnalyzer());
//返回第二次的检索结果
hits = searcher.search(query);
//输出检索结果的相关信息
printResult(hits, key2);
//第三次检索
query = QueryParser.parse(key3, "name", new StandardAnalyzer());
//返回第三次的检索结果
hits = searcher.search(query);
//输出检索结果的相关信息
printResult(hits, key3);
//第四次检索
query = QueryParser.parse(key4, "name", new StandardAnalyzer());
//返回第四次的检索结果
hits = searcher.search(query);
//输出检索结果的相关信息
printResult(hits, key4);
//第五次检索
query = QueryParser.parse(key5, "name", new StandardAnalyzer());
//返回第五次的检索结果
hits = searcher.search(query);
//输出检索结果的相关信息
printResult(hits, key5);
//第六次检索
query = QueryParser.parse(key6, "name", new StandardAnalyzer());
//返回第六次的检索结果
hits = searcher.search(query);
//输出检索结果的相关信息
printResult(hits, key6);
}
// 输出结果
public static void printResult(Hits hits, String key) throws Exception
{System.out.println("查找 \"" + key + "\" :");
if (hits != null) {
if (hits.length() == 0) {
System.out.println("没有找到任何结果");
} else {
System.out.print("找到");
for (int i = 0; i < hits.length(); i++) {
//取得文档检索结果中的对象
Document d = hits.doc(i);
//取得文档对象“title”字段的内容
String dname = d.get("title");
//输出
System.out.print(dname + " " );
}
System.out.println();
System.out.println();
}
}
}
}
在上述代码中初始化了一个IndexSearcher对象后,按不同的关键字创建了5个不同的Document对象,每个Document对象中包括两个字段,一个字段的名称为name,它表示该Document的名称,另一个则是实际用于检索的字段,它的内容将被分词,然后存入索引。然后调用IndexSearcher的search(Query)方法进行查找,这样就实现了最简单的检索功能。
注意:在IndexSearcher类中也有一个close方法。事实上,它关闭的并非Searcher对象本身,而是关闭Searcher对象内部所带的IndexReader对象。
除了上面的示例,IndexSearcher类的search方法还有多种重载格式,以满足不同情况的需要。具体重载格
从图11-2中可以看出,IndexSearcher类中最简单的search方法,就是在代码11.1中使用的search(Query)方法。其他的各种重载的search方法中有不同的参数。主要是为了完成对检索结果的排序、过滤等功能而设置的。关于IndexSearcher的其他内容,将会在下一章高级搜索技巧中进行介绍。
在搜索完成之后,就需要把搜索结果返回并显示给用户,只有这样才算是完成了搜索的任务。在Lucene中搜索结果的集合是用Hits类的实例来进行表示的。如果读者细心观察图11-2,就会发现,所有的search方法都返回一个类型为Hits的对象。其实在前面各章的代码中,相信读者已经多次看到关于Hits实例的使用。
Hits对象中主要有以下几个经常使用的方法。
length():返回搜索到结果的总数量。
doc(int n):返回第n个文档。
id(int n):返回第n个文档的内部ID号。
score(n):返回第n个文档的得分。
其中,length()方法和doc(intn)方法共同使用,就可以遍历结果集中的所有文档记录。不过有一点值得注意,如果一个结果集含有100000条记录,而Hits对象一次性就把检索结果全部返回,那么这个Hits对象的结果就会大不一样。
在本书中对这个问题做了细致的考虑,它并不是一次性将所有的结果返回,而是采取一种懒惰(Lazy)的方式来加载返回结果,即当用户将要访问某个文档的时候,Hits对象在内部对Lucene的索引又进行了一次检索,才将这个最新的结果返回给用户。有兴趣的读者可以研习Hits的源代码,以获得更多关于检索结果缓存的方法。
关于Hits对象的使用,在前面的章节中已经给出了许多例子,下面将给出一个更高级的使用示例。
在代码11.2中,将介绍提取一个单独的方法来建立索引。该方法总共创建了12个不同的Document,每个Document有两个域,“contents”和“path”,分别表示文档的内容和路径。每个文档的内容中都有一个单词“word”。
代码11.2 Hits对象的使用
package ch11;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Searcher;
public class HitsTest
{
public static void main(String[] args) throws Exception
{
// 构建索引
buildIndex();
// 使用已经存在索引目录
Searcher searcher = new IndexSearcher("c:\\index");
// 使用标准分析器
Analyzer aStandardAnalyzer = new StandardAnalyzer();
// 从标准输入读取查询的字符串
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
while (true)
{
System.out.println("-------------------------------------------------");
System.out.print("Query: ");
//从命令行中输入一字符串,以回车结束
String line = in.readLine();
// 判断是否直接输入的回车
if (line.length() == 0)
break;
// 构造Query对象
Query query = QueryParser.parse(line, "contents", aStandardAnalyzer);
// 输出要搜索的内容
System.out.println("查找 : " + query.toString("contents"));
// 使用Searcher对象的search方法进行搜索,返回的是一个Hits类型的对象
Hits hits = searcher.search(query);
// 使用Hits对象的length()方法,输出搜索到的文档的数量
System.out.println("总共找到 " + hits.length() + " 个文档");
// 定义每次显示的搜索结果数目
final int HITS_PER_PAGE = 10;
// 循环输出
for (int start = 0; start < hits.length(); start += HITS_PER_PAGE)
{
//计算结束的位置
int end = Math.min(hits.length(), start + HITS_PER_PAGE);
for (int i = start; i < end; i++)
{
// 取得搜索结果中的一个文档对象
Document doc = hits.doc(i);
// 输出文档的ID编号
System.out.println("文档的内部ID号:" + hits.id(i));
// 输出文档的评分
System.out.println("文档的分值:" + hits.score(i));
// 输出文档的存放路径
String path = doc.get("path");
if (path != null)
{
System.out.println("路径为:"+path);
}
}
// 判断是否还有结果未输出
if (hits.length() > end)
{
System.out.print("more (y/n) ? ");
line = in.readLine();
if (line.length() == 0 || line.charAt(0) == 'n')
break;
}
}
}
searcher.close();
}
// 构建索引
public static void buildIndex() throws Exception {
//以下步骤同代码11.1中的步骤类似,在此处不再详细解释
Document doc1 = new Document();
doc1.add(Field.Text("contents", "word1 word"));
doc1.add(Field.Keyword("path", "path\\document1.txt"));
Document doc2 = new Document();
doc2.add(Field.Text("contents", "word2 word"));
doc2.add(Field.Keyword("path", "path\\document2.txt"));
Document doc3 = new Document();
doc3.add(Field.Text("contents", "word3 word"));
doc3.add(Field.Keyword("path", "path\\document3.txt"));
Document doc4 = new Document();
doc4.add(Field.Text("contents", "word4 word"));
doc4.add(Field.Keyword("path", "path\\document4.txt"));
Document doc5 = new Document();
doc5.add(Field.Text("contents", "word5 word"));
doc5.add(Field.Keyword("path", "path\\document5.txt"));
Document doc6 = new Document();
doc6.add(Field.Text("contents", "word6 word"));
doc6.add(Field.Keyword("path", "path\\document6.txt"));
Document doc7 = new Document();
doc7.add(Field.Text("contents", "word7 word"));
doc7.add(Field.Keyword("path", "path\\document7.txt"));
Document doc8 = new Document();
doc8.add(Field.Text("contents", "word8 word"));
doc8.add(Field.Keyword("path", "path\\document8.txt"));
Document doc9 = new Document();
doc9.add(Field.Text("contents", "word9 word"));
doc9.add(Field.Keyword("path", "path\\document9.txt"));
Document doc10 = new Document();
doc10.add(Field.Text("contents", "word10 word"));
doc10.add(Field.Keyword("path", "path\\document10.txt"));
Document doc11 = new Document();
doc11.add(Field.Text("contents", "word11 word"));
doc11.add(Field.Keyword("path", "path\\document11.txt"));
Document doc12 = new Document();
doc12.add(Field.Text("contents", "word12 word"));
doc12.add(Field.Keyword("path", "path\\document12.txt"));
IndexWriter writer = new IndexWriter("c:\\index", new StandardAnalyzer(), true);
writer.addDocument(doc1);
writer.addDocument(doc2);
writer.addDocument(doc3);
writer.addDocument(doc4);
writer.addDocument(doc5);
writer.addDocument(doc6);
writer.addDocument(doc7);
writer.addDocument(doc8);
writer.addDocument(doc9);
writer.addDocument(doc10);
writer.addDocument(doc11);
writer.addDocument(doc12);
writer.close();
}
}
在建立完索引后,初始化一个IndexSearcher来进行检索。对于检索结果,在代码中使用了Hits对象所提供的大多数方法,比如获取文档、获取文档ID和获取文档评分等。代码在运行时,首先要求输入要查询的字符串,然后根据输入的查询字符串进行相应的检索,运行结果如图11-3所示。
图11-3 测试结果1
在代码11.2的测试过程中,分别使用了关键字word1、word4和word1 word3 word10。可以看到,IndexSearcher很好地完成了查找的任务。其中通过Hits对象获得文档的ID号、分值等信息。
图11-4是当用户检索关键字“word”时的运行效果,由于结果数量大于10条,而程序设定一次最多显示10条记录,故程序提示用户是否继续显示剩余的记录。如果此时用户输入“y”,则输出结果如图11-5所示。
图11-4 测试结果2 图11-5 测试结果3
在开发Web相关应用时,简便的方法是当某个用户检索完毕后,可直接将返回的Hits对象存入该用户的session中,然后根据用户的需要进行相关查询。不过这里读者要注意的一点,由于Hits对象被放入session中,并不适合存入大量文本。因为若是这样,对用户来说,可能导致浏览器的响应速度极慢,对服务器方来说,可能导致服务器的内容被大量Hits所占用,最终造成服务器的崩溃。
比较好的一种方式,是将Lucene与数据库相结合,在索引中存入一些关键性的ID字段、路径字段或是简单的文本,而真正的数据提取则从数据库中得到。这样一来既可以发挥Lucene优势,也可以使服务器端的压力减轻。