这两天学习了一下Lucene，然后对其进行了应用上的一些封装。主要仿照项目中经常使用的BaseDao的封装方式。对Lucene的一些简单操作进行了封装，在项目中使用起来比较方便。下面介绍一下封装代码。
1.基础类
该类中，主要提供
- createIndex——创建索引
- update——更新索引信息
- delete——删除索引信息
- searchAll——查询所有
- pageSearch——支持分页查询
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.FieldType;
import org.apache.lucene.document.StoredField;
import org.apache.lucene.index.*;
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.highlight.Highlighter;
import org.apache.lucene.search.highlight.InvalidTokenOffsetsException;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.wltea.analyzer.lucene.IKAnalyzer;
import java.beans.PropertyDescriptor;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 全文检索基础类
*
* @author: alex
* @time: 14-4-1 下午2:24
* @version: 1.0
*/
public abstract class BaseLucene<T extends Object> {
protected static Analyzer analyzer = new IKAnalyzer(); //分词器
protected static File indexDir = null;
static {
indexDir = new File(LuceneContants.INDEX_FILE_PATH); //存放索引文件的目录
}
/**
* 获取文件目录
* @return 文件目录对象
*/
private Directory getDirectory() {
Directory directory = null;
try {
directory = FSDirectory.open(indexDir);
} catch (IOException e) {
e.printStackTrace();
}
return directory;
}
/**
* 获取索引创建器
* @param directory 文件目录
* @return 索引创建器对象
*/
private IndexWriter getIndexWriter(Directory directory) {
IndexWriter indexWriter = null;
try {
//索引创建器配置
IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_46, analyzer);
//设置打开索引模式为创建或追加
config.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
//索引创建器对象
indexWriter = new IndexWriter(directory, config);
} catch (IOException e) {
e.printStackTrace();
}
return indexWriter;
}
/**
* 关闭文件目录和索引创建器对象
* @param directory 文件目录
* @param indexWriter 索引创建器
*/
private void closeDirectoryAndIndexWriter(Directory directory,IndexWriter indexWriter) {
if (indexWriter != null) {
try {
indexWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (directory != null) {
try {
directory.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 创建索引
* @param entity 泛型实体
* @param keyWordFields 关键字索引字段名集合
*/
public void createIndex(T entity,List<String> keyWordFields) {
Directory directory = null;
IndexWriter indexWriter = null;
try {
directory = getDirectory();
indexWriter = getIndexWriter(directory);
//装配成document
Document doc = getDoc(entity,keyWordFields);
indexWriter.addDocument(doc); //写入索引文件
} catch (IOException e) {
e.printStackTrace();
} finally {
closeDirectoryAndIndexWriter(directory,indexWriter);
}
}
/**
* 装配document对象方法
* @param entity 泛型实体
* @param keyWordFields 关键字索引字段名集合
* @return Document对象
*/
private Document getDoc(T entity,List<String> keyWordFields){
FieldType ftIndex = new FieldType(); // 索引类型
ftIndex.setIndexed(true); //设置索引为true
ftIndex.setStored(true); //设置保存为true
ftIndex.setTokenized(true); //设置分词为true
Document doc = new Document();
Map<String,Integer> fieldsMap = getAllFields(entity, keyWordFields);
for (Map.Entry<String,Integer> fieldMap : fieldsMap.entrySet()) {
if(fieldMap.getValue() == LuceneContants.IS_KEY_WORD) { //索引字段
Field field = new Field(fieldMap.getKey(), getterMethod(entity,fieldMap.getKey()).toString(),ftIndex);
doc.add(field);
} else { //存储字段
StoredField storedField = new StoredField(fieldMap.getKey(), getterMethod(entity,fieldMap.getKey()).toString());
doc.add(storedField);
}
}
return doc;
}
/**
* 通过反射获取所有实体字段
* @param entity 泛型实体
* @param keyWordFields 关键字索引字段名集合
* @return 实体的所有字段
*/
private Map<String,Integer> getAllFields(T entity,List<String> keyWordFields){
Map<String,Integer> fieldsMap = new HashMap<String,Integer>();
java.lang.reflect.Field[] fields = entity.getClass().getDeclaredFields();
for(int i = 0; i < fields.length; i++) {
Integer keyWordFlag = LuceneContants.NO_KEY_WORD;
String fieldName = fields[i].getName();
for(String keyWordField : keyWordFields) {
if(keyWordField.equals(fieldName)) {
keyWordFlag = LuceneContants.IS_KEY_WORD;
}
}
fieldsMap.put(fieldName,keyWordFlag);
}
return fieldsMap;
}
/**
* 通过反射获取字段值
* @param obj 实体
* @param filedName 字段名
* @return 字段值
*/
private Object getterMethod(Object obj, String filedName) {
Object object = null;
try {
Class clazz = obj.getClass();
PropertyDescriptor propertyDescriptor = new PropertyDescriptor(filedName, clazz);
Method getMethod = propertyDescriptor.getReadMethod();//获得get方法
if (propertyDescriptor != null) {
object = getMethod.invoke(obj); //执行get方法返回一个Object
}
} catch (Exception e) {
e.printStackTrace();
}
return object;
}
/**
* 查询所以索引匹配到的数据
* @param queryWhere 查询条件
* @param defaultQueryField 默认查询的关键字字段
* @param keyWordFields 是关键字且需高亮显示的字段集合
* @return json格式的字符串
*/
public String searchAll(String queryWhere,String defaultQueryField,List<String> keyWordFields) {
if("".equals(queryWhere)){
queryWhere = "(*:*)";
keyWordFields = new ArrayList<String>();
}
String result = null;
IndexReader reader = null;
IndexSearcher indexSearcher = null;
try {
reader = DirectoryReader.open(getDirectory());
indexSearcher = new IndexSearcher(reader);
Query query = new QueryParser(Version.LUCENE_46, defaultQueryField, analyzer).parse(queryWhere);
ScoreDoc[] hits = indexSearcher.search(query, LuceneContants.QUERY_MAX_COUNT).scoreDocs;
result = resultToJson(indexSearcher,query,hits,keyWordFields,0,hits.length);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
/**
* 分页查询所以索引匹配到的数据
* @param queryWhere 查询条件
* @param defaultQueryField 默认查询的关键字字段
* @param keyWordFields 是关键字且需高亮显示的字段集合
* @param currPage 当前页
* @param pageSize 每页显示的条数
* @return json格式的字符串
*/
public String pageSearch(String queryWhere,String defaultQueryField,List<String> keyWordFields,int currPage,int pageSize) {
if("".equals(queryWhere)){
queryWhere = "(*:*)";
keyWordFields = new ArrayList<String>();
}
String result = null;
IndexReader reader = null;
IndexSearcher indexSearcher = null;
try {
reader = DirectoryReader.open(getDirectory());
indexSearcher = new IndexSearcher(reader);
Query query = new QueryParser(Version.LUCENE_46, defaultQueryField, analyzer).parse(queryWhere);
ScoreDoc[] hits = indexSearcher.search(query, LuceneContants.QUERY_MAX_COUNT).scoreDocs;
//分页计算
int start = (currPage - 1) * pageSize;
int totalCount = hits.length;
int end = Math.min(currPage * pageSize,totalCount);
result = resultToJson(indexSearcher,query,hits,keyWordFields,start,end);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return result;
}
/**
* 将查询到的数据转成json格式数据返回
* @param indexSearcher 查询索引实体
* @param query 查询实体
* @param hits 匹配的结果对象
* @param keyWordFields 是关键字且需高亮显示的字段集合
* @param start 开始索引
* @param end 结束索引
* @return json格式的字符串
*/
private String resultToJson(IndexSearcher indexSearcher, Query query, ScoreDoc[] hits,List<String> keyWordFields,int start,int end){
JSONArray jsonArray = new JSONArray();
try {
Class<T> entityClass = (Class<T>)((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
T entity = entityClass.newInstance();
Map<String,Integer> fieldsMap = getAllFields(entity,keyWordFields);
for (int i = start; i < end; i++) {
JSONObject jsonObject = new JSONObject();
Document hitDoc = indexSearcher.doc(hits[i].doc);
for(Map.Entry<String, Integer> field : fieldsMap.entrySet()){
if(field.getValue() == LuceneContants.IS_KEY_WORD) { //是关键字，且需要高亮显示
String value = toHighlighter(query, hitDoc, field.getKey());
jsonObject.put(field.getKey(),value);
} else {
jsonObject.put(field.getKey(),hitDoc.get(field.getKey()));
}
}
jsonArray.add(jsonObject);
}
} catch (Exception e) {
e.printStackTrace();
}
return jsonArray.toString();
}
/**
* 高亮显示设置
* @param query 查询实体
* @param doc 文档对象
* @param field 字段
* @return 高亮设置
*/
private String toHighlighter(Query query, Document doc, String field) {
try {
SimpleHTMLFormatter simpleHtmlFormatter = new SimpleHTMLFormatter("<font color=\"blue\">", "</font>");
Highlighter highlighter = new Highlighter(simpleHtmlFormatter, new QueryScorer(query));
TokenStream tokenStream1 = analyzer.tokenStream("text", new StringReader(doc.get(field)));
String highlighterStr = highlighter.getBestFragment(tokenStream1, doc.get(field));
return highlighterStr == null ? doc.get(field) : highlighterStr;
} catch (IOException e) {
e.printStackTrace();
} catch (InvalidTokenOffsetsException e) {
e.printStackTrace();
}
return null;
}
/**
* 修改索引
* @param entity 泛型实体
* @param keyWordFields 索引字段集合
* @return true成功，false失败
*/
public boolean update(T entity,List<String> keyWordFields) {
boolean flag = false;
IndexWriter indexWriter = null;
Directory directory = null;
try{
directory = getDirectory();
indexWriter = getIndexWriter(directory);
Document doc = getDoc(entity,keyWordFields);
//根据Id进行更新索引
Term term = new Term("id", String.valueOf(getterMethod(entity,"id")));
indexWriter.updateDocument(term, doc);
flag = true;
} catch (Exception e){
flag = false;
e.printStackTrace();
} finally {
closeDirectoryAndIndexWriter(directory,indexWriter);
}
return flag;
}
/**
* 删除索引
* @param id 删除的索引Id
* @return true成功，false失败
*/
public boolean delete(Integer id) {
if(id == null || id.intValue() < 0) {
throw new RuntimeException("参数不正确！");
}
boolean flag = false;
IndexWriter indexWriter = null;
Directory directory = null;
try{
//索引所放目录
directory = getDirectory();
indexWriter = getIndexWriter(directory);
Term term = new Term("id", String.valueOf(id));
indexWriter.deleteDocuments(term);
flag = true;
}catch (Exception e) {
flag = false;
e.printStackTrace();
} finally {
closeDirectoryAndIndexWriter(directory,indexWriter);
}
return flag;
}
}
常量类：
/**
* 常量描述
*
* @author: alex
* @time: 14-4-1 下午2:24
* @version: 1.0
*/
public class LuceneContants {
//索引文件存储目录
public static final String INDEX_FILE_PATH = "D://indexFile";
//查询文件的最大条数
public static final int QUERY_MAX_COUNT = 100000;
//是索引标识
public static final int IS_KEY_WORD = 1;
//不是索引标识
public static final int NO_KEY_WORD = 0;
}
2.service层应用
import java.util.ArrayList;
import java.util.List;
/**
* service层
*
* @author: alex
* @time: 14-4-2 下午1:35
* @version: 1.0
*/
public class PersonSearchService extends BaseLucene<Person> {
private static List<String> keyWordFields = null;
static {
keyWordFields = new ArrayList<String>();
//给名字和介绍做全文检索
keyWordFields.add("id");
keyWordFields.add("name");
keyWordFields.add("introduce");
}
/**
* 保存用户信息
* @param person 用户
*/
public void savePerson(Person person) {
this.createIndex(person,keyWordFields);
}
/**
* 更新用户信息
* @param person 用户实体
* @return true成功，false失败
*/
public boolean updatePerson(Person person) {
return this.update(person,keyWordFields);
}
/**
* 删除用户信息
* @param id 用户ID
* @return true成功，false失败
*/
public boolean deletePerson(Integer id) {
return this.delete(id);
}
/**
* 根据条件查询所有
* @param queryWhere 查询条件
* @param defaultQueryField 默认检索字段
* @return json格式数据
*/
public String queryAll(String queryWhere,String defaultQueryField) {
return this.searchAll(queryWhere,defaultQueryField,keyWordFields);
}
/**
* 根据条件分页查询
* @param queryWhere 查询条件
* @param defaultQueryField 默认检索字段
* @param currPage 当前页
* @param pageSize 每页条数
* @return json格式数据
*/
public String pageQuery(String queryWhere,String defaultQueryField,int currPage,int pageSize) {
return this.pageSearch(queryWhere,defaultQueryField,keyWordFields,currPage,pageSize);
}
}
实体类：
/**
* 实体
*
* @author: alex
* @time: 14-4-2 下午1:32
* @version: 1.0
*/
public class Person {
private int id;
private String name;
private int age;
private String introduce;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getIntroduce() {
return introduce;
}
public void setIntroduce(String introduce) {
this.introduce = introduce;
}
}
3.测试类
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* 测试类
*
* @author: alex
* @time: 14-4-1 上午10:54
* @version: 1.0
*/
public class PersonSearchServiceTest {
static PersonSearchService personSearchService = null;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
personSearchService = new PersonSearchService();
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
}
@Test
public void testSavePerson() {
Person person = new Person();
person.setId(1);
person.setName("张三");
person.setAge(21);
person.setIntroduce("张三是中国好演员！");
personSearchService.savePerson(person);
person.setId(2);
person.setName("张一三");
person.setAge(22);
person.setIntroduce("张三是中国好替身！");
personSearchService.savePerson(person);
person.setId(3);
person.setName("张三疯");
person.setAge(23);
person.setIntroduce("张三是中国好程序员！");
personSearchService.savePerson(person);
person.setId(4);
person.setName("啊张三");
person.setAge(24);
person.setIntroduce("张三是中国好声音！");
personSearchService.savePerson(person);
person.setId(5);
person.setName("李三");
person.setAge(25);
person.setIntroduce("啊啊啊啊啊啊啊啊啊啊啊啊啊！");
personSearchService.savePerson(person);
}
@Test
public void testUpdatePerson() {
Person person = new Person();
person.setId(4);
person.setName("张三啊");
person.setAge(24);
person.setIntroduce("把啊张三改成了张三啊！");
boolean result = personSearchService.updatePerson(person);
Assert.assertTrue(result);
}
@Test
public void testDeletePerson() {
//删除了第二条
boolean result = personSearchService.deletePerson(2);
Assert.assertTrue(result);
}
@Test
public void testQuery() {
String queryWhere = "name:张三 introduce:中国";
String defaultQueryField = "name";
String result = personSearchService.queryAll(queryWhere, defaultQueryField);
System.out.println(result);
}
@Test
public void testPageQuery() {
String queryWhere = "name:张三 introduce:中国";
String defaultQueryField = "name";
String result = personSearchService.pageQuery(queryWhere, defaultQueryField,1,2);
System.out.println(result);
}
}
4.说明
本示例没有对查询出来的结果进行排序，同时还有一些其他的地方还需完善。代码发出来，给大家参考一下。
示例中应用的jar如下：
开发时，使用的maven，发一下maven的pom文件：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>lucene</groupId>
<artifactId>lucene</artifactId>
<version>1.0</version>
<dependencies>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-core</artifactId>
<version>4.6.0</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-highlighter</artifactId>
<version>4.6.0</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-queries</artifactId>
<version>4.6.0</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-queryparser</artifactId>
<version>4.6.0</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-test-framework</artifactId>
<version>4.6.0</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-smartcn</artifactId>
<version>3.6.2</version>
</dependency>
<dependency>
<groupId>IKAnalyzer</groupId>
<artifactId>IKAnalyzer</artifactId>
<version>2012FF_u1</version>
</dependency>
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>net.sf.ezmorph</groupId>
<artifactId>ezmorph</artifactId>
<version>1.0.6</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.8.3</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
</dependencies>
</project>
至于运行结果没有贴出来，有兴趣的同学可以自己运行一下。
相关推荐
《全面解析Lucene 4.6：核心概念与应用实践》 Lucene 4.6是Apache Lucene项目的一个重要版本，它是一个高性能、全文本搜索引擎库，为开发者提供了强大的文本检索功能。在这个版本中，Lucene进行了诸多优化和改进，...
18.lucene4.6索引的相关操作 19.lucene4.6的各种Query(1) 20.lucene4.6的各种Query(2) 21.lucene4.6的各种Query(3) 22.solr4.6的快速搭建 23.solr4.6索引的相关操作 24.solr4.6搜索的相关参数功能(1) 25.solr4.6搜索...
《深入理解Lucene 4.6：索引构建、查询执行与近实时搜索》 Lucene是一个开源全文搜索引擎库，广泛应用于各种信息检索系统。在本文中，我们将深入探讨Lucene 4.6版本，包括如何创建索引、执行查询以及实现近实时搜索...
《深入理解Lucene 4.6：搜索引擎框架详解》 Lucene是一个开源的全文检索库，由Apache软件基金会开发并维护。它提供了完整的搜索功能，包括索引、搜索、高亮显示结果等，广泛应用于各种信息检索系统。本文将重点探讨...
本文将重点探讨Lucene 4.6版本的实例应用，帮助读者理解其核心概念、工作流程以及如何在实际项目中进行有效利用。 1. **Lucene 4.6简介** - 发布时间：Lucene 4.6是在2013年发布的一个重要版本，引入了许多改进...
对于抓取的数据，进行去重，去标签，然后利用lucene 和 solr 进行索引和搜索。 课程的最大特点是内容新颖全面而又通俗易懂。对于实际搜索引擎所涉及的各种核心技术都有全面细致的介绍，除了作为搜索系统核心的网络...
Lucene提供了一个简单却强大的应用程式接口，能够做全文索引和搜寻。 从之前发布其他chm文件下载用户的反映看，有不少朋友反映下载后打开无法显示，这一般不是chm文件的问题，这里统一说明一下解决办法： 如果文件...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...
【课程大纲】01.Lucene4入门精通实战课程-概述 共23页02.Lucene系统架构 共16页03.Lucene索引里有什么 共17页04.Lucene索引深入 共24页05.Lucene索引深入优化 共10页06.Lucene索引搜索 共13页07.Lucene搜索实战1 共4...