亚洲精品自在在线观看,亚洲婷婷在线视频,亚洲中文字幕久久精品无码A

LUCENE学习�W�记3(转蝲)

Mon, 17 Dec 2007 11:36:00 GMT

1, 有时对于一个Document来说�Q�有一些Field会被频繁地操作，而另一些Field则不会。这时可以将频繁操作的Field和其他Field分开存放�Q�而在搜烦时同时检索这两部分Field而提取出一个完整的Document�? �q�要求两个烦引包含的Document的数量必��ȝ��同�?
在创建烦引的时候，可以同时创徏多个IndexWriter�Q�将一个Document�Ҏ��需要拆分成多个包含部分Field的Document�Q��ƈ��这些Document分别��d��C��同的索引�?
而在搜烦�Ӟ��则必��d��助ParallelReader�c�L��整合�?
Directory dir1=FSDirectory.getDirectory(new File(INDEX_DIR1),false);
Directory dir2=FSDirectory.getDirectory(new File(INDEX_DIR2),false);
ParallelReader preader=new ParallelReader();
preader.add(IndexReader.open(dir1));
preader.add(IndexReader.open(dir2));
IndexSearcher searcher=new IndexSearcher(preader);
之后的操作和一般的搜烦相同�?

2, Query的子�c? 下面的几个搜索在各种不同要求的场�?都会用到. 需要大家仔�l�研�?

Query query1 = new TermQuery(new Term(FieldValue, "name1")); // 词语搜烦
Query query2 = new WildcardQuery(new Term(FieldName, "name*")); // 通配�W?
Query query3 = new PrefixQuery(new Term(FieldName, "name1")); // 字段搜烦 Field:Keyword�Q�自动在�l�尾��d�� *
Query query4 = new RangeQuery(new Term(FieldNumber, NumberTools.LongToString(11L)), new Term(FieldNumber, NumberTools.LongToString(13L)), true); // 范围搜烦
Query query5 = new FilteredQuery(query, filter); // 带过滤条件的搜烦
Query query6 =new MatchAllDocsQuery(... // 用来匚w��所有文�?
Query query7 = new FuzzyQuery (...模糊搜烦
Query query8 = new RegexQuery (.. 正则搜烦
Query query9 = new SpanRegexQuery(...)�?同上, 正则表达式的查询�Q?
Query query9 = new SpanQuery 的子�c�d��套其他SpanQuery 增加�?rewrite�Ҏ��
Query query10 =new DisjunctionMaxQuery () ..�c�，提供了针�Ҏ��个短语的最大score。这一点对多字�D늚�搜烦非常有用
Query query11 = new ConstantScoreQuery �c�d��包装了一�?filter produces a score
equal to the query boost for every matching document.

BooleanQuery query12= new BooleanQuery();
booleanQuery.add(termQuery 1, BooleanClause.Occur.SHOULD);
booleanQuery.add(termQuery 2, BooleanClause.Occur.SHOULD);
//�q�个是�ؓ了联合多个查询而做的Query�c? BooleanQuery增加了最��的匚w��短语。见�Q�BooleanQuery.setMinimumNumberShouldMatch().

PhraseQuery
你可能对中日关系比较感兴��，��x��?#8216;�?#8217;�?#8216;�?#8217;挨得比较�q�（5个字的距��d��Q�的文章�Q�超�q�这个距��ȝ��不予考虑�Q�你可以�Q?

PhraseQuery query 13= new PhraseQuery();
query.setSlop(5);
query.add(new Term("content ", “�?#8221;));
query.add(new Term(“content”, “�?#8221;));

PhraseQuery对于短语的顺序是不管�?�q�点在查询时除了提高命中率外,也会�Ҏ��能产生很大的媄�? 利用SpanNearQuery可以对短语的��序�q�行控制,提高性能

BooleanQuery query12= new SpanNearQuery 可以对短语的��序�q�行控制,提高性能

3, 索引文本文�g
如果你想把纯文本文�g索引��h��Q�而不惌��己将它们��d��字符串创建field�Q�你可以用下面的代码创徏field�Q?

Field field = new Field("content", new FileReader(file));

�q�里的file��是该文本文件。该构造函数实际上是读��L��件内容，�q�对其进行烦引，但不存储

4, 如何删除索引
lucene提供了两�U�从索引中删除document的方法，一�U�是

void deleteDocument(int docNum)

�q�种�Ҏ��是根据document在烦引中的编��h��删除�Q�每个document加进索引后都会有个唯一�~�号�Q�所以根据编号删除是一�U�精��删除，但是�q�个�~�号是烦引的内部�l�构�Q�一般我们不会知道某个文件的�~�号到底是几�Q�所以用处不大。另一�U�是

void deleteDocuments(Term term)

�q�种�Ҏ��实际上是首先�Ҏ��参数term执行一个搜索操作，然后把搜索到的结果批量删除了。我们可以通过�q�个�Ҏ��提供一个严格的查询条�g�Q�达到删除指定document的目的�?
下面�l�出一个例子：

Directory dir = FSDirectory.getDirectory(PATH, false);
IndexReader reader = IndexReader.open(dir);
Term term = new Term(field, key);
reader.deleteDocuments(term);
reader.close();

5, 如何更新索引
lucene�q�没有提供专门的索引更新�Ҏ��Q�我们需要先��相应的document删除�Q�然后再��新的document加入索引。例如：

Directory dir = FSDirectory.getDirectory(PATH, false);
IndexReader reader = IndexReader.open(dir);
Term term = new Term(“title”, “lucene introduction”);
reader.deleteDocuments(term);
reader.close();

IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(), true);
Document doc = new Document();
doc.add(new Field("title", "lucene introduction", Field.Store.YES, Field.Index.TOKENIZED));
doc.add(new Field("content", "lucene is funny", Field.Store.YES, Field.Index.TOKENIZED));
writer.addDocument(doc);
writer.optimize();
writer.close();

但是�?.9RC1中说�?
新增�c�： org.apache.lucene.index.IndexModifier �Q�它合�ƈ�? IndexWriter �?IndexReader�Q�好处是我们可以增加和删除文档的时候不同担�?synchronisation/locking 的问题了�?

6, filer�c?使用 Filter �Ҏ��索结果进行过滤，可以获得更小范围内更�_��的结果�?有�h�? 注意它执行的是预处理�Q�而不是对查询�l�果�q�行�q��o�Q�所以��用filter的代��h��很大的，它可能会使一�ơ查询耗时提高一癑ր?

ISOLatin1AccentFilter ,�?ISO Latin 1 字符集中的unaccented�c�d��W�替�?accented �c�d��W?
DateFilter 日期�q��o�?
RangeFileter ,�?DateFilter 更加通用�Q�实�?
LengthFilter �c? 已经�?contrib 攑ֈ��?core 代码里。从 stream 中去掉太长和太短的单�? StopFilter �c? 增加了对处理stop words 的忽略大��写处理

7,本条是一个��用过滤的说明:

�q��o

使用 Filter �Ҏ��索结果进行过滤，可以获得更小范围内更�_��的结果�?

举个例子�Q�我们搜索上架时间在 2005-10-1 �?2005-10-30 之间的商品�?
对于日期旉��Q�我们需要�{换一下才能添加到索引库，同时�q�必��L��索引字段�?
// index
document.Add(FieldDate, DateField.DateToString(date), Field.Store.YES, Field.Index.UN_TOKENIZED);

//...

// search
Filter filter = new DateFilter(FieldDate, DateTime.Parse("2005-10-1"), DateTime.Parse("2005-10-30"));
Hits hits = searcher.Search(query, filter);

除了日期旉��Q�还可以使用整数。比如搜索�h格在 100 ~ 200 之间的商品�?
Lucene.Net NumberTools 对于数字�q�行了补位处理，如果需要��用��Q�Ҏ��可以自己参考源码进行�?
// index
document.Add(new Field(FieldNumber, NumberTools.LongToString((long)price), Field.Store.YES, Field.Index.UN_TOKENIZED));

//...

// search
Filter filter = new RangeFilter(FieldNumber, NumberTools.LongToString(100L), NumberTools.LongToString(200L), true, true);
Hits hits = searcher.Search(query, filter);

使用 Query 作�ؓ�q��o条�g�?
QueryFilter filter = new QueryFilter(QueryParser.Parse("name2", FieldValue, analyzer));

我们�q�可以��?FilteredQuery �q�行多条件过滤�?

Filter filter = new DateFilter(FieldDate, DateTime.Parse("2005-10-10"), DateTime.Parse("2005-10-15"));
Filter filter2 = new RangeFilter(FieldNumber, NumberTools.LongToString(11L), NumberTools.LongToString(13L), true, true);

Query query = QueryParser.Parse("name*", FieldName, analyzer);
query = new FilteredQuery(query, filter);
query = new FilteredQuery(query, filter2);

IndexSearcher searcher = new IndexSearcher(reader);
Hits hits = searcher.Search(query);

8, Sort
有时你想要一个排好序的结果集�Q�就像SQL语句�?#8220;order by”�Q�lucene能做刎ͼ�通过Sort�?
Sort sort = new Sort(“time”); //相当于SQL�?#8220;order by time”
Sort sort = new Sort(“time”, true); // 相当于SQL�?#8220;order by time desc”
下面是一个完整的例子�Q?

Directory dir = FSDirectory.getDirectory(PATH, false);
IndexSearcher is = new IndexSearcher(dir);
QueryParser parser = new QueryParser("content", new StandardAnalyzer());
Query query = parser.parse("title:lucene content:lucene";
RangeFilter filter = new RangeFilter("time", "20060101", "20060230", true, true);
Sort sort = new Sort(“time”);
Hits hits = is.search(query, filter, sort);
for (int i = 0; i < hits.length(); i++)
{
Document doc = hits.doc(i);
System.out.println(doc.get("title");
}
is.close();

9, 性能优化
一直到�q�里�Q�我们还是在讨论怎么样��lucene跑�v来，完成指定��d��。利用前面说的也��实能完成大部分功能。但是测试表明lucene的性能�q�不是很好，在大数据量大�q�发的条件下甚至会有半分钟返回的情况。另外大数据量的数据初始化徏立烦引也是一个十分耗时的过�E�。那么如何提高lucene的性能呢？下面从优化创建烦引性能和优化搜索性能两方面介�l��?

9.1 优化创徏索引性能
�q�方面的优化途径比较有限�Q�IndexWriter提供了一些接口可以控制徏立烦引的操作�Q�另外我们可以先��烦引写入RAMDirectory�Q�再扚w��写入FSDirectory�Q�不��怎样�Q�目的都是尽量少的文件IO�Q�因为创建烦引的最大瓶颈在于磁盘IO。另外选择一个较好的分析器也能提高一些性能�?

9.1.1 通过讄��IndexWriter的参��C��化烦引徏�?
setMaxBufferedDocs(int maxBufferedDocs)
控制写入一个新的segment前内存中保存的document的数目，讄��较大的数目可以加快徏索引速度�Q�默认�ؓ10�?
setMaxMergeDocs(int maxMergeDocs)
控制一个segment中可以保存的最大document数目�Q��D��有利于�q�加索引的速度�Q�默认Integer.MAX_VALUE�Q�无需修改�?
setMergeFactor(int mergeFactor)
控制多个segment合�ƈ的频率，��D��大时建立索引速度较快�Q�默认是10�Q�可以在建立索引时设�|��ؓ100�?

9.1.2 通过RAMDirectory�~�写提高性能
我们可以先把索引写入RAMDirectory�Q�达��C��定数量时再批量写�q�FSDirectory�Q�减��磁盘IO�ơ数�?

FSDirectory fsDir = FSDirectory.getDirectory("/data/index", true);
RAMDirectory ramDir = new RAMDirectory();
IndexWriter fsWriter = new IndexWriter(fsDir, new StandardAnalyzer(), true);
IndexWriter ramWriter = new IndexWriter(ramDir, new StandardAnalyzer(), true);
while (there are documents to index)
{
... create Document ...
ramWriter.addDocument(doc);
if (condition for flushing memory to disk has been met)
{
fsWriter.addIndexes(new Directory[] { ramDir });
ramWriter.close();
ramWriter = new IndexWriter(ramDir, new StandardAnalyzer(), true);
}
}

9.1.3 选择较好的分析器
�q�个优化主要是对��盘�I�间的优化，可以��烦引文件减��将�q�一半，相同��试数据下由600M减少�?80M。但是对旉��q�没有什么帮助，甚至会需要更长时��_��因�ؓ较好的分析器需要匹配词库，会消耗更多cpu�Q�测试数据用StandardAnalyzer耗时133分钟�Q�用MMAnalyzer耗时150分钟�?

9.2 优化搜烦性能
虽然建立索引的操作非常耗时�Q�但是那毕竟只在最初创建时才需要，�q�x��只是��量的维护操作，更何况这些可以放��C��个后台进�E�处理，�q�不影响用户搜烦。我们创建烦引的目的��是�l�用��h��索，所以搜索的性能才是我们最兛_��的。下面就来探讨一下如何提高搜索性能�?

9.2.1 ��烦引放入内�?
�q�是一个最直观的想法，因�ؓ内存比磁盘快很多。Lucene提供了RAMDirectory可以在内存中容纳索引�Q?

Directory fsDir = FSDirectory.getDirectory(“/data/index/”, false);
Directory ramDir = new RAMDirectory(fsDir);
Searcher searcher = new IndexSearcher(ramDir);

但是实践证明RAMDirectory和FSDirectory速度差不多，当数据量很小时两者都非常快，当数据量较大�Ӟ��索引文�g400M�Q�RAMDirectory甚至比FSDirectory�q�要慢一点，�q�确实让人出乎意料�?
而且lucene的搜索非常耗内存，即�ɞ�?00M的烦引文件蝲入内存，在运行一�D�|��间后都会out of memory�Q�所以个��入内存的作用�q�不大�?

9.2.2 优化旉��范围限制
既然载入内存�q�不能提高效率，一定有其它瓉��Q�经�q�测试发现最大的瓉��居然是时间范围限�Ӟ��那么我们可以怎样使时间范围限制的代�h最��呢�Q?
当需要搜索指定时间范围内的结果时�Q�可以：
1、用RangeQuery�Q�设�|�范��_��但是RangeQuery的实现实际上是将旉��范围内的旉��点展开�Q�组成一个个BooleanClause加入到BooleanQuery中查询，因此旉��范围不可能设�|�太大，�l�测试，范围��过一个月��׃��抛BooleanQuery.TooManyClauses�Q�可以通过讄��BooleanQuery.setMaxClauseCount(int maxClauseCount)扩大�Q�但是扩大也是有限的�Q��ƈ且随着maxClauseCount扩大�Q�占用内存也扩大
2、用RangeFilter代替RangeQuery�Q�经��试速度不会比RangeQuery慢，但是仍然有性能瓉��Q�查询的90%以上旉��耗费在RangeFilter�Q�研�I�其源码发现RangeFilter实际上是首先遍历所有烦引，生成一个BitSet�Q�标记每个document�Q�在旉��范围内的标记为true�Q�不在的标记为false�Q�然后将�l�果传递给Searcher查找�Q�这是十分耗时的�?
3、进一步提高性能�Q�这个又有两个思�\�Q?
a、缓存Filter�l�果。既然RangeFilter的执行是在搜索之前，那么它的输入都是一定的�Q�就是IndexReader�Q�而IndexReader是由Directory军_��的，所以可以认为RangeFilter的结果是��p��围的上下限决定的�Q�也��是由具体的RangeFilter对象军_��Q�所以我们只要以RangeFilter对象为键�Q�将filter�l�果BitSet�~�存��h��卛_��。lucene API已经提供了一个CachingWrapperFilter�c�d��装了Filter及其�l�果�Q�所以具体实施�v来我们可以cache CachingWrapperFilter对象�Q�需要注意的是，不要被CachingWrapperFilter的名字及其说明误��|��CachingWrapperFilter看�v来是有缓存功能，但的�~�存是针对同一个filter的，也就是在你用同一个filter�q��o不同IndexReader�Ӟ��它可以帮你缓存不同IndexReader的结果，而我们的需求恰恰相反，我们是用不同filter�q��o同一个IndexReader�Q�所以只能把它作��Z��个封装类�?
b、降低时间精度。研�I�Filter的工作原理可以看出，它每�ơ工作都是遍历整个烦引的�Q�所以时间粒度越大，�Ҏ��快�Q�搜索时间越短，在不影响功能的情况下�Q�时间精度越低越好，有时甚至牺牲一点精度也值得�Q�当然最好的情况是根本不作时间限制�?
下面针对上面的两个思�\演示一下优化结果（都采�?00�U�程随机关键词随��x��间范��_��Q?
�W�一�l�，旉��_�ֺ�为秒�Q?
方式直接用RangeFilter 使用cache 不用filter
�q�_��每个�U�程耗时 10s 1s 300ms

�W�二�l�，旉��_�ֺ�为天
方式直接用RangeFilter 使用cache 不用filter
�q�_��每个�U�程耗时 900ms 360ms 300ms

�׃��上数据可以得出结论：
1�?��量降低旉��_�ֺ��Q�将�_�ֺ��q��换成天带来的性能提高甚至比��用cache�q�好�Q�最好不使用filter�?
2�?在不能降低时间精度的情况下，使用cache能带�?0倍左右的性能提高�?

9.2.3 使用更好的分析器
�q�个跟创建烦引优化道理差不多�Q�烦引文件小了搜索自然会加快。当然这个提高也是有限的。较好的分析器相对于最差的分析器对性能的提升在20%以下�?

10 一些经�?

10.1关键词区分大��写
or AND TO�{�关键词是区分大��写的，lucene只认大写的，��写的当做普通单词�?/strong>

10.2 ��d��互斥�?
同一时刻只能有一个对索引的写操作�Q�在写的同时可以�q�行搜烦

10.3 文�g�?
在写索引的过�E�中��退出将在tmp目录留下一个lock文�g�Q��以后的写操作无法�q�行�Q�可以将其手工删�?

10.4 旉��格式
lucene只支持一�U�时间格式yyMMddHHmmss�Q�所以你传一个yy-MM-dd HH:mm:ss的时间给lucene它是不会当作旉��来处理的

10.5 讄��boost
有些时候在搜烦时某个字�D늚�权重需要大一些，例如你可能认为标题中出现关键词的文章比正文中出现关键词的文章更有价��|��你可以把标题的boost讄��的更大，那么搜烦�l�果会优先显�C�标题中出现关键词的文章�Q�没有��用排序的前题下）。��用方法：
Field. setBoost(float boost);默认值是1.0�Q�也��是说要增加权重的需要设�|�得�?大�?

上面�q�篇关于性能的讲解是很深�? 请学�?

本文转自�Q�http://zhangxinzhou.blog.ccidnet.com/blog-htm-do-showone-uid-36421-type-blog-itemid-213713.html

宋针�q?/a> 2007-12-17 19:36 发表评论

Mon, 17 Dec 2007 11:17:00 GMT

Lucene 是基�?Java 的全文信息检索包�Q�它目前�?Apache Jakarta 家族下面的一个开源项目。在�q�篇文章中，我们首先来看如何利用Lucene 实现高��搜烦功能�Q�然后学习如何利�?Lucene 来创��Z��个健壮的 Web 搜烦应用�E�序�?/blockquote>
在本��文章中�Q�你会学习到如何利用 Lucene 实现高��搜烦功能以及如何利用 Lucene 来创�?Web 搜烦应用�E�序。通过�q�些学习�Q�你��可以利�?Lucene 来创��q��搜烦应用�E�序�?/p>
架构概览

通常一�?Web 搜烦引擎的架构分为前端和后端两部分，��像下图中所�C�。在前端��程中，用户在搜索引擎提供的界面中输入要搜烦的关键词�Q�这里提到的用户界面一般是一个带有输入框�?Web ��面�Q�然后应用程序将搜烦的关键词解析成搜索引擎可以理解的形式�Q��ƈ在烦引文件上�q�行搜烦操作。在排序后，搜烦引擎�q�回搜烦�l�果�l�用戗��在后端��程中，�|�络爬虫或者机器�h从因特网上获�?Web ��面�Q�然后烦引子�pȝ��解析�q�些 Web ��面�q�存入烦引文件中。如果你惛_��?Lucene 来创��Z��?Web 搜烦应用�E�序�Q�那么它的架构也和上面所描述的类��|��如下图中所�C��?/p>
Figure 1. Web 搜烦引擎架构

利用 Lucene 实现高��搜烦

Lucene 支持多种形式的高�U�搜索，我们在这一部分中会�q�行探讨�Q�然后我会��?Lucene �?API 来演�C�如何实现这些高�U�搜索功能�?/p>
布尔操作�W?/span>

大多数的搜烦引擎都会提供布尔操作�W�让用户可以�l�合查询�Q�典型的布尔操作�W�有 AND, OR, NOT。Lucene 支持 5 �U�布��操作符�Q�分别是 AND, OR, NOT, �?+), �?-)。接下来我会讲述每个操作�W�的用法�?

OR: 如果你要搜烦含有字符 A 或�?B 的文档，那么��需要��?OR 操作�W�。需要记住的是，如果你只是简单的用空格将两个关键词分割开�Q�其实在搜烦的时候搜索引擎会自动在两个关键词之间加上 OR 操作�W�。例如，“Java OR Lucene” �?“Java Lucene” 都是搜烦含有 Java 或者含�?Lucene 的文档�?
AND: 如果你需要搜索包含一个以上关键词的文档，那么��需要��?AND 操作�W�。例如，“Java AND Lucene” �q�回所有既包含 Java 又包�?Lucene 的文档�?
NOT: Not 操作�W��得包含紧跟在 NOT 后面的关键词的文档不会被�q�回。例如，如果你想搜烦所有含�?Java 但不含有 Lucene 的文档，你可以��用查询语�?“Java NOT Lucene”。但是你不能只对一个搜索词使用�q�个操作�W�，比如�Q�查询语�?“NOT Java” 不会�q�回��M��l�果�?
加号�Q?�Q?/strong>: �q�个操作�W�的作用�?AND 差不多，但它只对紧跟着它的一个搜索词起作用。例如，如果你想搜烦一定包�?Java�Q�但不一定包�?Lucene 的文档，��可以��用查询语�?#8220;+Java Lucene”�?
减号�Q?�Q?/strong>: �q�个操作�W�的功能�?NOT 一��P��查询语句 “Java -Lucene” �q�回所有包�?Java 但不包含 Lucene 的文档�?

接下来我们看一下如何利�?Lucene 提供�?API 来实现布��查询。下面代�?昄��了如果利用布��操作符�q�行查询的过�E��?/p>
清单1�Q��用布��操作符

//Test boolean operator public void testOperator(String indexDirectory) throws Exception{ Directory dir = FSDirectory.getDirectory(indexDirectory,false); IndexSearcher indexSearcher = new IndexSearcher(dir); String[] searchWords = {"Java AND Lucene", "Java NOT Lucene", "Java OR Lucene", "+Java +Lucene", "+Java -Lucene"}; Analyzer language = new StandardAnalyzer(); Query query; for(int i = 0; i < searchWords.length; i++){ query = QueryParser.parse(searchWords[i], "title", language); Hits results = indexSearcher.search(query); System.out.println(results.length() + "search results for query " + searchWords[i]); } }

域搜�?Field Search)

Lucene 支持域搜索，你可以指定一�ơ查询是在哪些域(Field)上进行。例如，如果索引的文档包含两个域�Q?code>Title �?Content�Q�你��可以��用查�?“Title: Lucene AND Content: Java” 来返回所有在 Title 域上包含 Lucene �q�且�?Content 域上包含 Java 的文档。下面代�?昄��了如何利�?Lucene �?API 来实现域搜烦�?

清单2�Q�实现域搜烦

//Test field search public void testFieldSearch(String indexDirectory) throws Exception{ Directory dir = FSDirectory.getDirectory(indexDirectory,false); IndexSearcher indexSearcher = new IndexSearcher(dir); String searchWords = "title:Lucene AND content:Java"; Analyzer language = new StandardAnalyzer(); Query query = QueryParser.parse(searchWords, "title", language); Hits results = indexSearcher.search(query); System.out.println(results.length() + "search results for query " + searchWords); }

通配�W�搜�?Wildcard Search)

Lucene 支持两种通配�W�：问号�Q�？�Q�和星号�Q?�Q�。你可以使用问号�Q�？�Q�来�q�行单字�W�的通配�W�查询，或者利用星��P��*�Q�进行多字符的通配�W�查询。例如，如果你想搜烦 tiny 或�?tony�Q�你��可以��用查询语�?“t?ny”�Q�如果你��x��?Teach, Teacher �?Teaching�Q�你��可以��用查询语�?“Teach*”。下面代�?昄��了通配�W�查询的�q�程�?

清单3�Q�进行通配�W�查�?/strong>

//Test wildcard search public void testWildcardSearch(String indexDirectory)throws Exception{ Directory dir = FSDirectory.getDirectory(indexDirectory,false); IndexSearcher indexSearcher = new IndexSearcher(dir); String[] searchWords = {"tex*", "tex?", "?ex*"}; Query query; for(int i = 0; i < searchWords.length; i++){ query = new WildcardQuery(new Term("title",searchWords[i])); Hits results = indexSearcher.search(query); System.out.println(results.length() + "search results for query " + searchWords[i]); } }

模糊查询

Lucene 提供的模�p�查询基于编辑距��ȝ��?Edit distance algorithm)。你可以在搜索词的尾部加上字�W?~ 来进行模�p�查询。例如，查询语句 “think~” �q�回所有包含和 think �c�M��的关键词的文档。下面代码显�C�Z��如果利用 Lucene �?API �q�行模糊查询的代码�?

清单4�Q�实现模�p�查�?/strong>

//Test fuzzy search public void testFuzzySearch(String indexDirectory)throws Exception{ Directory dir = FSDirectory.getDirectory(indexDirectory,false); IndexSearcher indexSearcher = new IndexSearcher(dir); String[] searchWords = {"text", "funny"}; Query query; for(int i = 0; i < searchWords.length; i++){ query = new FuzzyQuery(new Term("title",searchWords[i])); Hits results = indexSearcher.search(query); System.out.println(results.length() + "search results for query " + searchWords[i]); } }

范围搜烦(Range Search)

范围搜烦匚w��某个域上的值在一定范围的文档。例如，查询 “age:[18 TO 35]” �q�回所�?age 域上的值在 18 �?35 之间的文档。下面代码显�C�Z��利用 Lucene �?API �q�行�q�回搜烦的过�E��?

清单5�Q�测试范围搜�?/strong>

//Test range search public void testRangeSearch(String indexDirectory)throws Exception{ Directory dir = FSDirectory.getDirectory(indexDirectory,false); IndexSearcher indexSearcher = new IndexSearcher(dir); Term begin = new Term("birthDay","20000101"); Term end = new Term("birthDay","20060606"); Query query = new RangeQuery(begin,end,true); Hits results = indexSearcher.search(query); System.out.println(results.length() + "search results is returned"); }

�?Web 应用�E�序中集�?Lucene

接下来我们开发一�?Web 应用�E�序利用 Lucene 来检索存攑֜�文�g服务器上�?HTML 文档。在开始之前，需要准备如下环境：

Eclipse 集成开发环�?
Tomcat 5.0
Lucene Library
JDK 1.5

�q�个例子使用 Eclipse �q�行 Web 应用�E�序的开发，最�l�这�?Web 应用�E�序跑在 Tomcat 5.0 上面。在准备好开发所必需的环境之后，我们接下来进�?Web 应用�E�序的开发�?

1、创��Z��个动�?Web ��目

�?Eclipse 里面�Q�选择 File > New > Project�Q�然后再弹出的窗口中选择动�?Web ��目�Q�如下图所�C��?

图二�Q�创建动态Web��目

在创建好动�?Web ��目之后�Q�你会看到创建好的项目的�l�构�Q�如下图所�C�，��目的名�U�Cؓ sample.dw.paper.lucene�?

图三�Q�动�?Web ��目的结�?/strong>

2. 设计 Web ��目的架�?/span>

在我们的设计中，把该�pȝ��分成如下四个子系�l�：

用户接口: �q�个子系�l�提供用��L��面��用户可以�?Web 应用�E�序服务器提交搜索请求，然后搜烦�l�果通过用户接口来显�C�出来。我们用一个名�?search.jsp 的页面来实现该子�pȝ��?
��h��理�?/strong>: �q�个子系�l�管理从客户端发送过来的搜烦��h��q�把搜烦��h��分发到搜索子�pȝ��中。最后搜索结果从搜烦子系�l�返回�ƈ最�l�发送到用户接口子系�l�。我们��用一�?Servlet 来实现这个子�pȝ��?
搜烦子系�l?/strong>: �q�个子系�l�负责在索引文�g上进行搜索�ƈ把搜索结构传递给��h��理器。我们��?Lucene 提供�?API 来实现该子系�l��?
索引子系�l?/strong>: �q�个子系�l�用来�ؓ HTML ��面来创建烦引。我们��?Lucene �?API 以及 Lucene 提供的一�?HTML 解析器来创徏该子�pȝ��?

下图昄��了我们设计的详细信息�Q�我们将用户接口子系�l�放�?webContent 目录下面。你会看��C��个名�?search.jsp 的页面在�q�个文�g多w��面。请求管理子�pȝ��在包 sample.dw.paper.lucene.servlet 下面�Q�类 SearchController 负责功能的实现。搜索子�pȝ��攑֜��?sample.dw.paper.lucene.search 当中�Q�它包含了两个类�Q?code>SearchManager �?SearchResultBean�Q�第一个类用来实现搜烦功能�Q�第二个�cȝ��来描�q�搜索结果的�l�构。烦引子�pȝ��攑֜��?sample.dw.paper.lucene.index 当中。类 IndexManager 负责�?HTML 文�g创徏索引。该子系�l�利用包 sample.dw.paper.lucene.util 里面的类 HTMLDocParser 提供的方�?getTitle �?getContent 来对 HTML ��面�q�行解析�?

囑֛��Q�项目的架构设计

3. 子系�l�的实现

在分析了�pȝ��的架构设计之后，我们接下来看�pȝ��实现的详�l�信息�?

用户接口: �q�个子系�l�有一个名�?search.jsp �?JSP 文�g来实玎ͼ��q�个 JSP ��面包含两个部分。第一部分提供了一个用��h��口去�?Web 应用�E�序服务器提交搜索请求，如下图所�C�。注意到�q�里的搜索请求发送到了一个名�?SearchController �?Servlet 上面。Servlet 的名字和具体实现的类的对应关�p�d�� web.xml 里面指定�?

�?�Q�向Web服务器提交搜索请�?/strong>

�q�个JSP的第二部分负责显�C�搜索结果给用户�Q�如图下图所�C�：

�?�Q�显�C�搜索结�?/strong>

��h��理�?/strong>: 一个名�?SearchController �?servlet 用来实现该子�pȝ��。下面代码给��Z��q�个�cȝ��源代码�?

清单�Q�：��h��理器的实现

            package sample.dw.paper.lucene.servlet; import java.io.IOException; import java.util.List; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import sample.dw.paper.lucene.search.SearchManager; /** * This servlet is used to deal with the search request * and return the search results to the client */ public class SearchController extends HttpServlet{ private static final long serialVersionUID = 1L; public void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{ String searchWord = request.getParameter("searchWord"); SearchManager searchManager = new SearchManager(searchWord); List searchResult = null; searchResult = searchManager.search(); RequestDispatcher dispatcher = request.getRequestDispatcher("search.jsp"); request.setAttribute("searchResult",searchResult); dispatcher.forward(request, response); } public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{ doPost(request, response); } }

在代码中�Q?code>doPost �Ҏ��从客��L��获取搜烦词�ƈ创徏�c?SearchManager 的一个实例，其中�c?SearchManager 在搜索子�pȝ��中进行了定义。然后，SearchManager 的方�?search 会被调用。最后搜索结果被�q�回到客��L��?

搜烦子系�l?/strong>: 在这个子�pȝ��中，我们定义了两个类�Q?code>SearchManager �?SearchResultBean。第一个类用来实现搜烦功能�Q�第二个�c�L��个JavaBean�Q�用来描�q�搜索结果的�l�构。下面代码给��Z��c?SearchManager 的源代码�?

清单7�Q�搜索功能的实现

            package sample.dw.paper.lucene.search; import java.io.IOException; import java.util.ArrayList; import java.util.List; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.queryParser.ParseException; import org.apache.lucene.queryParser.QueryParser; import org.apache.lucene.search.Hits; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; import sample.dw.paper.lucene.index.IndexManager; /** * This class is used to search the * Lucene index and return search results */ public class SearchManager { private String searchWord; private IndexManager indexManager; private Analyzer analyzer; public SearchManager(String searchWord){ this.searchWord = searchWord; this.indexManager = new IndexManager(); this.analyzer = new StandardAnalyzer(); } /** * do search */ public List search(){ List searchResult = new ArrayList(); if(false == indexManager.ifIndexExist()){ try { if(false == indexManager.createIndex()){ return searchResult; } } catch (IOException e) { e.printStackTrace(); return searchResult; } } IndexSearcher indexSearcher = null; try{ indexSearcher = new IndexSearcher(indexManager.getIndexDir()); }catch(IOException ioe){ ioe.printStackTrace(); } QueryParser queryParser = new QueryParser("content",analyzer); Query query = null; try { query = queryParser.parse(searchWord); } catch (ParseException e) { e.printStackTrace(); } if(null != query >> null != indexSearcher){ try { Hits hits = indexSearcher.search(query); for(int i = 0; i < hits.length(); i ++){ SearchResultBean resultBean = new SearchResultBean(); resultBean.setHtmlPath(hits.doc(i).get("path")); resultBean.setHtmlTitle(hits.doc(i).get("title")); searchResult.add(resultBean); } } catch (IOException e) { e.printStackTrace(); } } return searchResult; } }

在上面代码，注意到在�q�个�c�里面有三个�U�有属性。第一个是 searchWord�Q�代表了来自客户端的搜烦词。第二个�?indexManager�Q�代表了在烦引子�pȝ��中定义的�c?IndexManager 的一个实例。第三个�?analyzer�Q�代表了用来解析搜烦词的解析器。现在我们把注意力放在方�?search 上面。这个方法首先检查烦引文件是否已�l�存在，如果已经存在�Q�那么就在已�l�存在的索引上进行检索，如果不存在，那么首先调用�c?IndexManager 提供的方法来创徏索引�Q�然后在新创建的索引上进行检索。搜索结果返回后�Q�这个方法从搜烦�l�果中提取出需要的属性�ƈ为每个搜索结果生成类 SearchResultBean 的一个实例。最后这�?SearchResultBean 的实例被攑ֈ�一个列表里面�ƈ�q�回�l�请求管理器�?/p>
在类 SearchResultBean 中，含有两个属性，分别�?htmlPath �?htmlTitle�Q�以及这个两个属性的 get �?set �Ҏ��。这也意味着我们的搜索结果包含两个属性：htmlPath �?htmlTitle�Q�其�?htmlPath 代表�?HTML 文�g的�\径，htmlTitle 代表�?HTML 文�g的标题�?

索引子系�l?/strong>: �c?IndexManager 用来实现�q�个子系�l��?下面代码�l�出了这个类的源代码�?

清单8�Q�烦引子�pȝ��的实�?/strong>

            package sample.dw.paper.lucene.index; import java.io.File; import java.io.IOException; import java.io.Reader; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.store.Directory; import org.apache.lucene.store.FSDirectory; import sample.dw.paper.lucene.util.HTMLDocParser; /** * This class is used to create an index for HTML files * */ public class IndexManager { //the directory that stores HTML files private final String dataDir = "c:\\dataDir"; //the directory that is used to store a Lucene index private final String indexDir = "c:\\indexDir"; /** * create index */ public boolean createIndex() throws IOException{ if(true == ifIndexExist()){ return true; } File dir = new File(dataDir); if(!dir.exists()){ return false; } File[] htmls = dir.listFiles(); Directory fsDirectory = FSDirectory.getDirectory(indexDir, true); Analyzer analyzer = new StandardAnalyzer(); IndexWriter indexWriter = new IndexWriter(fsDirectory, analyzer, true); for(int i = 0; i < htmls.length; i++){ String htmlPath = htmls[i].getAbsolutePath(); if(htmlPath.endsWith(".html") || htmlPath.endsWith(".htm")){ addDocument(htmlPath, indexWriter); } } indexWriter.optimize(); indexWriter.close(); return true; } /** * Add one document to the Lucene index */ public void addDocument(String htmlPath, IndexWriter indexWriter){ HTMLDocParser htmlParser = new HTMLDocParser(htmlPath); String path = htmlParser.getPath(); String title = htmlParser.getTitle(); Reader content = htmlParser.getContent(); Document document = new Document(); document.add(new Field("path",path,Field.Store.YES,Field.Index.NO)); document.add(new Field("title",title,Field.Store.YES,Field.Index.TOKENIZED)); document.add(new Field("content",content)); try { indexWriter.addDocument(document); } catch (IOException e) { e.printStackTrace(); } } /** * judge if the index exists already */ public boolean ifIndexExist(){ File directory = new File(indexDir); if(0 < directory.listFiles().length){ return true; }else{ return false; } } public String getDataDir(){ return this.dataDir; } public String getIndexDir(){ return this.indexDir; } }

�q�个�c�d��含两个私有属性，分别�?dataDir �?indexDir�?code>dataDir 代表存放�{�待�q�行索引�?HTML ��面的�\径，indexDir 代表了存�?Lucene 索引文�g的�\径。类 IndexManager 提供了三个方法，分别�?createIndex, addDocument �?ifIndexExist。如果烦引不存在的话�Q�你可以使用�Ҏ�� createIndex ��d��Z��个新的烦引，用方�?addDocument ��d��一个烦引上��d��文档。在我们的场景中�Q�一个文档就是一�?HTML ��面。方�?addDocument 会调用由�c?HTMLDocParser 提供的方法对 HTML 文档�q�行解析。你可以使用最后一个方�?ifIndexExist 来判�?Lucene 的烦引是否已�l�存在�?

现在我们来看一下放在包 sample.dw.paper.lucene.util 里面的类 HTMLDocParser。这个类用来�?HTML 文�g中提取出文本信息。这个类包含三个�Ҏ��Q�分别是 getContent�Q?code>getTitle �?getPath。第一个方法返回去除了 HTML 标记的文本内容，�W�二个方法返�?HTML 文�g的标题，最后一个方法返�?HTML 文�g的�\径。下面代码给��Z��q�个�cȝ��源代码�?

清单9�Q�HTML 解析�?/strong>

package sample.dw.paper.lucene.util; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.Reader; import java.io.UnsupportedEncodingException; import org.apache.lucene.demo.html.HTMLParser; public class HTMLDocParser { private String htmlPath; private HTMLParser htmlParser; public HTMLDocParser(String htmlPath){ this.htmlPath = htmlPath; initHtmlParser(); } private void initHtmlParser(){ InputStream inputStream = null; try { inputStream = new FileInputStream(htmlPath); } catch (FileNotFoundException e) { e.printStackTrace(); } if(null != inputStream){ try { htmlParser = new HTMLParser(new InputStreamReader(inputStream, "utf-8")); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } } public String getTitle(){ if(null != htmlParser){ try { return htmlParser.getTitle(); } catch (IOException e) { e.printStackTrace(); } catch (InterruptedException e) { e.printStackTrace(); } } return ""; } public Reader getContent(){ if(null != htmlParser){ try { return htmlParser.getReader(); } catch (IOException e) { e.printStackTrace(); } } return null; } public String getPath(){ return this.htmlPath; } }

5�Q�在 Tomcat 5.0 上运行应用程�?/span>

现在我们可以�?Tomcat 5.0 上运行开发好的应用程序�?

右键单击 search.jsp�Q�然后选择 Run as > Run on Server�Q�如下图所�C��?

�?�Q�配�|?Tomcat 5.0

在弹出的�H�口中，选择 Tomcat v5.0 Server 作�ؓ目标 Web 应用�E�序服务器，然后点击 Next�Q�如下图所�C�：

�?�Q�选择 Tomcat 5.0

现在需要指定用来运�?Web 应用�E�序�?Apache Tomcat 5.0 以及 JRE 的�\径。这里你所选择�?JRE 的版本必��d��你用来编�?Java 文�g�?JRE 的版本一致。配�|�好之后�Q�点�?Finish。如下图所�C��?

�?�Q�完成Tomcat 5.0的配�|?/strong>

配置好之后，Tomcat 会自动运行，�q�且会对 search.jsp �q�行�~�译�q�显�C�给用户。如下图所�C��?

�?0�Q�用��L��?/strong>

在输入框中输入关键词 “information” 然后单击 Search 按钮。然后这个页面上会显�C�出搜烦�l�果来，如下图所�C��?

�?1�Q�搜索结�?/strong>

单击搜烦�l�果的第一个链接，��面上就会显�C�出所链接到的��面的内宏V��如下图所�C?

�?2�Q�详�l�信�?/strong>

现在我们已经成功的完成了�C�Z��目的开发，�q�成功的用Lucene实现了搜索和索引功能。你可以下蝲�q�个��目的源代码�Q?a title="下蝲" href="http://www.tkk7.com/Files/szhswl/wa-lucene2_source_code.zip">下蝲�Q��?

�ȝ��

Lucene 提供了灵�zȝ��接口使我们更加方便的设计我们�?Web 搜烦应用�E�序。如果你惛_��你的应用�E�序中加入搜索功能，那么 Lucene 是一个很好的选择。在设计你的下一个带有搜索功能的应用�E�序的时候可以考虑使用 Lucene 来提供搜索功能�?br />
本文摘自�Q�http://www.ibm.com/developerworks/cn/web/wa-lucene2/

宋针�q?/a> 2007-12-17 19:17 发表评论

�l�Compass搜烦��d��高亮(highlight)

Wed, 12 Dec 2007 12:39:00 GMT
        参考了springside的代码实��C��高亮�Q�其实也是很��单的。在原来的searchController里面用的是默认的CompassSearchHelper来搜索的�?br />
1         if (searchHelper == null) {
2             searchHelper = new CompassSearchHelper(getCompass(), getPageSize());
3         }
4         CompassSearchCommand searchCommand = new CompassSearchCommand();
5         searchCommand.setPage(new Integer(currentPage-1));
6         searchCommand.setQuery(query);
7         ModelAndView mv = new ModelAndView();
8         mv.addObject("query", query);
9         mv.addObject("p", currentPage);
10         List<String> errors = new ArrayList<String>();
11         try{
12             CompassSearchResults searchResults = searchHelper.search(searchCommand);
13             mv.addObject(getSearchResultsName(), searchResults);
14         }catch (SearchEngineQueryParseException ex){
15             errors.add(TextUtil.escapeHTML(ex.getMessage()));
16             mv.addObject("errors", errors);
17         }
18
本来打算按照springside里面的封装方法�?br /> http://svn.javascud.org/svn/springside/springside2/trunk/core/src/java/org/springside/components/compass/
�q�里有两个类AdvancedSearchCommand.java,CompassSearchService.java�Q�CompassSearchService里面实现了高亮和排序�Q�后来发现CompassSearchService和CompassSearchHelper长得很像�Q�而且CompassSearchHelper也提供了两个抽象的方法给用户提供一个添加功能的��Z��?br />
1     /**
2      * An option to perform any type of processing before the hits are detached.
3      */
4     protected void doProcessBeforeDetach(CompassSearchCommand searchCommand, CompassSession session, CompassHits hits,
5                                          int from, int size) {
6
7     }
8
9     /**
10      * An option to perform any type of processing after the hits are detached.
11      */
12     protected void doProcessAfterDetach(CompassSearchCommand searchCommand, CompassSession session,
13                                         CompassDetachedHits hits) {
14
15     }
16
所以我们只要实��C��个自��q��CompassSearchHelper覆盖�q�两个方法就可以辑ֈ�实现高亮的目的了�?br />
1 /**
2  * @author somebody
3  * @since Aug 23, 2007 2:04:19 PM
4  * @version $Id AdvanceCompassSearchHelper.java$
5  */
6 public class AdvanceCompassSearchHelper extends CompassSearchHelper {
7
8     private String[] highlightFields;
9
10     public String[] getHighlightFields() {
11         return highlightFields;
12     }
13
14     public void setHighlightFields(String[] highlightFields) {
15         this.highlightFields = highlightFields;
16     }
17
18     /**
19      * @param compass
20      */
21     public AdvanceCompassSearchHelper(Compass compass) {
22         super(compass);
23     }
24
25
26     /* (non-Javadoc)
27      * @see org.compass.core.support.search.CompassSearchHelper#doProcessBeforeDetach(org.compass.core.support.search.CompassSearchCommand, org.compass.core.CompassSession, org.compass.core.CompassHits, int, int)
28      */
29     @Override
30     protected void doProcessBeforeDetach(CompassSearchCommand searchCommand,
31             CompassSession session, CompassHits hits, int from, int size) {
32         if (from < 0) {
33             from = 0;
34             size = hits.getLength();
35         }
36
37         if (highlightFields == null) {
38             return;
39         }
40         // highlight fields
41         for (int i = from; i < size; i++) {
42             for (String highlightField : highlightFields) {
43                 hits.highlighter(i).fragment(highlightField);
44             }
45         }
46     }
47
ok�Q�这样就可以实现高亮了。修改一下SearchController的配�|��?br />
1     <bean id="advanceCompassSearchHelper" class="com.jdkcn.compass.AdvanceCompassSearchHelper">
2         <property name="highlightFields">
3             <list>
4                 <value>contentvalue>
5             list>
6         property>
7         <property name="pageSize"><value>10value>property>
8         <constructor-arg ref="compass"/>
9     bean>
10
11     <bean id="searchController" class="com.jdkcn.web.SearchController" parent="baseController">
12         <property name="compass"><ref bean="compass"/>property>
13         <property name="searchView"><value>searchvalue>property>
14         <property name="searchResultsView"><value>searchvalue>property>
15         <property name="pageSize"><value>10value>property>
16         <property name="searchHelper"><ref local="advanceCompassSearchHelper"/>property>
17     bean>
18
�q�不要忘了修改一下compass settings 修改一下高亮的样式�Q�修改一下高亮的颜色�?br />
1     <bean id="compass" class="org.compass.spring.LocalCompassBean">
2         <property name="resourceDirectoryLocations">
3             <list>
4                 <value>classpath:com/jdkcn/compassvalue>
5             list>
6         property>
7         <property name="connection">
8             <value>/lucene/indexesvalue>
9         property>
10         <property name="compassSettings">
11             <props>
12                 <prop key="compass.transaction.factory">
13                     org.compass.spring.transaction.SpringSyncTransactionFactory
14                 prop>
15                 <prop key="compass.engine.highlighter.default.formatter.simple.pre">
16                     ]]>
17                 prop>
18                 <prop key="compass.engine.highlighter.default.formatter.simple.post">
19                     ]]>
20                 prop>
21             props>
22         property>
23         <property name="transactionManager">
24             <ref bean="transactionManager" />
25         property>
26     bean>
27
ok了，��面上输��Z��下就能看到最�l�效果了${hit.highlightedText['content']?if_exists} 本文转自:http://jdkcn.com/entry/howto-add-highlight-in-compass.html

宋针�q?/a> 2007-12-12 20:39 发表评论

Compass: 在你的应用中集成搜烦功能

Wed, 12 Dec 2007 07:20:00 GMT
在许多应用程序中�Q�用��h��M��提出搜烦和查询领域实例的需求。他们或者希望构��Z��个进入应用程序的入口或者希望填充表单的机制。非常典型的解决�Ҏ��是用��览的方式（把领域的�l�承关系表现出来�Q�这��L��户可以定位和选择一个自己需要的�Q�或者一个检索表单的方式�Q�展��C��个多个输入域的表单，用户可以��索他们需要的信息�Q��?br />
现实中，对于可用性的角度来说�Q�这两种�Ҏ��都不是最佳的。浏览的方式会在有许多分支的时候变得缓慢而笨重。而且�Q�用户通常�_��地知道他们要用到那个应用�Q�然而却不情愿要��览整个�pȝ��来找��C��要的应用。检索表单的方式同样被检索条件个数的多少限制住了。这��p��在设�|��够的��索域�q�是��索表单的复杂性上作出权衡�?br />
从可用性的角度来说�Q�解册��个问题的�{�案��是提供一个单一的、Google样式的检索框�Q�用户可以输入�Q何符合实例字�D늚�内容。他们可以检索和表示�W�合�q�些内容的结果。表单中的这个检索框可以自动填充、Google��模式的输入框�Q�或者是�q�回表格式结果的正则表达式搜索。不��怎样�Q�这�U�解��x��案的�_�N��是UI是简单的�Q�用户可以输入�Q何他们选择的条�Ӟ��然后由搜索引擎去做这些复杂的工作。现在唯一的问题时�Q�如何实现这��L��搜烦��?br />
当面对实��C��l�的多输入域的表单的时候，大部分应用程序都选择了SQL。典型的情况是，��索的字段都与列名相匹配，�q�且使用SQL的LIKE语句。然而，因�ؓ复杂的SQL要去匚w��太多的字�D�，�q�且很多情况下由于这些字�D늚�文本长度问题�Q�造成实现的性能�l�常是非常差的。第二个问题是，�Ҏ��索结果没有排名�ƈ且返回的提示�q�没有反应出与查询的内容有多大相��x��，只是��单地�q�回�l�果�|�了。第三，�Ҏ��索结果相兌��的关键字没有高亮表示�?br />
很快�Q�大家意识到大部分应用程序需要搜索引擎。所有实体的字段可以像只有一个文仉��栯��索引�Q��ƈ且是正则文本搜烦可以匚w��的实体。现在非常流行的搜烦引擎之一是Luence。Lucene是相当不错的搜烦引擎�Q�在很多��目中应用成功。它提供了底层的搜烦引擎API�Q�能够��用Lucene数据�l�构�Q�Document/Field�Q�去索引数据�Q�能供��用查询API或搜索引擎在索引上检索。它已经在多�U�编�E�语�a�上实��C��全部功能�Q�包括Java、C#�?C++�{��?br />
如果我们分析一个典型的Web应用�E�序�Q�一般都有个一个共通的架构和特炏V��通常�Q�应用与后端的关�p�L��据库一起工作。这个应用��用领域模型表�C��个系�l�中的实体，�q��用ORM框架把领域模型映��到数据库上。一般情况下�Q��用一个服务层框架�ȝ��理事务、协作，有时也包括业务逻辑和Web框架。问题就在于怎么把Lucene集成到这��L��应用�E�序中去�?br />
当你试图去集成Lucene的时候，刚刚把第一个简单的�E�序跑�v来的时候，马上��׃��遇到一�q�串的挑战。第一个问题就是烦引应用数据。在之前很长一�D�|��_��相当多的��h��式代码热衷于把领域模型映��到Lucene数据模型上去。Lucene文档�Q�是Lucene主要的数据结构，它是一个扁�q�的�c�M��Map 的，只包含字�W�串的数据结构——所以许多无意义的代码热衷于“植入”�?#8220;植出”领域模型。另外一个问题是�~�少对Lucene的事务控�Ӟ��把领域模型数据存储到数据库和搜烦引擎是有问题的。而且�q�有几个其他的很有名的实践和模式要在Lucene中实玎ͼ�比如�~�存、隐式的搜烦、�ؓ支持Google样式的搜索而创��集的属性和为合适的语义保持可识别的Document对象�Q�等�{��?br /> Compass��?br />
Compass的设计目标是��化企业在集成搜烦功能时的��p��。Compass是在Lucene之上�Q��用了设计很好的搜索引擎的抽象。Compass扩展了核心Lucene�Q�增加了事务控制功能和快速更斎ͼ�也包括在数据库存储烦引的功能。当�Ӟ��它没有去隐藏Lucene的特性——所有Lucene的功能都能通过Compass实现�?br /> Compass核心API

Compass提供�l�了我们��单的�q�且熟悉的API。说Compass提供了让人熟悉的API是因为它模仿了当前流行的ORM框架的API来降低学习曲�Uѝ��Compass以下面一些主要的接口作�ؓ主要内容�Q?br />
* CompassConfiguration�Q�用来在一些设�|�参数、配�|�文件和映射定义上配�|�Compass。通常用来创徏Compass接口�?br /> * Compass�Q��ؓ单线�E��用，创徏�U�程安全的实例来打开Compass Seesion。同栯��提供了一些搜索引擎烦引��别的操作�?br /> * CompassSesssion�Q�用来执行像保存、删除、查找、装载这��L��搜烦操作。很轻量但是�q�不是线�E�安全的�?br /> * CompassTransaction�Q�管理Compass事务的接口。��用它�q�不需要事务管理环境（像Spring、JTA�Q��?br />
下面是��用这些API的一个简单的例子�Q?br />
// 在程序中配置和创建Compass
CompassConfiguration conf =
   new CompassConfiguration().setConnection("/tmp/index").addClass(Author.class);
Compass compass = conf.buildCompass();

  // 一个请求操�?br /> CompassSession session = compass.openSession();
CompassTransaction tx = null;
try {
   tx = session.beginTransaction();
   ...
   session.save(author);
   CompassHits hits = session.find("jack london");
   Author a = (Author) hits.data(0);
   Resource r = hits.resource(0);
   ...
   tx.commit();
} catch (CompassException ce) {
   if (tx != null) tx.rollback();
} finally {
   session.close();
}

��Z��化事务管理代码，Compass提供了好几种选择�Q�首先是使用CompassTemplate�Q�它使用��行的设计模式来抽象事务��理。第二个选择是在和事务管理环境下�Q�这��P��Compass与JTA与Spring�q�样的事务管理器集成�q�在一个已�l�存在的事务中执行。这个情况下�Q�当一�?Session执行的时候，CompassSession 可被用做一个自动加入事务处理的代理。这个代理的创徏可以是编�E�式的，也可使用Spring IOC�Q�Spring 2 中支持@CompassContext�Q��?br />
Compass支持原子性的事务�q�算�Q�与不同的事务管理策略集成，包括本地事务��理、JTA同步、XA for JTA的集成，Spring同步的集成�?br />
Compass的配�|�基�?#8220;键—�?#8221;的一一对应的设�|�。Compass可以使用�~�程式的配置�Q�基于XML DTD的配�|�（定义映射和设�|�）�Q�基于XML Schema的配�|�。基于XML Schema的配�|�得��C��Spring2新的��Z��Schema配置文�g的支持�?br /> 搜烦引擎映射

Compass的主要功能之一��是从应用程序模型到搜烦引擎的声明式映射。Compass搜烦引擎的领域模型由资源�Q�Lucene Document�Q�和属性（一个Lucene Field�Q�组成。这是用来烦引可搜烦内容的抽象数据对象�?br /> RSEM

�W�一个映��是RSEM�Q�Resource/SearchEngine Mapping�Q�。这是一个低�U�别从Compass资源和属性到搜烦引擎抽象到搜索引擎的映射。下面是个对作者资源的RSEM的示例：




上面的例子中�Q�我们定义了一个映��了作者别名的资源。这个资源的映射包括标识资源的ID和几个附加的属性。定义属性是可选的�Q�尽��他们允许声明式的控制不同属性的特征�Q�包括和一个�{换器兌��。下面的�C�Z��代码填充了一个资源�ƈ索引它�?br />
Resource r = session.createResource("author");
  r.addProperty("id", "1")
.addProperty("firstName", "jack")
.addProperty("lastName", "london")
.addProperty("birthdate", new Date());
  session.save(r);


上面的代码显�C�Z��一些Compass的特性。第一�Q�由于一个资源是可识别的�Q�Compass在这个资源已�l�存在的情况下更新它。第二，可以声明式的分配一个�{换器�l�这个资源，可以使用Compass内置的许多�{换器。下面是上面�C�Z��代码的Compass配置�Q�包括对mydate转换器的配置�Q�：

   xsi:schemaLocation="http://www.opensymphony.com/compass/schema/core-config
   http://www.opensymphony.com/comp ... ass-core-config.xsd">
















OSEM

OSEM(Object/Search Engine Mapping)是第二个支持的映��方案。它允许把应用对象的领域模型映射到搜索引擎。下面是Author�c�，使用注释对它�q�行了OSEM定义�Q?br />
@Searchable
public class Author {

@SearchableId
private Long id;

@SearchableComponent
private String Name;

@SearchableReference
private List books;

@SearchableProperty(format = "yyyy-MM-dd")
private Date birthdate;
}

  // ...

@Searchable
public class Name {

@SearchableProperty
private String firstName;

@SearchableProperty
private String lastName;
}

OSEM支持“植入”�?#8220;植出”一个对象的分层�l�构�q�入一个资源。当存储一个Author对象�Q�Compass��׃��“植入”�q�一个资源，Name�c�M��?#8220;植入”�q�相同的资源来表�C��个作者（�׃��l��g的映��）�Q�也包括一个这个作者书�c�列表里的每一本书�Q�存储在其他的资源里�Q�的引用。这个最后得到的资源会存储或者烦引在搜烦引擎中�?br />
Compass提供了非常灵�zȝ��机制来把领域模型映射到搜索引擎中。上面的例子只是一个很��单的例子。OSEM允许制定不同的�{换器�Q�一个类属性对应多个元数据�Q�从资源到属性的映射�Q�、分析器和所有参与的字段�Q�等�{��?br />
下面是author�c�L��样使用的例子：

// ...
Author author = new Author(1, new Name("jack", "london"), new Date());
session.save(author);
// ...
author = (Author) session.load(Author.class, 1);

XSEM

最后，Compass支持的搜索引擎映��是XSEM(Xml/Search Engine Mapping)。这�U�映��允许基于XML映射的定义（用XPath实现�Q�，把XML数据�l�构直接映射到搜索引擎。XSEM的处理同��L��通过对资�?#8220;植入”�?#8220;植出”的处理。Compass提供了一个XML包装对象叫做XmlObject�Q�它定义了不同的实现(dom4j, W3C Document)�Q�这些实现允许XPath表达式来求倹{��如果我们给��Z��面的XML数据�l�构�Q?br />

   Jack
   London




下面是个XSEM的实玎ͼ�









从XML数据�l�构到搜索引擎的映射是��用XPath表达式来完成。XML内容映射可以在搜索引擎中存储为XML�l�构�Q�这样就可以加蝲和搜索数据�?Compass支持多种XML DOM框架�Q��ؓXML内容作映��）�Q�包括JSE5�Q?dom4j�Q�SAX 和XPP�Q�，当然定制的实��C��很好做。下面是个不错的例子�Q?br />
Reader reader = // construct an xml reader over raw xml content
AliasedXmlObject xmlObj = RawAliasedXmlObject("author", reader);
session.save(xmlObj);
// ...
Resource resource = session.loadResource("author", 1);
// since we have xml-content, we can do the following as well
XmlObject xmlObj = session.load("author", 1);

Compass Gps

Compass Gps 是Compass的一个组�Ӟ��用来把不同的数据源与Compass集成。大部分常用的数据源是Compass与ORM工具的集成。Compass支持JPA、Hibernate、OJB、JDO和iBatis�?br />
拿Hibernate作�ؓ例子�Q�Compass�l�出了两个主要的操作�Q�烦引与镜像。拥有这两个映射的对象可以通过使用Hibernate API注册旉��监听�Q�进行自动的镜像操作到搜索引擎。下面的例子�l�出了怎样使用Compass Gps集成Hibernate�Q?br />
SessionFactory sessionFactory = // Hibernate Session Factory
Compass compass = // set up a Compass instance
CompassGps gps = new SingleCompassGps(compass);
CompassGpsDevice device = new Hibernate3GpsDevice("hibernate", sessionFactory);
gps.addDevice(device);
// start the gps, mirroring any changes made through Hibernate API
// to be mirrored to the search engine
gps.start();

  // ....

  // this will cause the database to be indexed
gps.index();
  // this will cause Hibernate to store the author in the database
  // and also index the author object through Compass
hibernateSess.save(new Author(1, new Name("jack", "london"), new Date()));

�ȝ��

�q�篇文章对Compass的主要功能的做了介绍�Q�但只是覆盖了怎样使用Compass的基本功能（��其�Q�Compass�q�有个与Spring集成的扩展组�Ӟ��q�个�q�没介绍�Q�。在使用搜烦引擎的时候，Compass同样也有很多现在��行功能和有一些细微的差别功能�Q�还有配�|�扩展功能。Compass的主要目标，像刚才提到的�Q�是��化集成搜索到��M��c�d��的应用程序中�Q�这��文章只是介�l�了怎么使用的基本信息�?br />
个�h收藏资料�Q�本文严重抄袭：http://bbs.51cto.com/thread-442091-1-1.html

宋针�q?/a> 2007-12-12 15:20 发表评论

lunece查询

Mon, 10 Dec 2007 11:51:00 GMT
//初始化IndexSearcher
IndexSearcher search = new IndexSearcher(path);
//构徏Term
Term term = new Term(fieldName,value);
//构徏Query对象
Query q = new TermQuery(term);
//��?br /> Hits hits = search.search(q);
//昄��查询�l�果
for(int i=0; i {
System.out.println(hits.doc(i));
}
IndexSearcher的常用方法有
search(Query q);
search(Query q,Filter filter);
search(Query q,Sort sort);
search(Query q,Filter filter,Sort sort);

Hits的常用方法有
doc(i); //得到�W�i个Document
id(i); //得到�W�i个Document在lucene文�g中的id�?br /> length(); //�l�果集的数量
score(i); //�W�i个Doucment的文档得分，默认昄��方式为score��D��高，排得��前。score取�?-1之间
如果��x��高score的倹{��可以有建立索引时设�|�，用Field.setBoost(Float f)�Ҏ��
Field f = new Field(fieldname,value,store,tokenized);
f.setBoost(5f);

在lucene中，document ID ��小�Q�查询时所需旉��短�Q�因为Hits的内部缓存机制�?/p>
Lunece的常用搜�?/p>
一、TermQuery 词条搜烦
Query query = new TermQuery(new Term(fieldname,value));

二、BooleanQuery 布尔搜烦
建立二个TermQuery
Query q1 = new TermQuery(new Term(fieldname1,value1));
Query q2 = new TermQuery(new Term(fieldname2,value2));
建立BooleanQuery对象
BooleanQuery query = new BooleanQuery();
query.add(q1,BooleanClause.Occue.MUST);
query.add(q2,BooleanClause.Occue.MUST);
BooleanClause.Occue 有三个静态�?br /> MUST�Q�MUST_NOT�Q�SHOULD
must&&must = (AnB)
must&&must_not = (A-(AnB))
should&&should = (AuB)

三、RangeQuery 范围搜烦
RangeQuery query = new RangeQuery(begin,end,false);
begin = new Term(fieldname,value);
end = new Term(fieldname,value);
false 表示开区间不包�?(begin,end) true 表示闭区�?包括 [begin,end]

四、PrefixQuery 前缀搜烦
PrefixQuery query = new PrefixQuery(new Term(fieldname,value));

五、PhraseQuery 短语搜烦
PhraseQuery query = new PhraseQuery();
query.add(new Term(fieldname,value));
query.add(new Term(fieldname,value));
�q�可以设�|�坡度，query.setSlop(int n),默认�?如查�?#8220;钢铁”�Q�可以用
query.add(new Term(fieldname,”�?#8221;));
query.add(new Term(fieldname,”�?#8221;));
如想�?#8220;钢和�?#8221;�Q?#8220;钢与�?#8221;也查询出来。可以加上query.setSlop(1);

六、MultiPhraseQuery 多短语搜�?br /> MultiPhraseQuery query = new MultiPharseQuery();
//加入短语的前�~�
query.add(new Term(fieldname,value));
//加入短语的后�~�
query.add(new Term[] {new Term(fieldname,value), new Term(fieldname,value)});

七、FuzzyQuery 模糊搜烦
FuzzyQuery query = new FuzzyQuery(new Term(filed,value));
它的三个构造函�?br /> FuzzyQuery(Term t);
FuzzyQuery(Term t,float 0.5f); �怼�度�?-1之间
FuzzyQuery(Term t,float 0.5f,int prefixLength);前缀必须相同的长�?br />
本文转自:http://job5156.xicp.net/?p=72

宋针�q?/a> 2007-12-10 19:51 发表评论

Lucene的工作原�?转蝲)

Thu, 06 Dec 2007 07:57:00 GMT

Lucene的概�q�ͼ�

　　Lucene(发音�?['lusen] )是一个非�怼��U�的开源的全文搜烦引擎,我们可以在它的上面开发出各种全文搜烦的应用来。Lucene在国外有很高的知名度�Q�现在已�l�是Apache的顶�U�项目，在国内，Lucene的应用也��来��多�?/p>
Lucene的算法原理：

　　Lucene是一个高性能的java全文��索工具包�Q�它使用的是倒排文�g索引�l�构。该�l�构及相应的生成��法如下�Q?

　0�Q�设有两��文�?�?
　　文章1的内容�ؓ�Q�Tom lives in Guangzhou,I live in Guangzhou too.
　　文章2的内容�ؓ�Q�He once lived in Shanghai.

　1)全文分析�Q�由于lucene是基于关键词索引和查询的�Q�首先我们要取得�q�两��文章的关键词，通常我们需要如下处理措�?
　　a.我们现在有的是文章内容，即一个字�W�串�Q�我们先要找出字�W�串中的所有单词，卛_��词。英文单词由于用�I�格分隔�Q�比较好处理。中文单词间是连在一��L��需要特�D�的分词处理�?
　　b.文章中的”in”, “once” “too”�{�词没有什么实际意义，中文中的“�?#8221;“�?#8221;�{�字通常也无具体含义�Q�这些不代表概念的词可以�q��o�?
　　c.用户通常希望�?#8220;He”时能把含“he”�Q?#8220;HE”的文章也扑և�来，所以所有单词需要统一大小写�?
　　d.用户通常希望�?#8220;live”时能把含“lives”�Q?#8220;lived”的文章也扑և�来，所以需要把“lives”�Q?#8220;lived”�q�原�?#8220;live”
　　e.文章中的标点�W�号通常不表�C�某�U�概念，也可以过滤掉
　在lucene中以上措施由Analyzer�c�d��?/font>

　�l�过上面处理�?
　　文章1的所有关键词为：[tom] [live] [guangzhou] [i] [live] [guangzhou]
　　文章2的所有关键词为：[he] [live] [shanghai]

　2) 倒排索引�Q�有了关键词后，我们��可以徏立倒排索引了。上面的对应关系是：“文章�?#8221;�?#8220;文章中所有关键词”。倒排索引把这个关�p�d��过来，变成�Q?#8220;关键�?#8221;�?#8220;拥有该关键词的所有文章号”�?/font>文章1�Q?�l�过倒排后变�?
关键�?文章�?
　　guangzhou 1
　　he 2
　　i 1
　　live 1,2
　　shanghai 2
　　tom 1

　　通常仅知道关键词在哪些文章中出现�q�不够，我们�q�需要知道关键词在文章中出现�ơ数和出现的位置�Q�通常有两�U�位�|�：a)字符位置�Q�即记录该词是文章中�W�几个字�W�（优点是关键词亮显时定位快�Q�；b)关键词位�|�，卌��录该词是文章中第几个关键词（优点是节�U�烦引空间、词�l�（phase�Q�查询快�Q�，lucene中记录的��是�q�种位置�?

加上“出现频率”�?#8220;出现位置”信息后，我们的烦引结构变为：

关键�?/td> 文章�?/td> [出现频率] 出现位置

guangzhou 1 [2] 3�Q?

he 2 [1] 1

i 1 [1] 4

live 1 [2] 2�Q?

2 [1] 2

shanghai 2 [1] 3

tom 1 [1] 1

　　以live �q�行��Z��我们说明一下该�l�构�Q�live在文�?中出��C��2�ơ，文章2中出��C��一�ơ，它的出现位置�?#8220;2,5,2”�q�表�C�Z��么呢�Q�我们需要结合文章号和出现频率来分析�Q�文�?中出��C��2�ơ，那么“2,5”��p��C�live在文�?中出现的两个位置�Q�文�?中出��C��一�ơ，剩下�?#8220;2”��p��C�live是文�?中第 2个关键字�?
　　以上��是lucene索引�l�构中最核心的部分。我们注意到关键字是按字�W�顺序排列的�Q�lucene没有使用B树结构）�Q?/font>因此lucene可以�?font color="#008080">二元搜烦��法快速定位关键词�?
　　实现�?lucene��上面三列分别作�?font color="#800000">词典文�g�Q�Term Dictionary�Q��?font color="#800000">频率文�g(frequencies)�?font color="#800000">位置文�g (positions)保存。其�?font color="#008080">词典文�g不仅保存有每个关键词�Q�还保留了指向频率文件和位置文�g的指针，通过指针可以扑ֈ�该关键字的频率信息和位置信息�?

　　Lucene中��用了field的概念，用于表达信息所在位�|�（如标题中�Q�文章中�Q�url中）�Q?/font>在徏索引中，�?font color="#008080">field信息也记录在词典文�g�?/font>�Q�每个关键词都有一个field信息(因�ؓ每个关键字一定属于一个或多个field)�?
　　��Z��减小索引文�g的大��，Lucene对烦引还使用�?font color="#800000">压羃技�?/font>。首先，对词典文件中的关键词�q�行了压�~�，关键词压�~��ؓ<前缀长度�Q�后�~�>�Q�例如：当前词�ؓ“阿拉伯语”�Q�上一个词�?#8220;阿拉�?#8221;�Q�那�?#8220;阿拉伯语”压羃�?lt;3�Q�语>。其�ơ大量用到的是对数字的压�~�，数字只保存与上一个值的差��|��q�样可以减小数字的长度，�q�而减��保存该数字需要的字节敎ͼ�。例如当前文章号�?6389�Q�不压羃要用3个字节保存）�Q�上一文章��h��16382�Q�压�~�后保存7�Q�只用一个字节）�?注意�?#8220;上一个词”。由于词典是按顺序排列的�Q�这�U�压�~�方法的效果会非常显著�?/font>

　　下面我们可以通过对该索引的查询来解释一下�ؓ什么要建立索引�?
假设要查询单�?“live”�Q�lucene先对词典二元查找、找到该词，通过指向频率文�g的指针读出所有文章号�Q�然后返回结果。词兔R��常非常��，因而，整个�q�程的时间是毫秒�U�的�?
而用普通的��序匚w��法�Q�不建烦引，而是�Ҏ��有文章的内容�q�行字符串匹配，�q�个�q�程��会相当�~�慢�Q�当文章数目很大�Ӟ��旉��往往是无法忍受的�?/p>
全文��索框架的实现机制�Q?/strong>

　　Lucene的API接口设计的比较通用�Q�输入输出结构都很像数据库的�?=>记录==>字段�Q�所以很多传�l�的应用的文件、数据库�{�都可以比较方便的映��到Lucene的存储结�?接口中。��M��上看�Q�可以先把Lucene当成一个支持全文烦引的数据库系�l��?/p>
比较一下Lucene和数据库�Q?/p>

Lucene 数据�?/td>

索引数据源：doc(field1,field2...) doc(field1,field2...)

           \ indexer /
       _____________
        | Lucene Index |
            --------------
           / searcher \

�l�果输出�Q�Hits(doc(field1,field2) doc(field1...))

索引数据源：record(field1,field2...) record(field1..)

            \ SQL: insert/
          _____________
           |   DB Index   |
               -------------
            / SQL: select \

�l�果输出�Q�results(record(field1,field2..) record(field1...))

Document�Q�一个需要进行烦引的“单元,一个Document由多个字�D늻��?

Record�Q�记录，包含多个字段

Field�Q�字�D?/p>
Field�Q�字�D?/td>

Hits�Q�查询结果集�Q�由匚w��的Document�l�成
RecordSet�Q�查询结果集�Q�由多个Record�l�成

全文��?≠ like "%keyword%"

　　�׃��数据库烦引不是�ؓ全文索引设计的，因此�Q��用like "%keyword%"�Ӟ��数据库烦引是不�v作用的，在��用like查询�Ӟ��搜烦�q�程又变成类��g��一��页��M��的遍历过�E�了�Q�所以对于含有模�p�查询的数据库服务来��_��LIKE�Ҏ��能的危��x��极大的。如果是需要对多个关键词进行模�p�匹配：like"%keyword1%" and like "%keyword2%" ...其效率也��可惌��知了�?/p>
　　通常比较厚的书籍后面常常附关键词索引表（比如�Q�北京：12, 34��，上�v�Q?,77��?#8230;…�Q�，它能够帮助读者比较快地找到相兛_��容的��늠�。而数据库索引能够大大提高查询的速度原理也是一��P��惛_��一下通过书后面的索引查找的速度要比一��一��地��d��定w��多少�?#8230;…而烦引之所以效率高�Q�另外一个原因是它是排好序的。对于检索系�l�来说核心是一个排序问题�?/p>
　　所以徏立一个高效检索系�l�的关键是徏立一个类��g��U�技索引一��L��反向索引机制�Q�将数据源（比如多篇文章�Q�排序顺序存储的同时�Q�有另外一个排好序的关键词列表�Q�用于存储关键词==>文章映射关系�Q�利用这��L��映射关系索引�Q�[关键�?=>出现关键词的文章�~�号�Q�出现次敎ͼ�甚至包括位置�Q��v始偏�U�量�Q�结束偏�U�量�Q�，出现频率]�Q�检索过�E�就是把模糊查询变成多个可以利用索引的精��查询的逻辑�l�合的过�E�。从而大大提高了多关键词查询的效率，所以，全文��索问题归�l�到最后是一个排序问题�?/p>
　　由此可以看出模糊查询相对数据库的�_��查询是一个非�怸��定的问题，�q�也是大部分数据库对全文��索支持有限的原因。Lucene最核心的特征是通过�Ҏ��的烦引结构实��C��传统数据库不擅长的全文烦引机�Ӟ��q�提供了扩展接口�Q�以方便针对不同应用的定制�?/p>
　　可以通过一下表格对比一下数据库的模�p�查询：

Lucene全文索引引擎数据�?/td>

索引 ��数据源中的数据都通过全文索引一一建立反向索引对于LIKE查询来说�Q�数据传�l�的索引是根本用不上的。数据需要逐个便利记录�q�行GREP式的模糊匚w��Q�比有烦引的搜烦速度要有多个数量�U�的下降�?/td>

匚w��效果通过词元(term)�q�行匚w��Q�通过语言分析接口的实玎ͼ�可以实现对中文等非英语的支持�?/td> 使用�Q�like "%net%" 会把netherlands也匹配出来，
多个关键词的模糊匚w��Q��用like "%com%net%"�Q�就不能匚w��词序颠倒的xxx.net..xxx.com

匚w��?/td> 有匹配度��法�Q�将匚w��E�度�Q�相似度�Q�比较高的结果排在前面�?/td> 没有匚w��E�度的控�Ӟ��比如有记录中net出现5词和出现1�ơ的�Q�结果是一��L��

�l�果输出通过特别的算法，��最匚w��度最高的�?00条结果输出，�l�果集是�~�冲式的��批量读取的�?/td> �q�回所有的�l�果集，在匹配条目非常多的时候（比如上万条）需要大量的内存存放�q�些临时�l�果集�?/td>

可定制�?/td> 通过不同的语�a�分析接口实现�Q�可以方便的定制出符合应用需要的索引规则�Q�包括对中文的支持）没有接口或接口复杂，无法定制

�l�论高负载的模糊查询应用�Q�需要负责的模糊查询的规则，索引的资料量比较�?/td> 使用率低�Q�模�p�匹配规则简单或者需要模�p�查询的资料量少

全文��索和数据库应用最大的不同在于�Q�让最相关�?/span> �?00条结果满��?8%以上用户的需求�?/font>
Lucene的创��C��处：

　　大部分的搜烦�Q�数据库�Q�引擎都是用B树结构来�l�护索引�Q�烦引的更新会导致大量的IO操作�Q�Lucene在实��C��Q�对此稍微有所改进�Q�不是维护一个烦引文�Ӟ��而是在扩展烦引的时候不断创建新的烦引文�Ӟ��然后定期的把�q�些新的��烦引文件合�q�到原先的大索引中（针对不同的更新策略，�Ҏ��的大��可以调��_��Q�这样在不媄响检索的效率的前提下�Q�提高了索引的效率�?/p>
Lucene和其他一些全文检索系�l?应用的比较：

Lucene 其他开源全文检索系�l?/td>

增量索引和批量烦�?/td> 可以�q�行增量的烦�?Append)�Q�可以对于大量数据进行批量烦引，�q�且接口设计用于优化扚w��索引和小扚w��的增量烦引�?/td> 很多�pȝ��只支持批量的索引�Q�有时数据源有一点增加也需要重建烦引�?/td>

数据�?/td> Lucene没有定义具体的数据源�Q�而是一个文档的�l�构�Q�因此可以非常灵�zȝ��适应各种应用�Q�只要前端有合适的转换器把数据源�{换成相应�l�构�Q��?/td> 很多�pȝ��只针对网��，�~�Z��其他格式文档的灵�z�L��?/td>

索引内容抓取 Lucene的文档是由多个字�D늻�成的�Q�甚臛_��以控刉��些字�D�需要进行烦引，那些字段不需要烦引，�q�一步烦引的字段也分为需要分词和不需要分词的�c�d��Q?br />    需要进行分词的索引�Q�比如：标题�Q�文章内容字�D?br />    不需要进行分词的索引�Q�比如：作�?日期字段 �~�Z��通用性，往往��文档整个烦引了

语言分析通过语言分析器的不同扩展实现�Q?br /> 可以�q��o掉不需要的词：an the of �{�，
西文语法分析�Q�将jumps jumped jumper都归�l�成jump�q�行索引/��?br /> 非英文支持：对亚�z�语�a��Q�阿拉伯语言的烦引支�?/td> �~�Z��通用接口实现

查询分析通过查询分析接口的实玎ͼ�可以定制自己的查询语法规则：
比如�Q?多个关键词之间的 + - and or关系�{?/td> 功能较强�?/td>

�q�发讉K�� 能够支持多用��L��使用功能较强�?/td>

关于亚洲语言的的切分词问�?Word Segment)
　　对于中文来说�Q�全文烦引首先还要解决一个语�a�分析的问题，对于英文来说�Q�语句中单词之间是天焉��过�I�格分开的，但亚�z�语�a�的中日韩文语句中的字是一个字挨一个，所有，首先要把语句中按“�?#8221;�q�行索引的话�Q�这个词如何切分出来��是一个很大的问题�?br /> 　　首先�Q�肯定不能用单个字符�?si-gram)为烦引单元，否则�?#8220;上�v”�Ӟ��不能让含�?#8220;��上”也匹配�?br /> 但一句话�Q?#8220;北京天安�?#8221;�Q�计��机如何按照中文的语�a�习惯�q�行切分呢？
　　“北京天安�?#8221; �q�是“�?�?天安�?#8221;�Q�让计算��够按照语�a�习惯�q�行切分�Q�往往需要机器有一个比较丰富的词库才能够比较准��的识别��句中的单词�?br /> 　　另外一个解决的办法是采用自动切分算法：��单词按�?元语�?bigram)方式切分出来�Q�比如：
　　　　"北京天安�? ==> "北京京天天安安门"�?br /> �q�样�Q�在查询的时候，无论是查�?北京" �q�是查询"天安�?�Q�将查询词组按同��L��规则�q�行切分�Q?北京"�Q?天安安门"�Q�多个关键词之间按与"and"的关�pȝ��合，同样能够正确地映��到相应的烦引中。这�U�方式对于其他亚�z�语�a��Q�韩文，日文都是通用的�?br /> 　　��Z��自动切分的最大优�Ҏ��没有词表�l�护成本�Q�实现简单，�~�点是烦引效率低�Q�但对于中小型应用来��_��Z��2元语法的切分�q�是够用的。基�?元切分后的烦引一般大��和源文件差不多�Q�而对于英文，索引文�g一般只有原文�g�?0%-40%不同�?

自动切分词表切分

实现实现非常��?/td> 实现复杂

查询增加了查询分析的复杂�E�度适于实现比较复杂的查询语法规�?/td>

存储效率索引冗余大，索引几乎和原文一样大索引效率高，为原文大��的30�Q�左�?/td>

�l�护成本无词表维护成�?/td> 词表�l�护成本非常高：中日韩等语言需要分别维护�?br /> �q�需要包括词频统计等内容

适用领域嵌入式系�l�：�q�行环境资源有限
分布式系�l�：无词表同步问�?br /> 多语�a�环境�Q�无词表�l�护成本 �Ҏ��询和存储效率要求高的专业搜烦引擎

目前比较大的搜烦引擎的语�a�分析��法一般是��Z��以上2个机制的�l�合。关于中文的语言分析��法�Q�大家可以在Google查关键词"wordsegment search"能找到更多相关的资料�?/p>
Lucene的结构框�Ӟ��
　　注意�Q�Lucene中的一些比较复杂的词法分析是用JavaCC生成的（JavaCC�Q�JavaCompilerCompiler�Q�纯Java的词法分析生成器�Q�，所以如果从源代码编译或需要修改其中的QueryParser、定制自��q��词法分析器，�q�需要从https://javacc.dev.java.net/下蝲javacc�?br /> 　　lucene的组成结构：对于外部应用来说索引模块(index)和检索模�?search)是主要的外部应用入口�?

org.apache.Lucene.search/ 搜烦入口

org.apache.Lucene.index/ 索引入口

org.apache.Lucene.analysis/ 语言分析�?/td>

org.apache.Lucene.queryParser/ 查询分析�?/td>

org.apache.Lucene.document/ 存储�l�构

org.apache.Lucene.store/ 底层IO/存储�l�构

org.apache.Lucene.util/ 一些公用的数据�l�构

从Lucene学到更多�Q?/strong>
　　Luene的确是一个面对对象设计的典范�?/p>

所有的问题都通过一个额外抽象层来方便以后的扩展和重用：你可以通过重新实现来达到自��q��目的�Q�而对其他模块而不需要；
��单的应用入口Searcher, Indexer�Q��ƈ调用底层一�p�d��l��g协同的完成搜索�Q务；
所有的对象的�Q务都非常专一�Q�比如搜索过�E�：QueryParser分析��查询语句�{换成一�p�d��的精��查询的�l�合(Query),通过底层的烦引读取结构IndexReader�q�行索引的读取，�q�用相应的打分器�l�搜索结果进行打�?排序�{�。所有的功能模块原子化程度非帔R��Q�因此可以通过重新实现而不需要修改其他模块�?nbsp;
除了灉|��的应用接口设计，Lucene�q�提供了一些适合大多数应用的语言分析器实玎ͼ�SimpleAnalyser,StandardAnalyser�Q�，�q�也是新用户能够很快上手的重要原因之一�?

�q�些优点都是非常值得在以后的开发中学习借鉴的。作��Z��个通用工具包，Lunece的确�l�予了需要将全文��索功能嵌入到应用中的开发者很多的便利�?br /> 　　此外�Q�通过对Lucene的学习和使用�Q�我也更深刻地理解了��Z��么很多数据库优化设计中要求，比如�Q?/p>

��可能对字段�q�行索引来提高查询速度�Q�但�q�多的烦引会�Ҏ��据库表的更新操作变慢�Q�而对�l�果�q�多的排序条�Ӟ��实际上往往也是性能的杀手之一�?
很多商业数据库对大批量的数据插入操作会提供一些优化参敎ͼ��q�个作用和烦引器的merge_factor的作用是�c�M��的�?
20%/80%原则�Q�查的结果多�q�不�{�于质量好，��其对于�q�回�l�果集很大，如何优化�q�头几十条结果的质量往往才是最重要的�?
��可能让应用从数据库中获得比较小的结果集�Q�因为即使对于大型数据库�Q�对�l�果集的随机讉K��也是一个非常消耗资源的操作�?

本文转自�Q?a >http://www.chedong.com/tech/lucene.html

宋针�q?/a> 2007-12-06 15:57 发表评论

Wed, 05 Dec 2007 09:08:00 GMT
     摘要: 使用Lucene实现全文��索，主要有下面三个步骤：　　1、徏立烦引库�Q�根据网站新��M��息库中的已有的数据资料徏立Lucene索引文�g�?　　2、通过索引库搜索：有了索引后，卛_��使用标准的词法分析器或直接的词法分析器实现进行全文检索�?　　3、维护烦引库�Q�网站新��M��息库中的信息会不断的变动�Q�包括新增、修改及删除�{�，�q�些信息的变动都需要进一步反映到Lucene索引文�g中�? &nbs...  阅读全文

宋针�q?/a> 2007-12-05 17:08 发表评论

Wed, 05 Dec 2007 09:04:00 GMT
     摘要: lucene的简单实�?lt;一> 关键�?   lucene     说明一�?�q�一��文章的用到的lucene,是用2.0版本�?主要在查询的时�?.0版本的lucene与以前的版本有了一些区�? 其实�q�一些代码都是早几个月写�?自己很懒,所以到今天才写到自��q��博客�?高深的文章自己写不了�Q�只能记录下一些简单的记录�?..  阅读全文

宋针�q?/a> 2007-12-05 17:04 发表评论

关键�?/td>	文章�?/td>	[出现频率]	出现位置
guangzhou	1	[2]	3�Q?
he	2	[1]	1
i	1	[1]	4
live	1	[2]	2�Q?
	2	[1]	2
shanghai	2	[1]	3
tom	1	[1]	1

Lucene	数据�?/td>
索引数据源：doc(field1,field2...) doc(field1,field2...) \ indexer / _____________ \| Lucene Index \| -------------- / searcher \ �l�果输出�Q�Hits(doc(field1,field2) doc(field1...))	索引数据源：record(field1,field2...) record(field1..) \ SQL: insert/ _____________ \| DB Index \| ------------- / SQL: select \ �l�果输出�Q�results(record(field1,field2..) record(field1...))
Document�Q�一个需要进行烦引的“单元,一个Document由多个字�D늻��?	Record�Q�记录，包含多个字段
Field�Q�字�D?/p>	Field�Q�字�D?/td>
Hits�Q�查询结果集�Q�由匚w��的Document�l�成	RecordSet�Q�查询结果集�Q�由多个Record�l�成

	Lucene全文索引引擎	数据�?/td>
索引	��数据源中的数据都通过全文索引一一建立反向索引	对于LIKE查询来说�Q�数据传�l�的索引是根本用不上的。数据需要逐个便利记录�q�行GREP式的模糊匚w��Q�比有烦引的搜烦速度要有多个数量�U�的下降�?/td>
匚w��效果	通过词元(term)�q�行匚w��Q�通过语言分析接口的实玎ͼ�可以实现对中文等非英语的支持�?/td>	使用�Q�like "%net%" 会把netherlands也匹配出来，多个关键词的模糊匚w��Q��用like "%com%net%"�Q�就不能匚w��词序颠倒的xxx.net..xxx.com
匚w��?/td>	有匹配度��法�Q�将匚w��E�度�Q�相似度�Q�比较高的结果排在前面�?/td>	没有匚w��E�度的控�Ӟ��比如有记录中net出现5词和出现1�ơ的�Q�结果是一��L��
�l�果输出	通过特别的算法，��最匚w��度最高的�?00条结果输出，�l�果集是�~�冲式的��批量读取的�?/td>	�q�回所有的�l�果集，在匹配条目非常多的时候（比如上万条）需要大量的内存存放�q�些临时�l�果集�?/td>
可定制�?/td>	通过不同的语�a�分析接口实现�Q�可以方便的定制出符合应用需要的索引规则�Q�包括对中文的支持）	没有接口或接口复杂，无法定制
�l�论	高负载的模糊查询应用�Q�需要负责的模糊查询的规则，索引的资料量比较�?/td>	使用率低�Q�模�p�匹配规则简单或者需要模�p�查询的资料量少

	Lucene	其他开源全文检索系�l?/td>
增量索引和批量烦�?/td>	可以�q�行增量的烦�?Append)�Q�可以对于大量数据进行批量烦引，�q�且接口设计用于优化扚w��索引和小扚w��的增量烦引�?/td>	很多�pȝ��只支持批量的索引�Q�有时数据源有一点增加也需要重建烦引�?/td>
数据�?/td>	Lucene没有定义具体的数据源�Q�而是一个文档的�l�构�Q�因此可以非常灵�zȝ��适应各种应用�Q�只要前端有合适的转换器把数据源�{换成相应�l�构�Q��?/td>	很多�pȝ��只针对网��，�~�Z��其他格式文档的灵�z�L��?/td>
索引内容抓取	Lucene的文档是由多个字�D늻�成的�Q�甚臛_��以控刉��些字�D�需要进行烦引，那些字段不需要烦引，�q�一步烦引的字段也分为需要分词和不需要分词的�c�d��Q?br /> 需要进行分词的索引�Q�比如：标题�Q�文章内容字�D?br /> 不需要进行分词的索引�Q�比如：作�?日期字段	�~�Z��通用性，往往��文档整个烦引了
语言分析	通过语言分析器的不同扩展实现�Q?br /> 可以�q��o掉不需要的词：an the of �{�，西文语法分析�Q�将jumps jumped jumper都归�l�成jump�q�行索引/��?br /> 非英文支持：对亚�z�语�a��Q�阿拉伯语言的烦引支�?/td>	�~�Z��通用接口实现
查询分析	通过查询分析接口的实玎ͼ�可以定制自己的查询语法规则：比如�Q?多个关键词之间的 + - and or关系�{?/td>	功能较强�?/td>
�q�发讉K��	能够支持多用��L��使用	功能较强�?/td>

	自动切分	词表切分
实现	实现非常��?/td>	实现复杂
查询	增加了查询分析的复杂�E�度	适于实现比较复杂的查询语法规�?/td>
存储效率	索引冗余大，索引几乎和原文一样大	索引效率高，为原文大��的30�Q�左�?/td>
�l�护成本	无词表维护成�?/td>	词表�l�护成本非常高：中日韩等语言需要分别维护�?br /> �q�需要包括词频统计等内容
适用领域	嵌入式系�l�：�q�行环境资源有限分布式系�l�：无词表同步问�?br /> 多语�a�环境�Q�无词表�l�护成本	�Ҏ��询和存储效率要求高的专业搜烦引擎

org.apache.Lucene.search/	搜烦入口
org.apache.Lucene.index/	索引入口
org.apache.Lucene.analysis/	语言分析�?/td>
org.apache.Lucene.queryParser/	查询分析�?/td>
org.apache.Lucene.document/	存储�l�构
org.apache.Lucene.store/	底层IO/存储�l�构
org.apache.Lucene.util/	一些公用的数据�l�构