全文检索之lucene的优化篇--增删改查

主要介绍增删改查索引的功能，并且对于查询到的关键字，返回高亮的结果。高亮的效果,就是将查询出来的结果,在前后加上标签,<font color="red">和</font>这样在浏览器显示的就是红色的字体.



目录效果如上,建立一个com.lucene的包,建立一个IndexDao的类,里面写入索引的增删改查方法;而建立的IndexDaoText类则是对这增删改查的测试;QueryResult则是一个查询结果的类,里面只有2个字段,总记录数和记录集合.
其中IndexDao类中的代码如下,比较长,其实也只是Search长,search长也只是因为查询前要做一些设置,排序,过滤器;查询后取出数据还要做一些高亮和摘要的设置.

[java] view
plain copy







package com.lucene;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import jeasy.analysis.MMAnalyzer;

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.NumberTools;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.IndexWriter.MaxFieldLength;

import org.apache.lucene.index.Term;

import org.apache.lucene.queryParser.MultiFieldQueryParser;

import org.apache.lucene.queryParser.QueryParser;

import org.apache.lucene.search.Filter;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.RangeFilter;

import org.apache.lucene.search.ScoreDoc;

import org.apache.lucene.search.Sort;

import org.apache.lucene.search.SortField;

import org.apache.lucene.search.TopDocs;

import org.apache.lucene.search.highlight.Formatter;

import org.apache.lucene.search.highlight.Fragmenter;

import org.apache.lucene.search.highlight.Highlighter;

import org.apache.lucene.search.highlight.QueryScorer;

import org.apache.lucene.search.highlight.Scorer;

import org.apache.lucene.search.highlight.SimpleFragmenter;

import org.apache.lucene.search.highlight.SimpleHTMLFormatter;

public class IndexDao {

//指定索引路径

String indexPath = "F:\\Users\\liuyanling\\workspace\\LuceneDemo\\luceneIndex";

//指定分词器

//Analyzer analyzer = new StandardAnalyzer();

Analyzer analyzer = new MMAnalyzer();// 词库分词

/**

* 添加/创建索引

*

* @param doc 需要创建索引的Document文件

*/

public void save(Document doc) {

IndexWriter indexWriter = null;

try {

indexWriter = new IndexWriter(indexPath, analyzer, MaxFieldLength.LIMITED);

indexWriter.addDocument(doc);

} catch (Exception e) {

throw new RuntimeException(e);

} finally {

try {

indexWriter.close();

} catch (Exception e) {

e.printStackTrace();

}

}

}

/**

* 删除索引

*

* Term是搜索的最小单位，代表某个 Field 中的一个关键词，如：<title, lucene>

* new Term( "title", "lucene" ); //删除标题中带有lucene的索引

* new Term( "id", "5" );

* new Term( "id", UUID );

*

* @param term

*/

public void delete(Term term) {

IndexWriter indexWriter = null;

try {

indexWriter = new IndexWriter(indexPath, analyzer, MaxFieldLength.LIMITED);

indexWriter.deleteDocuments(term);

} catch (Exception e) {

throw new RuntimeException(e);

} finally {

try {

indexWriter.close();

} catch (Exception e) {

e.printStackTrace();

}

}

}

/**

* 更新索引,也就是先删除后添加

*

* <pre>

* indexWriter.deleteDocuments(term);

* indexWriter.addDocument(doc);

* </pre>

*

* @param term

* @param doc

*/

public void update(Term term, Document doc) {

IndexWriter indexWriter = null;

try {

indexWriter = new IndexWriter(indexPath, analyzer, MaxFieldLength.LIMITED);

indexWriter.updateDocument(term, doc);

} catch (Exception e) {

throw new RuntimeException(e);

} finally {

try {

indexWriter.close();

} catch (Exception e) {

e.printStackTrace();

}

}

}

/**

* <pre>

* totalPage = recordCount / pageSize;

* if (recordCount % pageSize > 0)

* totalPage++;

* </pre>

*

* @param queryString 关键字

* @param firstResult 从第几条索引开始查

* @param maxResults 最多查几条

* @return QueryResult 返回查询结果,包括总记录数和所有结果

*/

public QueryResult search(String queryString, int firstResult, int maxResults) {

try {

// 1，把要搜索的文本解析为 Query

String[] fields = { "name", "content" };

Map<String, Float> boosts = new HashMap<String, Float>();

//创建索引时设置相关度,值越大,相关度越高,越容易查出来.name的优先级高于内容

boosts.put("name", 3f);

boosts.put("content", 1.0f); //默认为1.0f

//构造QueryParser,设置查询的方式,以及查询的字段,分词器和相关度的设置

QueryParser queryParser = new MultiFieldQueryParser(fields, analyzer, boosts);

//查询关键字queryString的结果

Query query = queryParser.parse(queryString);

//返回查询的结果

return search(query, firstResult, maxResults);

} catch (Exception e) {

throw new RuntimeException(e);

}

}

/**

* 查询索引

* @param query Query对象

* @param firstResult 从第几条索引开始查

* @param maxResults 最多查几条

* @return QueryResult 返回查询结果,包括总记录数和所有结果

*/

public QueryResult search(Query query, int firstResult, int maxResults) {

IndexSearcher indexSearcher = null;

try {

// 2，进行查询

indexSearcher = new IndexSearcher(indexPath);

//查询的设置1：过滤器,只查询出size在200~1000的文件,这个影响效率,不建议使用

//由于写成这样new RangeFilter("size","50", "200", true, true);,按理会查出50~200的文件,但是由于字符串的50是>200的,所以 //什么也不会查出来,所以要用NumberTools.longToString(),转换一下.

Filter filter = new RangeFilter("size", NumberTools.longToString(200),NumberTools.longToString(1000),true,true);

//查询的设置2：排序,设置根据size从小到大升序排序(不设置也可以的)

Sort sort = new Sort();

sort.setSort(new SortField("size")); // 默认为升序

//sort.setSort(new SortField("size", true));

//查询出结果

TopDocs topDocs = indexSearcher.search(query, filter, 10000, sort);

//将结果显示出来,收集到总记录数,实例化recordList,收集索引记录

int recordCount = topDocs.totalHits;

List<Document> recordList = new ArrayList<Document>();

//准备高亮器,字体颜色设置为red

Formatter formatter = new SimpleHTMLFormatter("<font color='red'>", "</font>");

Scorer scorer = new QueryScorer(query);

Highlighter highlighter = new Highlighter(formatter, scorer);

//设置段划分器，指定关键字所在的内容片段的长度

Fragmenter fragmenter = new SimpleFragmenter(50);

highlighter.setTextFragmenter(fragmenter);

// 3，取出当前页的数据

//获取需要查询的最后数据的索引号

int endResult = Math.min(firstResult + maxResults, topDocs.totalHits);

for (int i = firstResult; i < endResult; i++) {

ScoreDoc scoreDoc = topDocs.scoreDocs[i];

int docSn = scoreDoc.doc; // 文档内部编号

Document doc = indexSearcher.doc(docSn); // 根据编号取出相应的文档

// 高亮处理，返回高亮后的结果，如果当前属性值中没有出现关键字，会返回 null

// 查询“内容"是否包含关键字，没有则为null，有则加上高亮效果。

String highContent = highlighter.getBestFragment(analyzer, "content", doc.get("content"));

if (highContent == null) {

//如果没有关键字,则设置不能超过50个字符

String content = doc.get("content");

int endIndex = Math.min(50, content.length());

highContent = content.substring(0, endIndex);// 最多前50个字符

}

//返回高亮后的结果或者没有高亮但是不超过50个字符的结果

doc.getField("content").setValue(highContent);

//recordList收集索引记录

recordList.add(doc);

}

// 返回结果QueryResult

return new QueryResult(recordCount, recordList);

} catch (Exception e) {

throw new RuntimeException(e);

} finally {

try {

indexSearcher.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

看完IndexDao的类的增删改查,还有测试这些增删改查的方法.按照之前的做法,在IndexDao一个类,就能写完测试方法,但是这里分开了.分开了的话,就算了解耦了,灵活性会好很多.
下面是IndexDaoTest的测试代码,

[java] view
plain copy







package com.lucene;

import org.apache.lucene.document.Document;

import org.apache.lucene.index.Term;

import org.junit.Test;

import com.lucene.units.File2DocumentUtils;

public class IndexDaoTest {

//设置两个需要创建索引的文件

String filePath = "F:\\Users\\liuyanling\\workspace\\LuceneDemo\\datasource\\IndexWriter addDocument's a javadoc .txt";

String filePath2 = "F:\\Users\\liuyanling\\workspace\\LuceneDemo\\datasource\\小笑话_总统的房间 Room .txt";

//indexDao,实现具体的增删改查方法

IndexDao indexDao = new IndexDao();

/**

* 测试保存方法

*/

@Test

public void testSave() {

Document doc = File2DocumentUtils.file2Document(filePath);

//保存索引的时候设置相关度,相对于两个文件中都有的关键字,doc的相关度会高于doc2,也就是会优先查出来.

doc.setBoost(3f);

indexDao.save(doc);

Document doc2 = File2DocumentUtils.file2Document(filePath2);

//doc2.setBoost(1.0f);

indexDao.save(doc2);

}

/**

* 测试删除索引

*/

@Test

public void testDelete() {

//根据路径，删除所有关于该路径的索引文件

Term term = new Term("path", filePath);

indexDao.delete(term);

}

/**

* 测试更新索引

*/

@Test

public void testUpdate() {

//将filePath路径下的索引更新，内容都改为"这是更新后的文件内容"

Term term = new Term("path", filePath);

Document doc = File2DocumentUtils.file2Document(filePath);

doc.getField("content").setValue("这是更新后的文件内容");

indexDao.update(term, doc);

}

/**

* 测试查询

*/

@Test

public void testSearch() {

//关键字为IndexWriter,房间和content:绅士(表示只在内容中查询绅士),这里

String queryString1 = "IndexWriter";

String queryString2 = "房间";

String queryString3 = "content:绅士";

printSearchResult(queryString1, 0, 10);

printSearchResult(queryString2, 0, 10);

printSearchResult(queryString3, 0, 10);

}

/**

* 由于想一次性测试上面的3个查询效果,所以提取了一个打印结果的方法

* @param queryString

* @param firstResult

* @param maxResults

*/

private void printSearchResult(String queryString,int firstResult, int maxResults) {

QueryResult qr = indexDao.search(queryString, firstResult, maxResults);

System.out.println("总共有【" + qr.getRecordCount() + "】条匹配结果");

for (Document doc : qr.getRecordList()) {

//对于size要改为System.out.println("size =" + NumberTools.stringToLong(doc.get("size")));将大小从字符串转为long

File2DocumentUtils.printDocumentInfo(doc);

}

}

}

还有最后一个查询结果类,代码如下.

[java] view
plain copy







package com.lucene;

import java.util.List;

import org.apache.lucene.document.Document;

/**

* 查询结果类,就像实体

* @author liu

*

*/

public class QueryResult {

//总记录数

private int recordCount;

//索引记录

private List<Document> recordList;

//有参构造方法

public QueryResult(int recordCount, List<Document> recordList) {

super();

this.recordCount = recordCount;

this.recordList = recordList;

}

//get,set方法

public int getRecordCount() {

return recordCount;

}

public void setRecordCount(int recordCount) {

this.recordCount = recordCount;

}

public List<Document> getRecordList() {

return recordList;

}

public void setRecordList(List<Document> recordList) {

this.recordList = recordList;

}

}

代码看完了,现在看下运行效果.从增查改删依次测起.首先删了现有的索引文件夹.
1.执行添加,效果就是索引文件建立出来了,并且是两个文件都建立好了索引.



2.查看下结果.照理应该是三条都是有匹配结果的,但是第一条没有,是因为用了过滤器



把IndexDao中的search中配置的filter设置为null,就可以查出结果了.IndexWriter的size只有169,正好被过滤了.而且由于content中没有IndexWriter关键字,所以没有高亮,并且被摘要只有50个字符



3.然后执行以下改的方法,会将IndexWriter中内容修改.修改之后,照理只有一个结果,但是实际上查询结果是有两个记录,之前那条没有删除,然后新建了一条修改了.



4.删除,会删除indexWriter中的所有索引,还是2条记录,结果不对.



后来，发现原来
Lucene在删除索引时，经常会出现代码成功执行，但索引并未正直删除的现象，总结一下，要注意以下因素:
1.在创建Term时，注意Term的key一定要是以"词"为单位，否则删除不成功，例如：添加索引时，如果把"d:\doc\id.txt"当作要索引的字符串索引过了，那么在删除时，如果直接把"d:\doc\id.txt"作为查询的key来创建Term是无效的，应该用Id.txt(但这样会把所有文件名为Id.txt的都删除，所以官方建议最好用一个能唯一标识的关键字来删除，比如产品编号，新闻编号等（我的猜想：每个document都加入一个id字段作为唯一标识(可用系统当前时间值作为id的值)，每当要删除包含某关键字的文档索引时，先将这些文档搜索出来，然后获取它们的id值，传给一个List，然后再用List结合id字段来删除那些文档的索引......不过这个方法的效率可能会低了一点，因为每个文档都要搜两遍）；
2.要删除的“词”,在创建索引时，一定要是Tokened过的，否则也不成功；
3.IndexReader,IndexModifer,IndexWriter都提供了DeleteDocuements方法，但建议用IndexModifer来操作，原因是IndexModifer内部做了很多线程安全处理；(PS:IndexModifer已经过期了)
4.删除完成后，一定要调用相应的Close方法,否则并未真正从索引中删除。
以上是网上查找的原因，最后实验出来为什么lucene的索引删不掉还是花了一点时间。首先是看下File2DocumentUtils中的索引字段的设置。

[java] view
plain copy







Document doc = new Document();

//将文件名和内容分词,建立索引,存储；而内容通过readFileContent方法读取出来。

doc.add(new Field("name",file.getName(),Store.YES,Index.ANALYZED));

doc.add(new Field("content",readFileContent(file),Store.YES,Index.ANALYZED));

//将文件大小存储,但建立索引,但不分词;路径则不需要建立索引

//doc.add(new Field("size",String.valueOf(file.length()),Store.YES,Index.NOT_ANALYZED));

doc.add(new Field("size",NumberTools.longToString(file.length()),Store.YES,Index.NOT_ANALYZED));

doc.add(new Field("path", file.getAbsolutePath(), Store.YES, Index.NO));

其中,name和content是ANALYZED的,而size和path分别是NOT_ANALYZED和NO.上面说要可以要Tokened的字段才能用,但是Tokened过期了,用ANALYZED替换了.而对于"d:\doc\id.txt",我开始搞不清楚是什么意思.后来发现是指如我的路径:F:\datasource\IndexWriter
addDocument'sa javadoc .txt,按照正常思路,写成这样Term
term = new Term("path","F:\\datasource\\IndexWriteraddDocument's
a javadoc .txt");,但是term不认,写成这样反而认Term
term = new Term("path","IndexWriter addDocument's a javadoc .txt");我开始以为是这样，后来发现也不认。写成这样它才认Term
term = new Term("path","indexwriter");可以看出IndexWriter变成小写了，因为大写也不认。这就是上面说的key一定要是以"词"为单位.
对于Term到底是认哪种的写法,感到很奇怪.设想可能跟分词器有关,正好我之前我有用名字文本测试分词器,效果如下,但是我用的语句是这样的"IndexWriter
addDocument's a javadoc.txt",所以,我把文件名由"IndexWriter
addDocument's a javadoc .txt"改成了"IndexWriter
addDocument's ajavadoc.txt".



Term
term = new Term("name","s");写成这样,测试发现MMAnalyzer分词器认这种写法,可以查出结果,但是StandardAnalyzer不认.所以对于极易分词器,写上indexwriter,adddocument,s,javadoc.txt都是可以的.



将删除和更新的方法重新写一下,term写成这样

[java] view
plain copy







Term term = new Term("name", "indexwriter");

进行测试,删除索引,重新创建索引,更新效果如下,只有一个语句了.



而删除效果,则全部删除了,一条不留.



最后，还没完,还有下篇《全文检索之lucene的优化篇--查询篇》，介绍lucene中的各种查询方法。



顶