Question

如何读取Lucene索引数据

Answer 1

方法一：依次根据每个docid获取文档然后写入txt中，这样的以来，就避免了内存不足的缺点，但是这样单条读取的话，速度上可能会慢一点，但能满足需求无可厚非。伪代码如下
　　Java代码
try{
directory=FSDirectory.open（new File（indexReadPath））；//打开索引文件夹
IndexReader reader=DirectoryReader.open（directory）；//读取目录
IndexSearcher search=new IndexSearcher（reader）；//初始化查询组件
for（int i=0;i
Document doc=search.doc（i）；//依次获取每个docid对应的Document
//可以在此部，做个批量操作，加快写入速度
}
reader.close（）；//关闭资源
directory.close（）；//关闭连接
}catch（Exception e）{
e.printStackTrace（）；
}
try{
directory=FSDirectory.open（new File（indexReadPath））；//打开索引文件夹
IndexReader reader=DirectoryReader.open（directory）；//读取目录
IndexSearcher search=new IndexSearcher（reader）；//初始化查询组件
for（int i=0;i
Document doc=search.doc（i）；//依次获取每个docid对应的Document
//可以在此部，做个批量操作，加快写入速度
}
reader.close（）；//关闭资源
directory.close（）；//关闭连接
}catch（Exception e）{
e.printStackTrace（）；
}
　　Lucene的分页，总的来说有两种形式，小编总结如下图表格。（如果存在不合适之处，欢迎指正！）
编号 方式 优点 缺点
1 在ScoresDocs里进行分页 无需再次查询索引，速度很快 在海量数据时，会内存溢出
2 利用SearchAfter,再次查询分页 适合大批量数据的分页 再次查询，速度相对慢一点，但可以利用缓存弥补
从上图我们可以分析出，ScoreDocs适合在数据量不是很大的场景下进行分页，而SearchAfter则都适合，所以，我们要根据自己的业务需求，合理的选出适合自己的分页方式。
　　在我们了解这2中分页技术的优缺点之后，我们再来探讨下上面那个读2亿数据存入txt文本里，在这里，SocreDocs不适合这种场景，当然如果你内存足够大的话，可以尝试下，通用分页分批读取的方式，可以提升我们的写入效率，效果是比单条单条读取的速度是要快很多的。虽然ScoresDocs的分页方式在本需求上不适合，但是作为示例，下面小编给出使用ScoreDocs进行分页的代码：

Java代码
try{
directory=FSDirectory.open（new File（indexReadPath））；//打开索引文件夹
IndexReader reader=DirectoryReader.open（directory）；//读取目录
IndexSearcher search=new IndexSearcher（reader）；//初始化查询组件
TopDocs all=search.search（new MatchAllDocsQuery（）， 50000）；
int offset=0;//起始位置
int pageSize=30;//分页的条数
int total=30;//结束条数
int z=0;
while（z<=50）{//总分页数
System.out.println（"=============================="）；
pageScoreDocs（offset,total,search, all.scoreDocs）；//调用分页打印
offset=（z*pageSize+pageSize）；//下一页的位置增量
z++;//分页数+1;
total=offset+pageSize;//下一次的结束分页量
}
reader.close（）；//关闭资源
directory.close（）；//关闭连接
}catch（Exception e）{
e.printStackTrace（）；
}
try{
directory=FSDirectory.open（new File（indexReadPath））；//打开索引文件夹
IndexReader reader=DirectoryReader.open（directory）；//读取目录
IndexSearcher search=new IndexSearcher（reader）；//初始化查询组件
TopDocs all=search.search（new MatchAllDocsQuery（）， 50000）；
int offset=0;//起始位置
int pageSize=30;//分页的条数
int total=30;//结束条数
int z=0;
while（z<=50）{//总分页数
System.out.println（"=============================="）；
pageScoreDocs（offset,total,search, all.scoreDocs）；//调用分页打印
offset=（z*pageSize+pageSize）；//下一页的位置增量
z++;//分页数+1;
total=offset+pageSize;//下一次的结束分页量
}
reader.close（）；//关闭资源
directory.close（）；//关闭连接
}catch（Exception e）{
e.printStackTrace（）；
}
　　Java代码
public void pageScoreDocs（int offset,int total,IndexSearcher searcher,ScoreDoc[] doc） throws Exception{
//System.out.println（"offset:"+offset+"===>"+total）；
for（int i=offset;i
//System.out.println（"i"+i+"==>"+doc.length）；
if（i>doc.length-1）{//当分页的长度数大于总数就停止
break;
}else{
Document dosc=searcher.doc（doc[i].doc）；
System.out.println（dosc.get（"name"））；
}
}
public void pageScoreDocs（int offset,int total,IndexSearcher searcher,ScoreDoc[] doc） throws Exception{
//System.out.println（"offset:"+offset+"===>"+total）；
for（int i=offset;i
//System.out.println（"i"+i+"==>"+doc.length）；
if（i>doc.length-1）{//当分页的长度数大于总数就停止
break;
}else{
Document dosc=searcher.doc（doc[i].doc）；
System.out.println（dosc.get（"name"））；
}
}
　　最后我们来看下使用SearcherAfter进行分页的方式，代码如下：

Java代码
try{
directory=FSDirectory.open（new File（indexReadPath））；//打开索引文件夹
IndexReader reader=DirectoryReader.open（directory）；//读取目录
IndexSearcher search=new IndexSearcher（reader）；//初始化查询组件
int pageStart=0;
ScoreDoc lastBottom=null;//相当于pageSize
while（pageStart<10）{//这个只有是paged.scoreDocs.length的倍数加一才有可能翻页操作
TopDocs paged=null;
paged=search.searchAfter（lastBottom, new MatchAllDocsQuery（），null,30）；//查询首次的30条
if（paged.scoreDocs.length==0）{
break;//如果下一页的命中数为0的情况下，循环自动结束
}
page（search,paged）；//分页操作，此步是传到方法里对数据做处理的
pageStart+=paged.scoreDocs.length;//下一次分页总在上一次分页的基础上
lastBottom=paged.scoreDocs[paged.scoreDocs.length-1];//上一次的总量-1,成为下一次的lastBottom
}
reader.close（）；//关闭资源
directory.close（）；//关闭连接
}catch（Exception e）{
e.printStackTrace（）；
}
try{
directory=FSDirectory.open（new File（indexReadPath））；//打开索引文件夹
IndexReader reader=DirectoryReader.open（directory）；//读取目录
IndexSearcher search=new IndexSearcher（reader）；//初始化查询组件
int pageStart=0;
ScoreDoc lastBottom=null;//相当于pageSize
while（pageStart<10）{//这个只有是paged.scoreDocs.length的倍数加一才有可能翻页操作
TopDocs paged=null;
paged=search.searchAfter（lastBottom, new MatchAllDocsQuery（），null,30）；//查询首次的30条
if（paged.scoreDocs.length==0）{
break;//如果下一页的命中数为0的情况下，循环自动结束
}
page（search,paged）；//分页操作，此步是传到方法里对数据做处理的
pageStart+=paged.scoreDocs.length;//下一次分页总在上一次分页的基础上
lastBottom=paged.scoreDocs[paged.scoreDocs.length-1];//上一次的总量-1,成为下一次的lastBottom
}
reader.close（）；//关闭资源
directory.close（）；//关闭连接
}catch（Exception e）{
e.printStackTrace（）；
}

Answer 2

简单地说luncence的索引数据是通过调用IndexReader接口读取的。

lucene的索引一般都比较大，索引数据采用分目录存储，每个存储目录具有一个DocID，因此在实际的使用时需要依次读取所有的目录拼接后再以分页的方式读取。
代码片段：
try{
directory=FSDirectory.open（new
File（indexReadPath））；//打开索引文件夹
IndexReader
reader=DirectoryReader.open（directory）；//读取目录
IndexSearcher search=new
IndexSearcher（reader）；//初始化查询组件
for（int i=0;i
Document
doc=search.doc（i）；//依次获取每个docid对应的Document
}
reader.close（）；//关闭资源
directory.close（）；//关闭连接

}catch（Exception e）{
e.printStackTrace（）；
}

Answer 3

IndexReader有一个“工厂模式”的static interface——IndexReader.Open。定义如下：
#0001 public static IndexReader Open(System.String path)
#0002 public static IndexReader Open(System.IO.FileInfo path)
#0003 public static IndexReader Open(Directory directory)
#0004 private static IndexReader Open(Directory directory, bool closeDirectory)
其中有三个是public的接口，可供调用。打开一个索引，就是这么简单：
#0001 IndexReader reader = IndexReader.Open(index);
实际上，这个打开索引经历了这样的一个过程：
#0001 SegmentInfos infos = new SegmentInfos();
#0002 Directory directory = FSDirectory.GetDirectory(index, false);
#0003 infos.Read(directory);
#0004 bool closeDirectory = false;
#0005 if (infos.Count == 1)
#0006 {
#0007 // index is optimized
#0008 return new SegmentReader(infos, infos.Info(0), closeDirectory);
#0009 }
#0010 else
#0011 {
#0012 IndexReader[] readers = new IndexReader[infos.Count];
#0013 for (int i = 0; i < infos.Count; i++)
#0014 readers[i] = new SegmentReader(infos.Info(i));
#0015 return new MultiReader(directory, infos, closeDirectory, readers);
#0016 }

首先要读入索引的段信息(segment information,
#0001~#0003)，然后看一下有几个段：如果只有一个，那么可能是优化过的，直接读取这一个段就可以(#0008)；否则需要一次读入各个段
(#0013~#0014)，然后再拼成一个MultiReader(#0015)。打开索引文件的过程就是这样。

接下来我们要看看如何读取信息了。用下面这段代码来说明。
#0001 public static void PrintIndex(IndexReader reader)
#0002 {
#0003 //显示有多少个document
#0004 System.Console.WriteLine(reader + "\tNumDocs = " + reader.NumDocs());
#0005 for (int i = 0; i < reader.NumDocs(); i++)
#0006 {
#0007 System.Console.WriteLine(reader.Document(i));
#0008 }
#0009
#0010 //枚举term，获得<document, term freq, position* >信息
#0011 TermEnum termEnum = reader.Terms();
#0012 while (termEnum.Next())
#0013 {
#0014 System.Console.Write(termEnum.Term());
#0015 System.Console.WriteLine("\tDocFreq=" + termEnum.DocFreq());
#0016
#0017 TermPositions termPositions = reader.TermPositions(termEnum.Term());
#0018 int i = 0;
#0019 int j = 0;
#0020 while (termPositions.Next())
#0021 {
#0022
System.Console.WriteLine((i++) + "->" + " DocNo:" +
termPositions.Doc() + ", Freq:" + termPositions.Freq());
#0023 for (j = 0; j < termPositions.Freq(); j++)
#0024 System.Console.Write("[" + termPositions.NextPosition() + "]");
#0025 System.Console.WriteLine();
#0026 }
#0027
#0028 //直接获取 <term freq, document> 的信息
#0029 TermDocs termDocs = reader.TermDocs(termEnum.Term());
#0030 while (termDocs.Next())
#0031 {
#0032 System.Console.WriteLine((i++) + "->" + " DocNo:" + termDocs.Doc() + ", Freq:" + termDocs.Freq());
#0033 }
#0034 }
#0035
#0036 // FieldInfos fieldInfos = reader.fieldInfos;
#0037 // FieldInfo pathFieldInfo = fieldInfos.FieldInfo("path");
#0038
#0039 //显示 term frequency vector
#0040 for (int i = 0; i < reader.NumDocs(); i++)
#0041 {
#0042 //对contents的token之后的term存于了TermFreqVector
#0043 TermFreqVector termFreqVector = reader.GetTermFreqVector(i, "contents");
#0044
#0045 if (termFreqVector == null)
#0046 {
#0047 System.Console.WriteLine("termFreqVector is null.");
#0048 continue;
#0049 }
#0050
#0051 String fieldName = termFreqVector.GetField();
#0052 String[] terms = termFreqVector.GetTerms();
#0053 int[] frequences = termFreqVector.GetTermFrequencies();
#0054
#0055 System.Console.Write("FieldName:" + fieldName);
#0056 for (int j = 0; j < terms.Length; j++)
#0057 {
#0058 System.Console.Write("[" + terms[j] + ":" + frequences[j] + "]");
#0059 }
#0060 System.Console.WriteLine();
#0061 }
#0062 System.Console.WriteLine();
#0063 }

#0004 计算document的个数
#0012~#0034 枚举collection中所有的term
其中#0017~#0026 枚举每个term在出现的document中的所有位置(第几个词，从1开始计数)；#0029~#0033 计算每个term出现在哪些文档和相应的出现频度(即DF和TF)。
#0036~#0037在reader是SegmentReader类型的情况下有效。
#0040~#0061可以快速的读取某篇文档中出现的term和相应的频度。但是这部分需要在建索引时，设置storeTermVector为true。比如
doc.Add(Field.Text("contents", reader, true));
其中的第三项即是。默认为false。
有了这些数据，就可以统计我需要的数据了。