主要介绍增删改查索引的功能，并且对于查询到的关键字，返回高亮的结果。高亮的效果,就是将查询出来的结果,在前后加上标签,<font
color="red">和</font>这样在浏览器显示的就是红色的字体.
目录效果如上,建立一个com.lucene的包,建立一个IndexDao的类,里面写入索引的增删改查方法;而建立的IndexDaoText类则是对这增删改查的测试;QueryResult则是一个查询结果的类,里面只有2个字段,总记录数和记录集合.
其中IndexDao类中的代码如下,比较长,其实也只是Search长,search长也只是因为查询前要做一些设置,排序,过滤器;查询后取出数据还要做一些高亮和摘要的设置.
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的测试代码,
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);
}
}
}
还有最后一个查询结果类,代码如下.
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中的索引字段的设置。
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写成这样
Term term = new Term("name", "indexwriter");
进行测试,删除索引,重新创建索引,更新效果如下,只有一个语句了.
而删除效果,则全部删除了,一条不留.
最后，还没完,还有下篇《全文检索之lucene的优化篇--查询篇》，介绍lucene中的各种查询方法。