日韩精品网站,亚洲欧美日韩综合,亚洲www啪成人一区二区麻豆

Masen — Thu, 31 May 2007 04:56:00 GMT

通过�q�几天的看书和学习，�?Lucene 有了更进一步的认识�Q�所以�ȝ��一下这些天的学习成果把 Lucene 的学习心得也学出来�?

1 Lucene 的认�?

提到 Lucene 很多人都知道�q�个开源的搜烦工具�Q�其��力也是很大的。它让我们对搜烦引擎的认识不在那么神�U�，也不会在觉得癑ֺ��?google 的技术多么的高深没测�Q�其实其原理都是一��L��Q�只是他们要做的更好�Q�走的更�q��Ş了�?

Lucene 可以对�Q何的数据做烦引和搜烦�Q�说�q�样的话其实不过分，真的��是�q�样�Q�只要你能处理好�q�些数据�Q�交�l?Lucene ��d��立烦引它都可以帮你把�q�些数据�l�检索出来，是不是很好玩了。真正好玩的地方�q�在后面呢�?

2 Lucene 的学�?

前面已经�?Lucene 有了一些了解，现在我们惌��它怎么��L��索这些数据呢�Q�如果知道倒排索引�Q�你��q��道了�Q�其�?lucene ��索的是它自己建立的烦引，从烦引中的到数据的指针，从而得到数据。其实就�q�么��单�?

提到索引�Q�现在的索引技术中有：倒排索引、后�~�数组和签名文件这三种�Q�其中后�~�数组�q�种技术虽然检索速度也很快，但是它的数据�l�构构造和�l�护都是相当�ȝ��的所以不可取了。我也懒得去看了。至于签名文件嘛�Q�那�?80 �q�代的玩意了�Q�现在已�l�过时了。现在可是倒排索引的天下啊�Q�相信百度和 google 都是�q�种技术�?

3 索引的徏�?

我们从烦引的建立入手�Q?

我们建立一�?lucene 的烦引时必须先徏立该索引文�g存放的位�|�，看一下代码：

IndexWriter writer = null;

writer = new IndexWriter("c:\\index", new CJKAnalyzer(), true);

�q�段代码��时建立一个烦引前所必须的操作，先声明这�?IndexWriter �Q�实例化它你必须传入三个参数。他们分别代表：你要建立索引文�g的存放位�|�、你要��用烦引徏立的分词�Ҏ��、是否重新徏立烦引。这样你��告�?lucene 我要�?c 盘的 index 目录下徏立烦引文�Ӟ��我要使用车东老师的二分词��法做分析器、我要在�q�个目录下删除以前的索引或�Q何文件创立我的烦引文件�?

索引的徏立有三种方式�Q�让我一一道来�Q?

1 �?new IndexWriter(new RAMDirectory(), new StandardAnalyzer(), true);

在内存中建立索引�Q�速度最快但是耗资源，而且重启��没了�?

2 �?new IndexWriter(FSDirectory.getDirectory(path, true), new StandardAnalyzer(), true);

在文件系�l�中建立索引�Q�这里有两个参数�Q�分别是�Q�徏立烦引的路径、是否要删除当前目录下的文�g重新建立索引�?

3 �?new IndexWriter("c:\\index", new CJKAnalyzer(), true);

最常见的一�U�，在制定目录下建立索引�Q�看了源码你��q��道这�U�方法也是用的第二种方式�?Lucene 的源码：

public IndexWriter(String path, Analyzer a, boolean create)

throws IOException {

this(FSDirectory.getDirectory(path, create), a, create, true);

}

我想的没错�?

Indexwriter 性能调整参数�Q?

�W�一个优化的参数 �Q?mergeFactor �q�个参数用于控制 lucene 在把索引从内存写入到��盘上的文�g�pȝ��时内存最大的 Document 对象的数量。这个数要根据你的计��机讄��Q�默认情况下�?10 �?

�W�二个优化的参数 �Q?maxMergeFactor �q�个参数用来讄��当有多少�?Segment 时进行合�q�操作。当然我们知道当索引文�g太多的话其检索的速度��׃��很慢�Q�所以我们要当文件数量一定时让它�q�行索引的合�q�。这样就可以加快索引速度�Q�但是这个��D��Ҏ��你的情况而定。当文��数量较多时我们将��D��大些�Q�当文档数量较少时我们将��D��些�?

�W�三个优化的参数 �Q?minMergeDocs �q�个参数用于控制内存中文��的数量�?

�q�样我们建立索引已经完成�Q�接下来我们要徏�?Document 对象�Q�因��Z��必须告诉我要搜烦什么吧�Q�好了，看看源码�Q?

File file = new File("1.txt");

Document doc = new Document();

doc.add(Field.UnIndexed("filename", file.getName()));

FileInputStream fis = new FileInputStream(file);

byte[] b = new byte[fis.available()];

fis.read(b);

String content = new String(b);

doc.add(Field.Text("content", content));

fis.close();

以上我们��完成了��?1.txt 文�g攑ֈ�我们�?Document 对象了。这里我们用�?Field.Text(); �q�样的操作和 doc.add(); �q�样的方法徏立的。这也是建立索引的必��R�?

�E�微介绍一�?Field �Q�它��是你要建立索引的字�D�c��它分别�?

�c�d�� / �Ҏ��	是否分词	是否索引	是否存储	常用实例
Keyword(String,String) Keyword(String,Date)	�?	�?	�?	电话��L��Q��n份证�Q��h名，地名�Q�日�?
Unindexed(String,String)	�?	�?	�?	文��c�d��Q�文��名�U?
UnStored(String,String)	�?	�?	�?	文��的标题和内容
Text(String,String)	�?	�?	�?	文档的标题和内容
Text(String,Reader)	�?	�?	�?	文��的标题和内容

�q�样我们要徏什么样的烦引就对号入��吧，只要最后我们��?doc.add(Field.Text("content", content)); 把它��d��?Document 中就可以了�?

�q�时我们的文��已�l�徏立好了，现在��开始向索引中添加文��吧�Q�这里我们��?

writer.addDocument(doc); 来向 Indexwriter 索引中添加构造好的文��?

�q�样我们是不是就可以说我们已�l�徏立完了烦引呢�Q�其实不�Ӟ��我们�q�要优化优化�Q�这��h��快嘛�Q�对不对�Q?

writer.optimize(); �q�样一句话��可以实现烦引优化了�Q�具体的优化�q�程我就不说了，是不是很��单。但是一定不要忘了哦。调用这个方法时最好徏立一个合适的周期。定期进行优化�?

好了�Q�这��h��们就完成了烦引的建立了�?

下面我们看看�~�媄的合�q�吧�Q?

当我们在很多地方建立了很多的索引后，惌��合�ƈ�q�些索引我们怎么办呢�Q?

使用 IndexWriter.assIndexs(New Directory[]{path});

��可以对 path 路径下的索引合�ƈ到当前的索引中了�?

下面再看看烦引的删除吧！

有一些过时的索引我们需要删除，怎么办呢�Q?

IndexReader reader = IndexReader.open("c:\\index");

reader.delete(0);

�q�样我们��可以按照文��的��序删除对应的文��了�Q�但是这样不太现实，不对吗？我们怎么会知道文��的��序呢？

下面我们看看�W�二中方法：

IndexReader reader = IndexReader.open("c:\\index");

reader.delete(new Term("name","word1"));

reader.close();

按照字段来删除对应的文档�Q�这样合理多了。以后要删除时就按照词条的方式去删除�?!

索引锁： write.lock , commit.lock.

write.lock 是�ؓ了避免几个线�E�同时修改一个烦引文��而设�|�。当实例一�?indexwrite 时徏立和使用 indexReader 删除文��时徏立�?

Commit.lock 该锁主要�?segment 在徏立，合�ƈ或读取时生成�?

4 Lucene 的搜�?

以上完成了烦引的建立和一些关于烦引的知识�Q�但是光有烦引是不行的，我们真正要做的检索，�q�才是我们的关键。现在我们看�?lucene 的检索吧�?

认识��索从��索的工具开始吧�Q?IndexSearcher �c�L�� lucene 用于��索的工具�c�，我们在检索之前要得到�q�个�cȝ��实例�?

�W�一步我们看以下代码�Q?

IndexSearcher searcher = new IndexSearcher("c:\\index");

创徏 IndexSearcher 实例需要告�?lucene 索引的位�|�，��是�?IndexWrite 的文件�\径�?

Query query = null;

Hits hits = null;

query = QueryParser.parse(key1, "name", new StandardAnalyzer());

hits = searcher.search(query);

if (hits != null) {

if (hits.length() == 0) {

System.out.println(" 没有扑ֈ��M��l�果 ");

} else {

System.out.print(" 扑ֈ� ");

for (int i = 0; i < hits.length(); i++) {

Document d = hits.doc(i);

String dname = d.get("title");

System.out.print(dname + " " );

}

以上��是一个完整的��索过�E�，�q�里我们看见了个 Query �?Hits �Q�这两个�c�d��是比较关键的了，我们先从��索结果的 Hits �c�说赗��?

我们使用 Hits �l�常使用的几个方法有�Q?

length() : �q�回搜烦�l�果的��L��量�?

Doc(int n) : 攑֛��W?n 个文��?

Id(int n) : �q�回�W?n 个文档的内部�~�号�?

Sorce(int n) : �q�回�W?n 个文��的得分�?

看见�q�个 Sorce(int n) �q�个�Ҏ��Q�是不是��可以联惛_��搜烦引擎的排序问题呢�Q�像癑ֺ�的推�q�是怎么做出来的�?, 可想而知吧，那就说明必定存在一中方法可以动态的改变某片文��的得分。对了， lucene 中可以��?Document �?setBoost �Ҏ��可以改变当前文��?boost 因子�?

下面我们看看�Q?

Document doc1 = new Document();

doc1.add(Field.Text("contents", "word1 word"));

doc1.add(Field.Keyword("path", "path\\document1.txt"));

doc1.setBoost(1.0f);

�q�样我们��在改变了篇文��的评分了�Q�当 boost 的��D��大它的分值就��高�Q�其出现的位�|�就��靠前�?

让我们再来看�?lucene 为我们提供的各种 Query 吧�?

�W�一�?nbsp; 按词条搜�?�Q?TermQuery
query = new TermQuery(new Term("name","word1"));

hits = searcher.search(query);

�q�样��可以把 field �?name 的所有包�?word1 的文档检索出来了�?

�W�二�?nbsp; “与或”搜烦 �Q?BooleanQuery

它实际是一个组�?query 看看下面的代码：

query1 = new TermQuery(new Term("name","word1"));

query2 = new TermQuery(new Term("name","word2"));

query = new BooleanQuery();

query.add(query1, false, false);

query.add(query2, false, false);

hits = searcher.search(query);

看看 booleanQuery 的用法吧�Q?

true & true : 表明当前加入的字句是必须要满��的。相当于逻辑与�?

false & true : 表明当前加入的字句是不可一被满��的�Q?相当于逻辑非�?

false & false : 表明当前加入的字句是可选的�Q�相当于逻辑或�?

true & true : 错误的情��c�?

Lucene 可以最多支持连�l?1024 �?query 的组合�?

�W�三�?nbsp; 在某一范围内搜�?�Q?RangeQuery

IndexSearcher searcher = new IndexSearcher("c:\\index");

Term beginTime = new Term("time","200001");

Term endTime = new Term("time","200005");

Hits hits = null;

RangeQuery query = null;

query = new RangeQuery(beginTime, endTime, false);

hits = searcher.search(query);

RangeQuery 的构造函数的参数分别代表起始、结束、是否包括边界。这��h��们就可以按照要求��索了�?

�W�四�?nbsp; 使用前缀��?�Q?PrefixQuery

�q�个��索的机制有点�c�M��?indexOf() 从前�~�查找。这个常在英文中使用�Q�中文中��很��用了。代码如下：

IndexSearcher searcher = new IndexSearcher("c:\\index");

Term pre1 = new Term("name", "Da");

query = new PrefixQuery(pre1);

hits = searcher.search(query);

�W�五�?nbsp; 多关键字的搜�?�Q?PhraseQuery

可以多个关键字同时查询。��用如下：

query = new PhraseQuery();

query.add(word1);

query.add(word2);

query.setSlop(0);

hits = searcher.search(query);

printResult(hits, "'david' �?'mary' 紧紧盔R��?Document");

query.setSlop(2);

hits = searcher.search(query);

printResult(hits, "'david' �?'mary' 中相隔两个词的短�?");

�q�里我们要注�?query.setSlop(); �q�个�Ҏ��的含义�?

query.setSlop(0); 紧紧相连 �Q�这个的条�g比较苛刻�Q?

query.setSlop(2); 盔R��

�W�六�?nbsp; 使用短语�~�搜烦 �Q?PharsePrefixQuery

使用 PharsePrefixQuery 可以很容易的实现相关短语的检索功能�?

实例�Q?

query = new PhrasePrefixQuery();

// 加入可能的所有不��定的词

Term word1 = new Term("content", "david");

Term word2 = new Term("content", "mary");

Term word3 = new Term("content", "smith");

Term word4 = new Term("content", "robert");

query.add(new Term[]{word1, word2});

// 加入��定的词

query.add(word4);

query.setSlop(2);

hits = searcher.search(query);

printResult(hits, " 存在短语 'david robert' �?'mary robert' 的文�?");

�W�七�?nbsp; 相近词语的搜�?�Q?fuzzyQuery

可以通俗的说它是一�U�模�p�查询�?

实例�Q?

Term word1 = new Term("content", "david");

Hits hits = null;

FuzzyQuery query = null;

query = new FuzzyQuery(word1);

hits = searcher.search(query);

printResult(hits," �?'david' �怼�的词 ");

�W�八�?nbsp; 使用通配�W�搜�?�Q?WildcardQuery

实例�Q?

IndexSearcher searcher = new IndexSearcher("c:\\index");

Term word1 = new Term("content", "*ever");

Term word2 = new Term("content", "wh?ever");

Term word3 = new Term("content", "h??ever");

Term word4 = new Term("content", "ever*");

WildcardQuery query = null;

Hits hits = null;

query = new WildcardQuery(word1);

hits = searcher.search(query);

printResult(hits, "*ever");

query = new WildcardQuery(word2);

hits = searcher.search(query);

printResult(hits, "wh?ever");

query = new WildcardQuery(word3);

hits = searcher.search(query);

printResult(hits, "h??ever");

query = new WildcardQuery(word4);

hits = searcher.search(query);

printResult(hits, "ever*");

�׃��可以看出通配�W�？代便 1 个字�W�， * 代表 0 到多个字�W��?

Lucene 现在支持以上八中的搜索方式，我们可以�Ҏ��需要选择适合自己的搜索方式。当然上面提供的一些可能对英文�q�是比较有效�Q�中文就不可取了�Q�所以我们开始想想百度，我们只在一个输入框中搜索结果。有了这个疑问我们揭开下一章的讨论吧！

查询字符串的解析�Q�这个就是我们经常在一个输入框中输入我们要��索的文字�Q�交�l�搜索引擎去帮我们分词�?

QueryParser �c�d��是对查询字符串的解析�c�R�?

看看它的用法�Q?

query = QueryParser.parse(key1, "name", new StandardAnalyzer());

hits = searcher.search(query);

它直接返回一�?Query 对象。需要传入的参数分别是：

用户需要查询的字符丌Ӏ�需要检索的对应字段名称、采用的分词�c�R�?

Analyzer analyzer = new CJKAnalyzer();

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

Query query = MultiFieldQueryParser.parse(searchword, fields, analyzer);

Hits hits = searcher.search(query);

QueryParser �?#8220;�?#8221; �?“�?#8221;�Q?

QueryParser 之间默认是或�Q�我们想改变��Z��的话加入以下代码�Q?

QueryParser.setOperator(QueryParser.DEFAULT_OPERATOR_AND);

��可以了�?

5 高��搜烦技�?

前面我们已经介绍了一般情况下 lucene 的��用技巧，现在我们探讨一下高�U�搜索的技巧吧�Q?

1�?�Ҏ��索结果进行排序：

1�Q?使用 sort �c�L��序：

Sort sort = new Sort();

hits = searcher.search(query,sort);

�q�种方式是��用默认的 sort 排序方式�q�行排序。默认的 sort 排序是按照相兛_��q�行排序。即通过 luence 的评分机制进行排序�?

2) �Ҏ��一字段�q�行排序

Sort sort = new Sort( “ content ” );

hits = searcher.search(query,sort);

3) 对多个字�D�进行排�?

Sort sort = new Sort(new SortField[]{new SortField("title"),new SortField("contents")});

hits = searcher.search(query,sort);

2�?多域搜烦和多索引搜烦�Q?

在��?luecene �Ӟ��如果查询的只是某�?terms �Q�而不兛_��q�些词条到时来自那个字段中时。这时可以��?MultiFieldQueryParser �c�R��这个用于用��h��索含有某个关键字是否存在在字�D�中�Q�他们之间的关系使用 OR �q�接。即不管存在在哪一个字�D�都会显�C�显�C�出来�?

使用 MultiSearcher 可以满��同时多烦引的搜烦需求�?

Searcher[] searchers = new Searcher[2];

searchers[0] = new IndexSearcher(indexStoreB);

searchers[1] = new IndexSearcher(indexStoreA);

// 创徏一个多索引��索器

Searcher mSearcher = new MultiSearcher(searchers);

3�? �Ҏ��索结果进行过滤：

1) �Ҏ��间进行过�?

通常情况下我们对搜烦�l�果要进行过滤显�C�，卛_��昄��q��o后的�l�果�?

doc.add(Field.Keyword("datefield", DateField.timeToString(now - 1000)));

DateFilter df1 = DateFilter.Before("datefield", now);

2) 查询�q��o�?

通过查询�q��o器可以过滤一部分的信息�?

Filter filter = new Filter()

{

public BitSet bits (IndexReader reader) throws IOException

{

BitSet bitset = new BitSet(5);

bitset.set (1);

bitset.set (3);

return bitset;

}

};

// 生成带有�q��o器的查询对象

Query filteredquery = new FilteredQuery (query, filter);

// �q�回��索结�?

Hits hits = searcher.search (filteredquery);

�q�样我们��可以��用自己定义的�q��o方式去过滤信息了�?

3) 带缓存的�q��o器：

使用待缓存的�q��o器我们可以重用过滤功能，如下�Q?

MockFilter filter = new MockFilter();

CachingWrapperFilter cacher = new CachingWrapperFilter(filter);

cacher.bits(reader);

以上介绍完了现在学习 luence �Q�没有太详细的介�l�它的实玎ͼ�因�ؓ它对于我们来说是一个工��P��既然是工��h��们就要会用就可以了�?

Masen 2007-05-31 12:56 发表评论

Lucene 索引机制

Masen — Thu, 31 May 2007 03:52:00 GMT

深入 Lucene 索引机制

Lucene 是一个基�?Java 的全文检索工具包�Q�你可以利用它来��Z��的应用程序加入烦引和��索功能。Lucene 目前是著名的 Apache Jakarta 家族中的一个开源项目，下面我们卛_��学习 Lucene 的烦引机制以及它的烦引文件的�l�构�?/p>
在这��文章中�Q�我们首先演�C�如何��?Lucene 来烦引文��，接着讨论如何提高索引的性能。最后我们来分析 Lucene 的烦引文件结构。需要记住的是，Lucene 不是一个完整的应用�E�序�Q�而是一个信息检索包�Q�它方便你�ؓ你的应用�E�序��d��索引和搜索功能�?/p>

架构概览

图一昄��?Lucene 的烦引机制的架构。Lucene 使用各种解析器对各种不同�c�d��的文档进行解析。比如对�?HTML 文��Q�HTML 解析器会做一些预处理的工作，比如�q��o文��中的 HTML 标签�{�等。HTML 解析器的输出的是文本内容�Q�接着 Lucene 的分词器(Analyzer)从文本内容中提取出烦引项以及相关信息�Q�比如烦引项的出现频率。接着 Lucene 的分词器把这些信息写到烦引文件中�?/p>
图一�Q�Lucene 索引机制架构

回页�?/font>

用Lucene索引文��

接下来我��一步一步的来演�C�如何利�?Lucene ��Z��的文��创建烦引。只要你能将要烦引的文�g转化成文本格式，Lucene ��p��Z��的文��徏立烦引。比如，如果你想�?HTML 文��或�?PDF 文档建立索引�Q�那么首先你��需要从�q�些文��中提取出文本信息�Q�然后把文本信息交给 Lucene 建立索引。我们接下来的例子用来演�C�如何利�?Lucene 为后�~�名�ؓ txt 的文件徏立烦引�?/p>

1�Q?准备文本文�g

首先把一些以 txt 为后�~�名的文本文�g攑ֈ�一个目录中�Q�比如在 Windows �q�_��上，你可以放�?C:\\files_to_index 下面�?/p>

2�Q?创徏索引

清单1是�ؓ我们所准备的文��创建烦引的代码�?/p>
清单1�Q�用 Lucene 索引你的文��


            package lucene.index;
            import java.io.File;
            import java.io.FileReader;
            import java.io.Reader;
            import java.util.Date;
            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;
            /**
            * This class demonstrates the process of creating an index with Lucene
            * for text files in a directory.
            */
            public class TextFileIndexer {
            public static void main(String[] args) throws Exception{
            //fileDir is the directory that contains the text files to be indexed
            File   fileDir  = new File("C:\\files_to_index ");
            //indexDir is the directory that hosts Lucene's index files
            File   indexDir = new File("C:\\luceneIndex");
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
            File[] textFiles  = fileDir.listFiles();
            long startTime = new Date().getTime();
            //Add documents to the index
            for(int i = 0; i < textFiles.length; i++){
            if(textFiles[i].isFile() >> textFiles[i].getName().endsWith(".txt")){
            System.out.println("File " + textFiles[i].getCanonicalPath()
            + " is being indexed");
            Reader textReader = new FileReader(textFiles[i]);
            Document document = new Document();
            document.add(Field.Text("content",textReader));
            document.add(Field.Text("path",textFiles[i].getPath()));
            indexWriter.addDocument(document);
            }
            }
            indexWriter.optimize();
            indexWriter.close();
            long endTime = new Date().getTime();
            System.out.println("It took " + (endTime - startTime)
            + " milliseconds to create an index for the files in the directory "
            + fileDir.getPath());
            }
            }

正如清单1所�C�，你可以利�?Lucene 非常方便的�ؓ文��创徏索引。接下来我们分析一下清�?中的比较关键的代码，我们先从下面的一条语句开始看赗��?/p>


            Analyzer luceneAnalyzer = new StandardAnalyzer();

�q�条语句创徏了类 StandardAnalyzer 的一个实例，�q�个�c�L��用来从文本中提取出烦引项的。它只是抽象�c?Analyzer 的其中一个实现。Analyzer 也有一些其它的子类�Q�比�?SimpleAnalyzer �{��?/p>

我们接着看另外一条语句：


            IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);

�q�条语句创徏了类 IndexWriter 的一个实例，该类也是 Lucene 索引机制里面的一个关键类。这个类能创��Z��个新的烦引或者打开一个已存在的烦引�ƈ��所引添加文��。我们注意到该类的构造函数接受三个参敎ͼ��W�一个参数指定了存储索引文�g的�\径。第二个参数指定了在索引�q�程中��用什么样的分词器。最后一个参数是个布��变量，如果��gؓ真，那么��p��C��创徏一个新的烦引，如果��gؓ假，��p��C�打开一个已�l�存在的索引�?/p>

接下来的代码演示了如何添加一个文档到索引文�g中�?/p>


            Document document = new Document();
            document.add(Field.Text("content",textReader));
            document.add(Field.Text("path",textFiles[i].getPath()));
            indexWriter.addDocument(document);

首先�W�一行创��Z��c?Document 的一个实例，它由一个或者多个的�?Field)�l�成。你可以把这个类惌��成代表了一个实际的文��Q�比如一�?HTML ��面�Q�一�?PDF 文��Q�或者一个文本文件。而类 Document 中的域一般就是实际文��的一些属性。比如对于一�?HTML ��面�Q�它的域可能包括标题�Q�内容，URL �{�。我们可以用不同�c�d��?Field 来控制文档的哪些内容应该索引�Q�哪些内容应该存储。如果想获取更多的关�?Lucene 的域的信息，可以参�?Lucene 的帮助文档。代码的�W�二行和�W�三行�ؓ文档��d��了两个域�Q�每个域包含两个属性，分别是域的名字和域的内容。在我们的例子中两个域的名字分别�?content"�?path"。分别存储了我们需要烦引的文本文�g的内容和路径。最后一行把准备好的文档��d��C��索引当中�?/p>

当我们把文��d��到烦引中后，不要忘记关闭索引�Q�这��h��保证 Lucene 把添加的文��写回到硬盘上。下面的一句代码演�C�Z��如何关闭索引�?/p>


            indexWriter.close();

利用清单1中的代码�Q�你��可以成功的��文本文��添加到索引中去。接下来我们看看对烦引进行的另外一�U�重要的操作�Q�从索引中删除文档�?/p>

回页�?/font>

从烦引中删除文档

�c�IndexReader负责从一个已�l�存在的索引中删除文档，如清�?所�C��?/p>
清单2�Q�从索引中删除文�?/strong>


            File   indexDir = new File("C:\\luceneIndex");
            IndexReader ir = IndexReader.open(indexDir);
            ir.delete(1);
            ir.delete(new Term("path","C:\\file_to_index\lucene.txt"));
            ir.close();

在清�?中，�W�二行用静态方�?IndexReader.open(indexDir) 初始化了�c?IndexReader 的一个实例，�q�个�Ҏ��的参数指定了索引的存储�\径。类 IndexReader 提供了两�U�方法去删除一个文档，如程序中的第三行和第四行所�C�。第三行利用文��的编��h��删除文��。每个文��都有一个系�l�自动生成的�~�号。第四行删除了�\径�ؓ"C:\\file_to_index\lucene.txt"的文档。你可以通过指定文�g路径来方便的删除一个文档。值得注意的是虽然利用上述代码删除文��使得该文档不能被��索到�Q�但是�ƈ没有物理上删除该文��。Lucene 只是通过一个后�~�名�ؓ .delete 的文件来标记哪些文��已经被删除。既然没有物理上删除�Q�我们可以方便的把这些标��Cؓ删除的文档恢复过来，如清�?3 所�C�，首先打开一个烦引，然后调用�Ҏ�� ir.undeleteAll() 来完成恢复工作�?/p>
清单3�Q�恢复已删除文��

File indexDir = new File("C:\\luceneIndex"); IndexReader ir = IndexReader.open(indexDir); ir.undeleteAll(); ir.close();

你现在也许想知道如何物理上删除烦引中的文��，�Ҏ��也非常简单。清�?4 演示了这个过�E��?/p>
清单4�Q�如何物理上删除文档

File indexDir = new File("C:\\luceneIndex"); Analyzer luceneAnalyzer = new StandardAnalyzer(); IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,false); indexWriter.optimize(); indexWriter.close();

在清�?4 中，�W�三行创��Z��c?IndexWriter 的一个实例，�q�且打开了一个已�l�存在的索引。第 4 行对索引�q�行清理�Q�清理过�E�中��把所有标��Cؓ删除的文��物理删除�?/p>
Lucene 没有直接提供�Ҏ��Ҏ��档进行更斎ͼ�如果你需要更��C��个文��，那么你首先需要把�q�个文��从烦引中删除�Q�然后把新版本的文��加入到烦引中厅R�?/p>

回页�?/font>

提高索引性能

利用 Lucene�Q�在创徏索引的工�E�中你可以充分利用机器的��g资源来提高烦引的效率。当你需要烦引大量的文�g�Ӟ��你会注意到烦引过�E�的瓉��是在往��盘上写索引文�g的过�E�中。�ؓ了解册��个问�? Lucene 在内存中持有一块缓冲区。但我们如何控制 Lucene 的缓冲区呢？�q�运的是�Q�Lucene 的类 IndexWriter 提供了三个参数用来调整缓冲区的大��以及往��盘上写索引文�g的频率�?/p>
1�Q�合�q�因子（mergeFactor�Q?/p>
�q�个参数军_��了在 Lucene 的一个烦引块中可以存攑֤��文��以及把��盘上的索引块合�q�成一个大的烦引块的频率。比如，如果合�ƈ因子的值是 10�Q�那么当内存中的文��数达�?10 的时候所有的文档都必��d��到磁盘上的一个新的烦引块中。�ƈ且，如果��盘上的索引块的隔数辑ֈ� 10 的话�Q�这 10 个烦引块会被合�ƈ成一个新的烦引块。这个参数的默认值是 10�Q�如果需要烦引的文��数非常多的话�q�个值将是非�怸�合适的。对批处理的索引来讲�Q��ؓ�q�个参数赋一个比较大的��g��得到比较好的索引效果�?/p>
2�Q�最��合�q�文��数

�q�个参数也会影响索引的性能。它军_��了内存中的文档数臛_��辑ֈ�多少才能��它们写回磁盘。这个参数的默认值是10�Q�如果你有��够的内存�Q�那么将�q�个值尽量设的比较大一些将会显著的提高索引性能�?/p>
3�Q�最大合�q�文��数

�q�个参数军_��了一个烦引块中的最大的文��数。它的默认值是 Integer.MAX_VALUE�Q�将�q�个参数讄��为比较大的值可以提高烦引效率和��索速度�Q�由于该参数的默认值是整型的最大��|��所以我们一般不需要改动这个参数�?/p>
清单 5 列出了这个三个参数用法，清单 5 和清�?1 非常�怼��Q�除了清�?5 中会讄��刚才提到的三个参数�?/p>
清单5�Q�提高烦引性能

/** * This class demonstrates how to improve the indexing performance * by adjusting the parameters provided by IndexWriter. */ public class AdvancedTextFileIndexer { public static void main(String[] args) throws Exception{ //fileDir is the directory that contains the text files to be indexed File fileDir = new File("C:\\files_to_index"); //indexDir is the directory that hosts Lucene's index files File indexDir = new File("C:\\luceneIndex"); Analyzer luceneAnalyzer = new StandardAnalyzer(); File[] textFiles = fileDir.listFiles(); long startTime = new Date().getTime(); int mergeFactor = 10; int minMergeDocs = 10; int maxMergeDocs = Integer.MAX_VALUE; IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true); indexWriter.mergeFactor = mergeFactor; indexWriter.minMergeDocs = minMergeDocs; indexWriter.maxMergeDocs = maxMergeDocs; //Add documents to the index for(int i = 0; i < textFiles.length; i++){ if(textFiles[i].isFile() >> textFiles[i].getName().endsWith(".txt")){ Reader textReader = new FileReader(textFiles[i]); Document document = new Document(); document.add(Field.Text("content",textReader)); document.add(Field.Keyword("path",textFiles[i].getPath())); indexWriter.addDocument(document); } } indexWriter.optimize(); indexWriter.close(); long endTime = new Date().getTime(); System.out.println("MergeFactor: " + indexWriter.mergeFactor); System.out.println("MinMergeDocs: " + indexWriter.minMergeDocs); System.out.println("MaxMergeDocs: " + indexWriter.maxMergeDocs); System.out.println("Document number: " + textFiles.length); System.out.println("Time consumed: " + (endTime - startTime) + " milliseconds"); } }

通过�q�个例子�Q�我们注意到在调整缓冲区的大��以及写��盘的频率上�?Lucene �l�我们提供了非常大的灉|��性。现在我们来看一下代码中的关键语句。如下的代码首先创徏了类 IndexWriter 的一个实例，然后对它的三个参数进行赋倹{�?/p>

int mergeFactor = 10; int minMergeDocs = 10; int maxMergeDocs = Integer.MAX_VALUE; IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true); indexWriter.mergeFactor = mergeFactor; indexWriter.minMergeDocs = minMergeDocs; indexWriter.maxMergeDocs = maxMergeDocs;

下面我们来看一下这三个参数取不同的值对索引旉��的媄响，注意参数值的不同和烦引之间的关系。我们�ؓ�q�个实验准备�?10000 个测试文档。表 1 昄��了测试结果�?/p>
�?�Q�测试结�?/strong>

通过�?1�Q�你可以清楚地看��C��个参数对索引旉��的媄响。在实践中，你会�l�常的改变合�q�因子和最��合�q�文��数的值来提高索引性能。只要你有��够大的内存，你可以�ؓ合�ƈ因子和最��合�q�文��数�q�两个参数赋��量大的��g��提高索引效率�Q�另外我们一般无需更改最大合�q�文��数�q�个参数的��|��因�ؓ�pȝ��已经默认��它讄��成了最大�?/p>

回页�?/font>

Lucene 索引文�g�l�构分析

在分�?Lucene 的烦引文件结构之前，我们先要理解反向索引�Q�Inverted index�Q�这个概念，反向索引是一�U�以索引��ؓ中心来组�l�文档的方式�Q�每个烦引项指向一个文��序列，�q�个序列中的文��都包含该索引��V��相反，在正向烦引中�Q�文档占据了中心的位�|�，每个文��指向了一个它所包含的烦引项的序列。你可以利用反向索引��L��的找到那些文��包含了特定的烦引项。Lucene正是使用了反向烦引作为其基本的烦引结构�?/p>

回页�?/font>

索引文�g的逻辑视图

在Lucene 中有索引块的概念�Q�每个烦引块包含了一定数目的文��。我们能够对单独的烦引块�q�行��索。图 2 昄��?Lucene 索引�l�构的逻辑视图。烦引块的个数由索引的文档的��L��以及每个索引块所能包含的最大文��数来决定�?/p>
�?�Q�烦引文件的逻辑视图

回页�?/font>

Lucene 中的关键索引文�g

下面的部分将会分析Lucene中的主要的烦引文�Ӟ��可能分析有些索引文�g的时候没有包含文件的所有的字段�Q�但不会影响到对索引文�g的理解�?/p>
1�Q�烦引块文�g

�q�个文�g包含了烦引中的烦引块信息�Q�这个文件包含了每个索引块的名字以及大小�{�信息。表 2 昄��了这个文件的�l�构信息�?/p>
�?�Q�烦引块文�g�l�构

2�Q�域信息文�g

我们知道�Q�烦引中的文��由一个或者多个域�l�成�Q�这个文件包含了每个索引块中的域的信息。表 3 昄��了这个文件的�l�构�?/p>
�?�Q�域信息文�g�l�构

3�Q�烦引项信息文�g

�q�是索引文�g里面最核心的一个文�Ӟ��它存储了所有的索引��的��g��及相关信息，�q�且以烦引项来排序。表 4 昄��了这个文件的�l�构�?/p>
�?�Q�烦引项信息文�g�l�构

4�Q�频率文�?/p>
�q�个文�g包含了包含烦引项的文��的列表�Q�以及烦引项在每个文档中出现的频率信息。如果Lucene在烦引项信息文�g中发现有索引��和搜烦词相匚w��。那�?Lucene ��׃��在频率文件中找有哪些文�g包含了该索引��V��表5昄��了这个文件的一个大致的�l�构�Q��ƈ没有包含�q�个文�g的所有字�D�c�?/p>
�?�Q�频率文件的�l�构

5�Q�位�|�文�?/p>
�q�个文�g包含了烦引项在每个文��中出现的位�|�信息，你可以利用这些信息来参与对烦引结果的排序。表 6 昄��了这个文件的�l�构

�?�Q�位�|�文件的�l�构

到目前�ؓ止我们介�l�了 Lucene 中的主要的烦引文件结构，希望能对你理�?Lucene 的物理的存储�l�构有所帮助�?/p>

回页�?/font>

�ȝ��

目前已经有非常多的知名的�l�织正在使用 Lucene�Q�比如，Lucene �?Eclipse 的帮助系�l�，�ȝ��理工学院�?OpenCourseWare 提供了搜索功能。通过阅读�q�篇文章�Q�希望你能对 Lucene 的烦引机制有所了解�Q��ƈ且你会发现利�?Lucene 创徏索引是非常简单的事情�?/p>

Masen 2007-05-31 11:52 发表评论

Masen — Tue, 29 May 2007 16:43:00 GMT

在应用中加入全文��索功能——基于Java的全文烦引引擎Lucene��?/h3>

关键词：Lucene java full-text search engine Chinese word segment

Lucene不是一个完整的全文索引应用�Q�而是是一个用Java写的全文索引引擎工具包，它可以方便的嵌入到各�U�应用中实现针对应用的全文烦�?��索功能�?
Lucene的作者：Lucene的�A献�?a >Doug Cutting�?一位资深全文烦�?��索专�Ӟ��曄��是V-Twin搜烦引擎(Apple的Copland操作�pȝ��的成��׃��一)的主要开发者，后在Excite担�Q高��pȝ�� 架构设计师，目前从事于一些INTERNET底层架构的研�I�。他贡献出的Lucene的目标是为各�U�中��型应用�E�序加入全文��索功能�?/p>

Lucene的发展历�E�：早先发布在作者自��q��www.lucene.com�Q�后来发布在SourceForge�Q?001�q�年底成为APACHE基金会jakarta的一个子��目�Q?a >http://jakarta.apache.org/lucene/
已经有很多Java��目都��用了Lucene作�ؓ其后台的全文索引引擎�Q�比较著名的有：

J ive�Q�WEB论坛�pȝ��Q?
Eyebrows�Q�邮件列表HTML归档/��览/查询�pȝ��Q�本文的主要参考文�?#8220;TheLucene search engine: Powerful, flexible, and free”作者就是EyeBrows�pȝ��的主要开发者之一�Q�而EyeBrows已经成�ؓ目前APACHE��目的主要邮件列表归��系�l��?
Cocoon:��Z��XML的web发布框架�Q�全文检索部分��用了Lucene

Eclipse:��Z��Java的开攑ּ�发��^収ͼ�帮助部分的全文烦引��用了Lucene

对于中文用户来说�Q�最兛_��的问题是其是否支持中文的全文��索。但通过后面对于Lucene的结构的介绍�Q�你会了解到�׃��Lucene良好架构设计�Q�对中文的支持只需对其语言词法分析接口�q�行扩展��p��实现对中文检索的支持�?/p>
全文��索的实现机制

Lucene的API接口设计的比较通用�Q�输入输出结构都很像数据库的�?=>记录==>字段�Q�所以很多传�l�的应用的文件、数据库�{�都可以比较方便的映��到Lucene的存储结�?接口中。��M��上看�Q�可以先�?strong>Lucene当成一个支持全文烦引的数据库系�l?/strong>�?/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늻��?/td> Record�Q�记录，包含多个字段

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

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

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

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

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

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

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

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

大部分的搜烦�Q�数据库�Q�引擎都是用B树结构来�l�护索引�Q�烦引的更新会导致大量的IO操作�Q�Lucene在实��C��Q�对此稍微有所改进�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�，很多�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> 　

�q�发讉K�� 能够支持多用��L��使用　

　

关于亚洲语言的的切分词问�?Word Segment)

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

自动切分词表切分

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

查询增加了查询分析的复杂�E�度�Q?/td> 适于实现比较复杂的查询语法规�?/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>
安装和��?/strong>

下蝲�Q?a >http://jakarta.apache.org/lucene/

注意�Q�Lucene中的一些比较复杂的词法分析是用JavaCC生成的（JavaCC�Q�JavaCompilerCompiler�Q�纯Java的词法分析生成器�Q�，所以如果从源代码编译或需要修改其中的QueryParser、定制自��q��词法分析器，�q�需要从https://javacc.dev.java.net/下蝲javacc�?/p>
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�程�Q�从命��o行读取文件名�Q�多个）�Q�将文�g分�\�?path字段)和内�?body字段)2个字�D�进行存储，�q�对内容�q�行全文索引�Q�烦引的单位�?Document对象�Q�每个Document对象包含多个字段Field对象�Q�针对不同的字段属性和数据输出的需求，对字�D�还可以选择不同的烦�?存储�?�D�规则，列表如下�Q?

�Ҏ�� 切词索引存储用�?/th>

Field.Text(String name, String value) Yes Yes Yes 切分词烦引�ƈ存储�Q�比如：标题�Q�内容字�D?/td>

Field.Text(String name, Reader value) Yes Yes No 切分词烦引不存储�Q�比如：META信息�Q?br>不用于返回显�C�，但需要进行检索内�?/td>

Field.Keyword(String name, String value) No Yes Yes 不切分烦引�ƈ存储�Q�比如：日期字段

Field.UnIndexed(String name, String value) No No Yes 不烦引，只存储，比如�Q�文件�\�?/td>

Field.UnStored(String name, String value) Yes Yes No 只全文烦引，不存�?/td>

public class IndexFiles {
//使用�Ҏ��Q? IndexFiles [索引输出目录] [索引的文件列表] ...
public static void main(String[] args) throws Exception {
String indexPath = args[0];
IndexWriter writer;
//用指定的语言分析器构造一个新的写索引器（�W?个参数表�C�是否�ؓ�q�加索引�Q?br> writer = new IndexWriter(indexPath, new SimpleAnalyzer(), false);

for (int i=1; i System.out.println("Indexing file " + args[i]);
InputStream is = new FileInputStream(args[i]);

//构造包�?个字�D�Field的Document对象
//一个是路径path字段�Q�不索引�Q�只存储
//一个是内容body字段�Q�进行全文烦引，�q�存�?br> Document doc = new Document();
doc.add(Field.UnIndexed("path", args[i]));
doc.add(Field.Text("body", (Reader) new InputStreamReader(is)));
//��文档写入烦�?br> writer.addDocument(doc);
is.close();
};
//关闭写烦引器
writer.close();
}
}
　

索引�q�程中可以看刎ͼ�

语言分析器提供了抽象的接口，因此语言分析(Analyser)是可以定制的�Q�虽然lucene�~�省提供�?个比较通用的分析器 SimpleAnalyser和StandardAnalyser�Q�这2个分析器�~�省都不支持中文�Q�所以要加入对中文语�a�的切分规则，需要修改这2个分�?器�?
Lucene�q�没有规定数据源的格式，而只提供了一个通用的结构（Document对象�Q�来接受索引的输入，因此输入的数据源可以是：数据库，WORD文��Q�PDF文��Q�HTML文��……只要能够设计相应的解析�{换器��数据源构造成成Docuement对象卛_��q�行索引�?
对于大批量的数据索引�Q�还可以通过调整IndexerWrite的文件合�q��率属性（mergeFactor�Q�来提高扚w��索引的效率�?

��索过�E�和�l�果昄��Q?/p>
搜烦�l�果�q�回的是Hits对象�Q�可以通过它再讉K��Document==>Field中的内容�?/p>
假设�Ҏ��body字段�q�行全文��索，可以��查询结果的path字段和相应查询的匚w��?score)打印出来�Q?/p>
public class Search {
public static void main(String[] args) throws Exception {
String indexPath = args[0], queryString = args[1];
//指向索引目录的搜索器
Searcher searcher = new IndexSearcher(indexPath);
//查询解析器：使用和烦引同��L��语言分析�?br> Query query = QueryParser.parse(queryString, "body",
new SimpleAnalyzer());
//搜烦�l�果使用Hits存储
Hits hits = searcher.search(query);
//通过hits可以讉K��到相应字�D늚�数据和查询的匚w��?br> for (int i=0; i System.out.println(hits.doc(i).get("path") + "; Score: " +
hits.score(i));
};
}
}
在整个检索过�E�中�Q�语�a�分析器，查询分析器，甚至搜烦器（Searcher�Q�都是提供了抽象的接口，可以�Ҏ��需要进行定制�?
Hacking Lucene

��化的查询分析�?/strong>

个�h感觉lucene成�ؓJAKARTA��目后，��d��了太多的旉��用于调试日趋复杂QueryParser�Q�而其中大部分是大多数用户�q�不很熟悉的�Q�目前LUCENE支持的语法：

Query ::= ( Clause )*
Clause ::= ["+", "-"] [ ":"] ( | "(" Query ")")

中间的逻辑包括�Q�and or + - &&||�{�符��P��而且�q�有"短语查询"和针对西文的前缀/模糊查询�{�，个�h感觉对于一般应用来��_��q�些功能有一些华而不实，其实能够实现目前�c�M��于Google的查询语句分析功能其实对于大多数用户来说已经够了。所以，Lucene早期版本的QueryParser仍是比较好的选择�?/p>
��d��修改删除指定记录�Q�Document�Q?/strong>

Lucene提供了烦引的扩展机制�Q�因此烦引的动态扩展应该是没有问题的，而指定记录的修改也似乎只能通过记录的删除，然后重新加入实现。如何删�?指定的记录呢�Q�删除的�Ҏ��也很��单，只是需要在索引时根据数据源中的记录ID专门另徏索引�Q�然后利用IndexReader.delete (Termterm)�Ҏ��通过�q�个记录ID删除相应的Document�?/p>
�Ҏ��某个字段值的排序功能

lucene�~�省是按照自��q��相关度算法（score�Q�进行结果排序的�Q�但能够�Ҏ��其他字段�q�行�l�果排序是一个在LUCENE的开发邮件列表中�l�常提到的问题，很多原先��Z��数据库应用都需要除了基于匹配度�Q�score�Q�以外的排序功能。而从全文��索的原理我们可以了解刎ͼ��M��不基于烦引的搜烦�q�程�?率都会导致效率非常的低，如果��Z��其他字段的排序需要在搜烦�q�程中访问存储字�D�，速度回大大降低，因此非常是不可取的�?/p>
但这里也有一个折中的解决�Ҏ��Q�在搜烦�q�程中能够媄响排序结果的只有索引中已�l�存储的docID和score�q?个参敎ͼ�所以，��Z��score以外的排序，其实可以通过��数据源预先排好序，然后�Ҏ��docID�q�行排序来实现。这样就避免了在LUCENE搜烦�l�果外对�l�果再次�q�行排序和在搜烦�q�程中访问不在烦引中的某个字�D�倹{�?/p>
�q�里需要修改的是IndexSearcher中的HitCollector�q�程�Q?/p>
...
　scorer.score(new HitCollector() {
private float minScore = 0.0f;
public final void collect(int doc, float score) {
if (score > 0.0f && // ignore zeroed buckets
(bits==null || bits.get(doc))) { // skip docs not in bits
totalHits[0]++;
if (score >= minScore) {
/* 原先�Q�Lucene��docID和相应的匚w��度score例入�l�果命中列表中：
* hq.put(new ScoreDoc(doc, score)); // update hit queue
* 如果用doc �?1/doc 代替 score�Q�就实现了根据docID��排或逆排
* 假设数据源烦引时已经按照某个字段排好了序�Q�而结果根据docID排序也就实现�?br> * 针对某个字段的排序，甚至可以实现更复杂的score和docID的拟合�?br> */
hq.put(new ScoreDoc(doc, (float) 1/doc ));
if (hq.size() > nDocs) { // if hit queue overfull
hq.pop(); // remove lowest in hit queue
minScore = ((ScoreDoc)hq.top()).score; // reset minScore
}
}
}
}
}, reader.maxDoc());

更通用的输入输出接�?/strong>

虽然lucene没有定义一个确定的输入文档格式�Q�但��来��多的�h惛_��使用一个标准的中间格式作�ؓLucene的数据导入接口，然后其他数据�Q�比�?PDF只需要通过解析器�{换成标准的中间格式就可以�q�行数据索引了。这个中间格式主要以XML��Z��Q�类似实现已�l�不�?�Q?个：

数据�? WORD PDF HTML DB other
\ | | | /
XML中间格式
|
Lucene INDEX

目前�q�没有针对MSWord文档的解析器�Q�因为Word文档和基于ASCII的RTF文档不同�Q�需要��用COM对象机制解析。这个是我在Google上查的相兌��料：http://www.intrinsyc.com/products/enterprise_applications.asp
另外一个办法就是把Word文档转换成text�Q?a >http://www.winfield.demon.nl/index.html

索引�q�程优化

索引一般分2�U�情况，一�U�是��批量的索引扩展�Q�一�U�是大批量的索引重徏。在索引�q�程中，�q�不是每�ơ新的DOC加入�q�去索引都重新进行一�ơ烦引文件的写入操作�Q�文件I/O是一仉��常消耗资源的事情�Q��?/p>
Lucene先在内存中进行烦引操作，�q�根据一定的扚w��q�行文�g的写入。这个批�ơ的间隔��大�Q�文件的写入�ơ数��少�Q�但占用内存会很多。反之占用内�?��，但文件IO操作频繁�Q�烦引速度会很慢。在IndexWriter中有一个MERGE_FACTOR参数可以帮助你在构造烦引器后根据应用环境的情况�?分利用内存减��文件的操作。根据我的��用经验：�~�省Indexer是每20条记录烦引后写入一�ơ，每将MERGE_FACTOR增加50倍，索引速度可以提高1倍左叟�?br>

搜烦�q�程优化

lucene支持内存索引�Q�这��L��搜烦比基于文件的I/O有数量��的速度提升�?br>http://www.onjava.com/lpt/a/3273
而尽可能减少IndexSearcher的创建和�Ҏ��索结果的前台的缓存也是必要的�?br>

Lucene面向全文��索的优化在于首次索引��索后�Q��ƈ不把所有的记录�Q�Document�Q�具体内容读取出来，而�v只将所有结果中匚w��度最高的�?100条结果（TopDocs�Q�的ID攑ֈ��l�果集缓存中�q�返回，�q�里可以比较一下数据库��索：如果是一�?0,000条的数据库检索结果集�Q�数据库是一�?要把所有记录内定w��取得以后再开始返回给应用�l�果集的。所以即使检索匹配��L��很多�Q�Lucene的结果集占用的内存空间也不会很多。对于一般的模糊��索应用是用不到这么多的结果的�Q�头100条已�l�可以满��?0%以上的检索需求�?br>

如果首批�~�存�l�果数用完后�q�要��d��更后面的�l�果时Searcher会再�ơ检索�ƈ生成一个上�ơ的搜烦�~�存数大1倍的�~�存�Q��ƈ再重新向后抓取。所以如�?构造一个Searcher��L��1�Q?20条结果，Searcher其实是进行了2�ơ搜索过�E�：�?00条取完后�Q�缓存结果用完，Searcher重新��?再构造一�?00条的�l�果�~�存�Q�依此类推，400条缓存，800条缓存。由于每�ơSearcher对象消失后，�q�些�~�存也访问那不到了，你有可能惛_��l�果记录�~�存下来�Q�缓存数��量保证�?00以下以充分利用首�ơ的�l�果�~�存�Q�不让Lucene��费多次��索，而且可以分��q�行�l�果�~�存�?br>

Lucene的另外一个特�Ҏ��在收集结果的�q�程中将匚w��度低的结果自动过滤掉了。这也是和数据库应用需要将搜烦的结果全部返回不同之处�?/p>
我的一些尝�?/font>�Q?/p>

支持中文的Tokenizer�Q�这里有2个版本，一个是通过JavaCC生成的，对CJK部分按一个字�W�一个TOKEN索引�Q�另外一个是从SimpleTokenizer改写的，对英文支持数字和字母TOKEN�Q�对中文按�P代烦引�?
��Z��XML数据源的索引器：XMLIndexer�Q�因此所有数据源只要能够按照DTD转换成指定的XML�Q�就可以用XMLIndxer�q�行索引了�?
�?据某个字�D�|��序：按记录烦引顺序排序结果的搜烦器：IndexOrderSearcher�Q�因此如果需要让搜烦�l�果�Ҏ��某个字段排序�Q�可以让数据源先按某个字�D�|��好序�Q�比如：PriceField�Q�，�q�样索引后，然后在利用这个按记录的ID��序��索的搜烦器，�l�果��是相当于是那个字段排序的结果了�?

从Lucene学到更多

Luene的确是一个面对对象设计的典范

所有的问题都通过一个额外抽象层来方便以后的扩展和重用：你可以通过重新实现来达到自��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�予了需要将全文��索功能嵌入到应用中的开发者很多的便利�?/p>
此外�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��也是一个非常消耗资源的操作�?br>

参考资料：

Apache: Lucene Project
http://jakarta.apache.org/lucene/
Lucene开�?用户邮�g列表归��
Lucene-dev@jakarta.apache.org
Lucene-user@jakarta.apache.org

The Lucene search engine: Powerful, flexible, and free
http://www.javaworld.com/javaworld/jw-09-2000/jw-0915-Lucene_p.html

Lucene Tutorial
http://www.darksleep.com/puff/lucene/lucene.html

Notes on distributed searching with Lucene
http://home.clara.net/markharwood/lucene/

中文语言的切分词
http://www.google.com/search?sourceid=navclient&hl=zh-CN&q=chinese+word+segment

搜烦引擎工具介绍
http://searchtools.com/

Lucene作者Cutting的几��论文和专利
http://lucene.sourceforge.net/publications.html

Lucene�?NET实现�Q�dotLucene
http://sourceforge.net/projects/dotlucene/

Lucene作者Cutting的另外一个项目：��Z��Java的搜索引擎Nutch
http://www.nutch.org/ http://sourceforge.net/projects/nutch/

关于��Z��词表和N-Gram的切分词比较
http://china.nikkeibp.co.jp/cgi-bin/china/news/int/int200302100112.html

2005-01-08 Cutting在Pisa大学做的关于Lucene的讲座：非常详细的Lucene架构解说

特别感谢�Q?br>前网易CTO许良�?Jack Xu)�l�我的指��|��是您��我带入了搜索引擎这个行业�?/p> 原文出处�Q�http://www.chedong.com/tech/lucene.html

Masen 2007-05-30 00:43 发表评论

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