最近一段时间在研究lucene的使用，可以说lucene的功能确实很强大，我只是略沾皮毛，下面是我学习lucene的过程。
开发环境：eclipse3.7；
lucene版本：3.5
功能需求是：对50万的简历数据可以进行多关键字的查询，查询响应时间控制在3S中以内。
需要说明的是，我的简历数据是放在数据库表里面的，数据库对于like%的查询效率太低。所以这里我就想到了用lucene的全文检索来实现。
简历表：tb_resume(resumeId,.....);对应实体类：ResumeModel
CREATE TABLE `tb_resume` (
`resumeId` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(200) DEFAULT NULL,
`sex` varchar(11) DEFAULT NULL,
`degree` varchar(200) DEFAULT NULL,
`jingyan` varchar(200) DEFAULT NULL,
`birthday` datetime DEFAULT NULL,
`nowPlace` varchar(200) DEFAULT NULL,
`birthPlace` varchar(200) DEFAULT NULL,
`email` varchar(200) DEFAULT NULL,
`tel` varchar(200) DEFAULT NULL,
`workExp` longtext,
`educationExp` longtext,
`projectExp` longtext,
`selfEvaluation` longtext,
`state` int(11) DEFAULT NULL,
`qz` int(11) DEFAULT '1',
PRIMARY KEY (`resumeId`)
) ENGINE=InnoDB AUTO_INCREMENT=500058 DEFAULT CHARSET=utf8;
第一步，创建索引
由于数据来源是在数据库，所以需要先取出数据库里面的数据。
然后对这些数据创建索引：
import java.io.IOException;
import java.util.Date;
import java.util.List;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import scott.resume.model.ResumeModel;
import util.Constant;
/**
* 创建索引类
* @author Administrator
*
*/
public class CreateIndex {
// private static final File INDEX_DIR = new File("E:\\新的设计目录\\txlpf\\lucene");
// private static final Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_35);
/**
* 将简历信息添加到索引库中
* @param list
* @throws IOException
*/
public static void index(List<ResumeModel> list) throws IOException {
long start1 = new Date().getTime();
IndexWriter writer = openIndexWriter();
try {
for (ResumeModel rm : list) {
Document document = builderDocument(rm);
writer.addDocument(document);
}
} finally {
writer.close();
}
long end1 = new Date().getTime();
System.out.println("创建索引花费时间：" + (double) (end1 - start1) / 1000 + "秒");
}
private static IndexWriter openIndexWriter() throws IOException {
IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_35,
Constant.analyzer);
iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);//增量型索引 ，这个地方是关于你创建索引是增量的还是始终创建的。一般来说，选择create_or_append比较好，无论你是否已经创建了索引，都满足
return new IndexWriter(FSDirectory.open(Constant.INDEX_DIR), iwc);
}
/**
* 创建索引
* @param obj 要创建索引的对象
* @return
*/
public static Document builderDocument(ResumeModel rm) {
Document document = new Document();
String state = null;
if(rm.getState()==0){
state = "未录用";
}
else{
state = "已录用";
}
Field id = new Field("id", String.valueOf(rm.getResumeId()), Field.Store.YES, Field.Index.ANALYZED);
Field content = new Field("content", rm.getDegree()+rm.getJingyan()+rm.getWorkExp()+rm.getEducationExp()+rm.getProjectExp()+rm.getSelfEvaluation()+state, Field.Store.YES, Field.Index.ANALYZED);
document.add(id);
document.add(content);
return document;
}
}
其中，docement就相当于数据表。field相当于数据表里面的字段。
第二步：查询
创建完索引之后就可以进行查询了
jsp页面用于输入查询的关键词，例如我输入：java 已录用
下面是写的一个查询帮助类：
import org.apache.lucene.index.Term;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
/**
* 查询类
* @author Administrator
*
*/
public class QueryUtil {
/**
* 功能：按词条搜索 － TermQuery
* @param field field的名称
* @param searchKey 查询的词
* @return
*/
public static Query searchByTeam(String field,String searchKey){
System.err.println("TermQuery test demo------");
Term term = new Term(field, searchKey);
Query query= new TermQuery(term);
System.err.println("查询条件:" + query);
System.err.println("查询语义:查询在AlarmType中出现\""+searchKey+"\"这个词的Document.");
return query;
}
/**
* 功能：查询俩个子查询的交集
* @param qy1
* @param qy2
* @return
*/
public static Query booleanAndSearch(Query qy1,Query qy2){
BooleanQuery query = new BooleanQuery();//新建一个布尔查询
query.add(qy1, BooleanClause.Occur.MUST);
query.add(qy2, BooleanClause.Occur.MUST);
return query;
}
/**
* 功能：查询俩个子查询的交集
* @param fieldOne 第一个子查询field
* @param searchKeyOne 第一个子查询关键词
* @param fieldTwo 第二个子查询的field
* @param searchKeyTwo 第二个子查询的关键词
* @return
*/
public static Query searchByBooleanAnd(String fieldOne ,String searchKeyOne,String fieldTwo,String searchKeyTwo){
BooleanQuery query = new BooleanQuery();//新建一个布尔查询
Query qy1 = QueryUtil.searchByTeam(fieldOne, searchKeyOne);
Query qy2 = QueryUtil.searchByTeam(fieldTwo, searchKeyTwo);
query.add(qy1, BooleanClause.Occur.MUST);
query.add(qy2, BooleanClause.Occur.MUST);
System.err.println("查询条件:" + query);
System.err.println("查询语义:查询在"+fieldOne+"中包含\""+searchKeyOne+"\"这个词但是不能包含查询在"+fieldTwo+"中包含\""+searchKeyTwo+"\"的Document.");
return query;
}
/**
* 功能：查询俩个子查询的并集
* @param fieldOne 第一个子查询field
* @param searchKeyOne 第一个子查询关键词
* @param fieldTwo 第二个子查询的field
* @param searchKeyTwo 第二个子查询的关键词
* @return
*/
public static Query searchByBooleanOr(String fieldOne ,String searchKeyOne,String fieldTwo,String searchKeyTwo){
BooleanQuery query = new BooleanQuery();//新建一个布尔查询
Query qy1 = QueryUtil.searchByTeam(fieldOne, searchKeyOne);
Query qy2 = QueryUtil.searchByTeam(fieldTwo, searchKeyTwo);
query.add(qy1, BooleanClause.Occur.SHOULD);
query.add(qy2, BooleanClause.Occur.SHOULD);
System.err.println("查询条件:" + query);
System.err.println("查询语义:包含查询在"+fieldOne+"中包含\""+searchKeyOne+"\"这个词而且包含查询在"+fieldTwo+"中包含\""+searchKeyTwo+"\"的Document.");
return query;
}
/**
* 功能：查询俩个子查询的 差集,第一个子查询的结果不包含第二个子查询
* @param fieldOne 第一个子查询field
* @param searchKeyOne 第一个子查询关键词
* @param fieldTwo 第二个子查询的field
* @param searchKeyTwo 第二个子查询的关键词
* @return
*/
public static Query searchByBooleanNot(String fieldOne ,String searchKeyOne,String fieldTwo,String searchKeyTwo){
BooleanQuery query = new BooleanQuery();//新建一个布尔查询
Query qy1 = QueryUtil.searchByTeam(fieldOne, searchKeyOne);
Query qy2 = QueryUtil.searchByTeam(fieldTwo, searchKeyTwo);
query.add(qy1, BooleanClause.Occur.MUST);
query.add(qy2, BooleanClause.Occur.MUST_NOT);
System.err.println("查询条件:" + query);
System.err.println("查询语义:查询在"+fieldOne+"中包含\""+searchKeyOne+"\"这个词但是不包含查询在"+fieldTwo+"中包含\""+searchKeyTwo+"\"的Document.");
return query;
}
/**
* 功能：词组查询也称短语查询
* @param fields 查询的field
* @param keywords 关键词数组
* @return
*/
public static Query searchByManyKeywords(String fields,String[] keywords){
PhraseQuery query = new PhraseQuery();
String str = null;
for(int i=0;i<keywords.length;i++){
query.add(new Term(fields, keywords[i]));
str = str +keywords[i];
}
query.setSlop(5);
System.err.println("查询条件:" + query);
System.err.println("查询语义:查询"+fields+"中含有:"+str+"的数据，这几个词至少移动五步才能构成词组，返回符合条件的Document.");
return query;
}
}
查询时候关键词的确定
首先，前台控制关键词之间只能是空格，或者逗号
然后获取用户输入的关键词：
/**
* 根据输入的关键字返回关键词字符串数组
* @param key
* @return
*/
public static String[] getKeywords(String key){
String[] resultKeys = null;
key = key.replace(" ", " ");//第一步，将所有的全角空格换个半角空格
key = key.replace("，", ",");//第二部，将所有的全角逗号，换成半角逗号
key = key.replaceAll(",", " ");//将所有的半角逗号换成空格
key = key.replaceAll( "(\\s+) ", " "); //将多个空格换成一个空格
key = key.trim(); //去除俩端的空格
resultKeys = key.split("[ ,]");//以空格分隔字符串
return resultKeys;
}
查询：java，已录用
/**
* 功能：获得多个关键词的查询的query
* @param field 要查询的字段
* @param keys 查询的关键词数组
* @return
* @throws CorruptIndexException
* @throws ParseException
* @throws IOException
*/
public static Query searchByManyKey(String field,String keys[]) throws CorruptIndexException, ParseException, IOException{
Query qy1 = null;
Query qy2 = null;
Query temp = null;
for(int i=0;i<keys.length-1;i++){
qy1 = QueryForLucene.buildQuery(field, keys[i]);
qy2 = QueryForLucene.buildQuery(field, keys[i+1]);
temp = qy1;
temp = QueryUtil.booleanAndSearch(temp, qy2);
System.out.println(temp+"\n__________________");
}
return temp;
}
/**
* 功能：多关键词查询，返回查询结果集
* @param field 查询的field
* @param key 查询的关键词数组
* @return
* @throws CorruptIndexException
* @throws ParseException
* @throws IOException
*/
public static ScoreDoc[] getSearchResultAnd(String field,String key[]) throws CorruptIndexException, ParseException, IOException{
IndexReader reader = IndexReader.open(FSDirectory.open(Constant.INDEX_DIR));
IndexSearcher searcher = new IndexSearcher(reader);
try {
Query query = searchByManyKey(field, key);
TopDocs topDocs = searcher.search(query, 510000);
int total = topDocs.totalHits;
System.out.println("在"+field+"中搜索："+query.toString()+"total=" + total);
ScoreDoc[] scoreDocs = topDocs.scoreDocs;
return scoreDocs;
} finally {
searcher.close();
}
}
这样就可以实现查询了。
当有的用户的简历信息发生变化的时候，如果我们重新创建索引的话，是需要大量的时间的，这里需要重新创建该用户的简历信息索引。
第三步：更新索引
import org.apache.lucene.store.Directory;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import scott.resume.model.ResumeModel;
import util.Constant;
/**
* 更新索引
* @author Administrator
*
*/
public class UpdateIndex {
/**
* 功能：删除原先的索引之后，新增新的索引
* @param rm
*/
public static void updateAndNewIndex(ResumeModel rm){
try{
if(rm.getState()==1){//已经存在了简历
deleteIndex("id",String.valueOf(rm.getResumeId()));
}
Document doc = CreateIndex.builderDocument(rm);
Directory dir = FSDirectory.open(Constant.INDEX_DIR);
IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_35,Constant.analyzer).setOpenMode(OpenMode.APPEND);
IndexWriter writer = new IndexWriter(dir, config);
writer.addDocument(doc);
writer.close();
}catch(Exception e){
e.printStackTrace();
}
}
/**
* 删除索引，这里主要是对resumeId进行查询，然后删除这个结果
* @param field
* @param keyword
* @throws Exception
*/
public static void deleteIndex(String field , String keyword) throws Exception{
long startTime = System.currentTimeMillis();
//首先，我们需要先将相应的document删除
Directory dir = FSDirectory.open(Constant.INDEX_DIR);
IndexReader reader = IndexReader.open(dir,false);
Term term = new Term(field,keyword);
reader.deleteDocuments(term);
reader.close();
long endTime = System.currentTimeMillis();
System.out.println("total time: " + (endTime - startTime) + " ms");
}
}
第一次写个人学习笔记，文笔比较差，请见谅
http://download.csdn.net/download/somtomking/1921112
分享到：
相关推荐
### Lucene 3.5 学习笔记 #### 一、Lucene 3.5 基本概念 ##### 1.1 Lucene 概述 **1.1.1 IndexWriter** `IndexWriter` 是 Lucene 中的核心类之一，用于创建或更新索引。它提供了添加文档、删除文档、优化索引等...
本压缩包包含的是Lucene 3.5.0版本的全部源码，对于想要深入理解Lucene工作原理、进行二次开发或者进行搜索引擎相关研究的开发者来说，是一份非常宝贵的学习资源。 Lucene 3.5.0是Lucene的一个重要版本，它在3.x...
不过，对于理解搜索引擎的工作机制和学习基本的全文搜索实现，Lucene 3.5仍然是一个很好的起点。通过深入研究这个压缩包中的各种包和源码，开发者可以掌握如何构建一个高效的全文搜索系统，并在此基础上进行扩展和...
开发者可以通过源代码学习如何集成Lucene到自己的项目中，以实现高效、精确的全文检索功能。 总结，Lucene 3.5的源代码是理解其工作原理的宝贵资源。通过对源码的深入研究，开发者不仅可以掌握Lucene的基本操作，还...
luke3.5 可查看lucene3.5索引
lucene3.5 IKAnalyzer3.2.5 实例中文分词通过，目前在网上找的lucene 和IKAnalyzer 的最新版本测试通过。内含：示例代码，以及最新jar包。 lucene lucene3.5 IKAnalyzer IKAnalyzer3.2.5 jar 中文 分词
《Lucene 3.5：创建、增删改查详解》 Lucene 是一个高性能、全文本搜索库，被广泛应用于各种搜索引擎的开发。在3.5版本中，Lucene 提供了强大的文本分析和索引功能，以及对文档的高效检索。本文将详细介绍如何在...
本篇文章将围绕“lucene3.5全文检索案例lucene+demo”，详细讲解Lucene 3.5的核心概念、关键功能以及如何通过实例进行操作。 一、Lucene 3.5核心概念 1. 文档（Document）：Lucene中的最小处理单元，相当于数据库...
《深入探索Lucene 3.5：学习研究报告》 Lucene 3.5是一个重要的版本更新，它在2011年11月26日发布，为搜索引擎开发者提供了更高效、更稳定的功能。该版本在性能优化、新特性和错误修复上取得了显著的进步。 首先，...
《Lucene3.5实例详解：构建全文搜索引擎》 Apache Lucene是一个开源的全文检索库，为Java开发者提供了强大的文本搜索功能。在本实例中，我们将深入探讨如何使用Lucene 3.5版本来构建一个基本的全文搜索引擎，主要...
lucene3.5高亮
**Lucene 3.5 API 概述** Lucene 是一个高性能、全文本搜索库，由 Apache 软件基金会开发。它提供了高级文本检索功能，广泛用于构建搜索引擎和其他需要高效全文检索能力的应用。Lucene 3.5 API 是该库在2011年发布...
chm格式的Lucene帮助文档,Lucene3.5
《Lucene 3.5中文分词案例解析》 Lucene是一个开源的全文搜索引擎库，广泛应用于各种信息检索系统中。在3.5版本中，Lucene已经支持了中文分词，这对于处理中文文档和搜索需求显得尤为重要。本文将深入探讨Lucene ...
《深入剖析Lucene 3.5源码：揭示搜索引擎核心技术》 Lucene 3.5是Apache Lucene项目的一个重要版本，它是一个高性能、全文本搜索库，为开发者提供了强大的文本搜索功能。作为开源软件，Lucene的源码对学习和理解...
**正文** Lucene 是一个由 Apache 软件基金会开发的全文搜索引擎库，它提供了强大的文本分析和索引功能，广泛应用于各种信息检索系统。...理解这些基础知识对于深入学习 Lucene 的后续版本至关重要。
在“关于lucene3.5的使用”这个主题中，我们将深入探讨Lucene 3.5的关键特性、核心组件以及如何通过实例进行应用。首先，我们需要了解以下几个核心概念： 1. **索引（Index）**：Lucene 的工作基于索引，就像书籍的...
在本篇文章中，我们将深入探讨 Lucene 3.5 版本的 API，尽管它是英文版，但其丰富的功能和详细文档使其对开发者极具价值。 1. **Lucene 的基本概念** - **索引（Index）**：Lucene 使用倒排索引（Inverted Index）...
Lucene3.5视频教程（内含分享链接） 一共50集， 包含各部分讲解及源码