Lucene基础（二）--索引的操作

索引的操作

我们建立所有就是要达到快速检索的目的，对数据能够方面便的查找，和数据库类似，索引也有自己的相关增删改查的操作。

在索引的增删改查中，增删改属于写操作，主要是有IndexWrite提供的方法处理；而查显而易见，读操作，使用IndexSeacher 提供的方法来实现。在Lucene的官方文档找到 org.apache.lucene.index.IndexWriter 这个类，我们就可以看到他很多方法。

创建索引

如同上一章里面的代码，创建索引时先建立文件，创建索引的域，再使用IndexWriter的addDocument（）方法就可以了，核心代码如下:

iwriter = new IndexWriter(directory, new IndexWriterConfig(version, new StandardAnalyzer(version)));
for(String text : content){
doc = new Document();
//使用的field 有很多类型，理解他们的区别 例如：TextField 和 StringField等
doc.add(new TextField("content", text,Field.Store.YES));
iwriter.addDocument(doc);
}

索引删除

索引删除包括只删除索引下面的document和删除索引文件

在IndexWriter有如下一些方法

deleteAll() 删除索引中所有的documents

deleteDocuments(Query… queries) 按照提供的Query 删除documents

deleteDocuments(Term… terms) 按照短语删除documents

deleteUnusedFiles() 删除所有不再使用index的文件

forceMergeDeletes() 删除处于已经删除的状态documents，由此可见，之前的删除文档的方法并没有真正的删除掉的documents，只是标记删除，我个人理解是类似逻辑上的删除

forceMergeDeletes(boolean doWait) 删除过程中指明是否阻塞，直到操作完成

索引更新

更新操作也是一样，查看文档就有，这里截个图：

索引查询

Query

索引查询的时候可以使用Query的实现子类来创建查询，执行IndexSearcher的search方法来查询，也可以使用QueryParse类来构造查询.

分页

方式1：在scoreDoc中进行分页，数据一次性查出来，在结果集分页，结果集较大时容易溢出

方式2：使用searcheAfter,等价查询的次数，但是不会出现查询结果溢出，推荐，类似数据库中的分页查询

这个类似数据库中的查询，可以对结果集分页显示，类似方式一，查询的时候直接分页，类似方式二 。

索引操作实例

package lucene_demo03;

import java.io.IOException;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;

/**
*
*关于索引的查询(分页查询)
*方式1：在scoreDoc中进行分页，数据一次性查出来，在结果集分页，结果集较大时容易溢出
*方式2：使用searcheAfter,等价查询的次数，但是不会出现查询结果溢出，推荐，类似数据库中的分页查询
* @author YipFun
*/
public class LuceneDemo03 {

private static final Version version = Version.LUCENE_4_9;
private Directory directory = null;
private DirectoryReader ireader = null;
private IndexWriter iwriter = null;

//测试数据
private String[] content = {
"hello lucene",
"I love coding",
"I can play basketball",
"I can play football",
"I can play dota"
};

/**
* 构造方法
*/
public LuceneDemo03() {
directory = new RAMDirectory();
}

/**
* 创建索引
*/
public void createIndex(){
Document doc = null;
try {
iwriter = new IndexWriter(directory, new IndexWriterConfig(version, new StandardAnalyzer(version)));
for(String text : content){
doc = new Document();
//使用的field 有很多类型，理解他们的区别 例如：TextField 和 StringField
doc.add(new TextField("content", text,Field.Store.YES));
iwriter.addDocument(doc);
}

} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(iwriter != null)
iwriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}

}

public IndexSearcher getSearcher(){
try {
if(ireader==null) {
ireader = DirectoryReader.open(directory);
} else {
DirectoryReader tr = DirectoryReader.openIfChanged(ireader) ;
if(tr!=null) {
ireader.close();
ireader = tr;
}
}
return new IndexSearcher(ireader);
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

/**
*
* @param field
* @param term
* @param num
*/
public void searchByTerm(String field,String term,int num){
IndexSearcher isearcher = getSearcher();
//注意query的实现类和QueryParse的用法的区别
TermQuery query = new TermQuery(new Term(field, term));
ScoreDoc[] hits;
try {
//注意searcher的几个方法
hits = isearcher.search(query, null, num).scoreDocs;
// Iterate through the results:
for (int i = 0; i < hits.length; i++) {
Document hitDoc = isearcher.doc(hits[i].doc);
System.out.println("This is the text to be indexed="+hitDoc.get("content"));
}
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 区别与上一种查询，使用QueryParser的parse方法构造一个Query传递给方式使用
* @param query
* @param num
*/
public void searchByQueryParse(Query query,int num) {
try {
IndexSearcher searcher = getSearcher();
TopDocs tds = searcher.search(query, num);
System.out.println("一共查询了:"+tds.totalHits);
for(ScoreDoc sd:tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
System.out.println("This is the text to be indexed="+doc.get("content"));
}
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 第一中分页方式，对ScoreDoc进行分页
* @param query
* @param pageIndex 从1开始，即第一页
* @param pageSize 分页大小
* @param num search top n hits
*/
public void searchForPage(Query query ,int pageIndex,int pageSize,int num){
try {
IndexSearcher searcher = getSearcher();
TopDocs tds = searcher.search(query, num);
System.out.println("一共查询了:"+tds.totalHits);
//对ScoreDoc分页
int start = (pageIndex-1)*pageSize;
int end = pageIndex*pageSize;
ScoreDoc scoreDocs[] = tds.scoreDocs;
for(int i=start;i<end;i++) {
Document doc = searcher.doc(scoreDocs[i].doc);
System.out.println("This is the text to be indexed="+doc.get("content"));
}
} catch (CorruptIndexException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 使用searchAfter 实现在查询的时候的分页
* @param query
* @param pageIndex
* @param pageSize
* @throws IOException
*/
public void searchForPageByAfter(Query query ,int pageIndex,int pageSize) throws IOException{
IndexSearcher searcher = getSearcher();
//先获取上一页的最后一个元素
ScoreDoc lastSd = getLastScoreDoc(pageIndex, pageSize, query, searcher);
TopDocs tds = searcher.searchAfter(lastSd,query, pageSize);
for(ScoreDoc sd:tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
System.out.println("This is the text to be indexed="+doc.get("content"));
}

}

/**
* 返回分页查询的上一条
* @param pageIndex
* @param pageSize
* @param query
* @param indexSearcher
* @return
*/
private ScoreDoc getLastScoreDoc(int pageIndex,int pageSize,Query query,IndexSearcher searcher){
if(pageIndex==1)return null;//如果是第一页就返回空
int num = pageSize*(pageIndex-1);//获取上一页的数量
TopDocs tds = null;
try {
tds = searcher.search(query, num);
} catch (IOException e) {
e.printStackTrace();
}
return tds.scoreDocs[num-1];
}

public static void main(String[] args) throws ParseException, IOException {
LuceneDemo03 ld = new LuceneDemo03();
ld.createIndex();
ld.searchByTerm("content","play",500);
System.out.println("==============1======================");

QueryParser parser = new QueryParser(version, "content", new StandardAnalyzer(version));
Query q = parser.parse("play");//研究下parse的语法
ld.searchByQueryParse(q,500);
System.out.println("===============2=====================");

ld.searchForPage(q, 1, 2, 500);//从第一页开始
System.out.println("================3====================");

ld.searchForPageByAfter(q, 1, 2);//从第一页开始
System.out.println("================4====================");
}

}