Javen-Studio咖啡小屋软件工作室

Hawk搜索引擎平台0.6.22测试版(免费下载)

2009-03-21T17:57:00.000-07:00

Hawk搜索引擎平台0.6.22测试版(免费下载)
Hawk 搜索引擎平台是面向中小型网站，可以定制的垂直搜索引擎平台。本搜索引擎平台目标是方便用户搭建站内搜索、某个领域的垂直搜索、以及检索个人文档以及自己关注的网站信息的桌面搜索等应用领域。它改造自Lucene，Hadoop和Nutch系统，是纯Java的搜索平台软件，可以运行于Windows及Linux等平台，具备基本的抓取、索引和检索功能，本搜索引擎免费下载，欢迎大家测试和使用！
Hawk 搜索引擎平台特点简介
对网页进行深度抓取和分析，自定义抓取规则，实现站内搜索。
可以索引各种常用类型文档，实现桌面文档检索。
单台PC服务器能索引上千万文档，可以用于中小型检索服务。
可以自定义网页展示模板，或XML接口，轻松与各种系统整合。
自动分析网页文本，提取新词，如人名，地名等。
支持检索词自动推荐以及繁简转换功能。
可以定制主页的各项文字，包括包含自己的欢迎网页。

拥有百万文档的开发文档库搜索
本开发文档库索引了大量常用软件的开发文档和API参考手册，包括主要的Java文档、RFC文档和Linux系统下的文档如man手册等，完整的最新版MSDN联机丛书，Android/Symbian参考手册，Eclipse/Oracle帮助文档，Apple和iPhone系统开发文档，Solaris、OpenOffice和mysql手册等等，超过百万篇网页及PDF等格式文档，欢迎使用！

© 2008 Javen-Studio http://javenstudio.org/ 咖啡小屋

Annotated Lucene （源码剖析）

2008-10-24T10:46:00.001-07:00

Hawk搜索引擎平台应用：词典搜索和文档搜索

2008-10-24T10:45:00.001-07:00

Hawk搜索引擎平台应用：词典搜索和文档搜索

Hawk 搜索引擎平台可用来定制自己的搜索应用服务，如站内网页搜索和桌面搜索。下面介绍两个很有用的桌面搜索应用。辞典搜索收录有四十部超过800万词汇的常用英语和汉语词典，如朗文，牛津，汉语大词典等。文档搜索服务索引了主要的Java文档和Linux系统下的文档如man手册等，欢迎使用！

© 2008 Javen-Studio http://javenstudio.org 咖啡小屋

Hawk搜索引擎平台0.6.9测试版(提供下载)

2008-07-20T00:10:00.000-07:00

Hawk搜索引擎平台0.6.9测试版(提供下载)

Hawk 搜索引擎平台是面向中小型网站，可以定制的垂直搜索引擎平台。本搜索引擎平台目标是方便用户搭建站内搜索、某个领域的垂直搜索、以及检索个人文档以及自己关注的网站信息的桌面搜索等应用领域。它改造自Lucene，Hadoop和Nutch系统，是纯Java的搜索平台软件，可以运行于Windows及Linux等平台，具备基本的抓取、索引和检索功能，本搜索引擎将免费提供，欢迎大家测试和使用，谢谢！

Hawk 搜索引擎平台特点简介

对网页进行深度抓取和分析，自定义抓取规则，实现站内搜索。
可以索引各种常用类型文档，实现桌面文档检索。
单台PC服务器能索引上千万文档，可以用于中小型检索服务。
可以自定义网页展示模板，或XML接口，轻松与各种系统整合。
自动分析网页文本，提取新词，如人名，地名等。
支持检索词自动推荐以及繁简转换功能。

欢迎光临 Javen-Studio 新网址：http://javenstudio.org

2008-03-20T19:39:00.000-07:00

欢迎光临 Javen-Studio 新网址：http://javenstudio.org

Hawk 搜索引擎平台 0.4.50 开发版

2008-03-20T19:34:00.001-07:00

Hawk 搜索引擎平台 0.4.50 开发版
Hawk 搜索引擎平台是面向中小型网站，可以定制的垂直搜索引擎平台。本搜索引擎平台目标是方便用户搭建站内搜索、某个领域的垂直搜索、以及检索个人文档以及自己关注的网站信息的桌面搜索等应用领域。它改造自Lucene，Hadoop和Nutch系统，是纯Java的搜索平台软件，可以运行于Windows及Linux等平台，具备基本的抓取、索引和检索功能，本搜索引擎将免费提供，欢迎大家测试和使用，谢谢！ Hawk 搜索引擎平台技术特点简介
改造Hadoop中MapReduce和JobTracker，TaskTracker的结构，以实现可以在Windows/Linux跨平台执行job，并将Map和Reduce分离以实现可以独立执行Map或者Reduce的任务，减少重复的数据处理。Map和Reduce分别代之Processor和Combiner两个独立的Task。以上改造为实现将来更轻量级的分布式计算做准备，而无需像Hadoop一样需建立庞大的cluster集群来进行分布式存储和计算。
改造Nutch结构，改造索引和segment存储格式及内容，简化部分处理流程，并把改造后的Hadoop系统与之整合。为支持单机千万级的索引量重新设计，同时为实现将来软件模块化做准备，如OSGI或更轻量级架构。
全新的管理界面的设计，以与Windows相似的操作界面呈现，并支持国际化语言，目前支持英文和中文界面。
支持自然语言语法分析及语义识别。网页正文智能识别和提取，及新词自动分析和提取功能，持续改进中。
© 2008 Javen-Studio http://javenstudio.org 咖啡小屋

Annotated Hadoop （源码剖析）

2008-02-21T10:36:00.000-08:00

Hadoop目前是Apache Lucene下的一个子项目，它最初是从Nutch项目中分离出来的专门负责分布式存储以及分布式运算的项目。简单地说来，Hadoop是一个可以更容易开发和运行处理大规模数据的软件平台。本文先从源码角度剖析MapReduce框架及运行原理。

Annotated Hadoop: 第一节 Hadoop是什么
http://www.cppblog.com/javenstudio/articles/43072.html

Annotated Hadoop: 第二节 MapReduce框架结构
http://www.cppblog.com/javenstudio/articles/43073.html

Annotated Hadoop: 第三节 MapReduce工作原理
http://www.cppblog.com/javenstudio/articles/43075.html

未完待续
Annotated Hadoop 作者：naven 日期：2007-12-29

Hawk-0.4.35搜索引擎平台开发版发布

2008-02-20T10:51:00.000-08:00

Hawk 搜索引擎平台是面向中小型网站，可以定制的垂直搜索引擎平台。本搜索引擎平台
目标是方便用户搭建站内搜索、某个领域的垂直搜索、以及检索个人文档以及自己关注的
网站信息的桌面搜索等应用领域。

http://www.cppblog.com/javenstudio/articles/43021.html

Annotated Lucene：第五节索引里有什么

2007-08-31T18:31:00.000-07:00

1 什么是索引

为了使用Lucene来索引数据，首先你得把它转换成一个纯文本（plain-text）tokens的数据流（stream），并通过它创建出Document对象，其包含的Fields成员容纳这些文本数据。一旦你准备好些Document对象，你就可以调用IndexWriter类的addDocument(Document)方法来传递这些对象到Lucene并写入索引中。当你做这些的时候，Lucene首先分析（analyzer）这些数据来使得它们更适合索引。详见《Lucene In Action》

下面先了解一下索引结构的一些术语。

1.1 索引数据结构介绍

1.1.1 术语定义

Lucene中基本的概念（fundamental concepts）是index、Document、Field和term。

1 一条索引（index）包含（contains）了一连串（a sequence of）文档（documents）。

2 一个文档（document）是由一连串fields组成。

3 一个field是由一连串命名了（a named sequence of）的terms组成。

4 一个term是一个string（字符串）。

相同的字符串（same string）但是在两个不同的fields中被认为（considered）是不同的term。因此（thus）term被描述为（represent as）一对字符串（a pair of strings），第一个string取名（naming）为该field的名字，第二个string取名为包含在该field中的文本（text within the field）。

1.1.2 倒排索引（inverted indexing）

索引（index）存储terms的统计数据（statistics about terms），为了使得基于term的检索（term-based search）效率更高（more efficient）。Lucene的索引分成（fall into）被广为熟悉的（known as）索引种类（family of indexex）叫做倒排索引（inverted index）。这是因为它可以列举（list），对一个term来说，所有包含它的文档（documents that contain it）。这与自然关联规则（natural relationship）是相反，即由documents列举它所包含的terms。

1.1.3 Fields的种类

在Lucene中，fields可以被存储（stored），在这种情况（in which case）下它们的文本被逐字地（literally）以一种非倒排的方式（in non-inverted manner）存储进index中。那些被倒排的fields（that are inverted）称为（called）被索引（indexed）。一个field可以都被存储（stored）并且被索引（indexed）。

一个field的文本可以被分解为（be tokenized into）terms以便被索引（indexed），或者field的文本可以被逐字地使用为（used literally as）一个term来被索引（be indexed）。大多数fields被分解（be tokenized），但是有时候对某种唯一性（certain identifier）的field来逐字地索引（be indexed literally）又是非常有用的，如url。

1.1.4 片断（segments）

Lucene的索引可以由多个复合的子索引（multiple sub-indexes）或者片断（segments）组成（be composed of）。每一个segment都是一个完全独立的索引（fully independent index），它能够被分离地进行检索（be searched seperately）。索引按如下方式进行演化（evolve）：

1. 为新添加的文档（newly added documents）创建新的片断（segments）。

2. 合并已存在的片断（merging existing segments）。

检索可以涉及（involve）多个复合（multiple）的segments，并且/或者多个复合（multiple）的indexes。每一个index潜在地（potentially）包含（composed of）一套（a set of）segments。

1.1.5 文档编号（document numbers）

在内部（internally），Lucene通过一个整数的（interger）文档编号（document number）来表示文档。第一篇被添加到索引中的文档编号为0（be numbered zero），每一篇随后（subsequent）被添加的document获得一个比前一篇更大的数字（a number one greater than the previous）。

需要注意的是一篇文档的编号（document’s number）可以更改，所以在Lucene之外（outside of）存储这些编号时需要特别小心（caution should be taken）。详细地说（in particular），编号在如下的情况（following situations）可以更改：

1 存储在每个segment中的编号仅仅是在所在的segment中是唯一的（unique），在它能够被使用在（be used in）一个更大的上下文（a larger context）中前必须被转变（converted）。标准的技术（standard technique）是给每一个segment分配（allocate）一个范围的值（a range of values），基于该segment所使用的编号的范围（the range of numbers）。为了将一篇文档的编号从一个segment转变为一个扩展的值（an external value），该片断的基础的文档编号（base document number）被添加（is added）。为了将一个扩展的值（external value）转变回一个segment的特定的值（specific value），该segment将该扩展的值所在的范围标识出来（be indentified），并且该segment的基础值（base value）将被减少（substracted）。例如，两个包含5篇文档的segments可能会被合并（combined），所以第一个segment有一个基础的值（base value）为0，第二个segment则为5。在第二个segment中的第3篇文档（document three from the second segment）将有一个扩展的值为8。

2 当文档被删除的时候，在编号序列中（in the numbering）将产生（created）间隔段（gaps）。这些最后（eventually）在索引通过合并演进时（index evolves through merging）将会被清除（removed）。当segments被合并后（merged），已删除的文档将会被丢弃（dropped），一个刚被合并的（freshly-merged）segment因此在它的编号序列中（in its numbering）不再有间隔段（gaps）。

1.1.6 索引结构概述

每一个片断的索引（segment index）管理（maintains）如下的数据：

1 Fields名称：这包含了（contains）在索引中使用的一系列fields的名称（the set of field names）。

2 已存储的field的值：它包含了，对每篇文档来说，一个属性-值数据对（attribute-value pairs）的清单（a list of），其中属性即为field的名字。这些被用来存储关于文档的备用信息（auxiliary information），比如它的标题（title）、url、或者一个访问一个数据库（database）的唯一标识（identifier）。这套存储的fields就是那些在检索时对每一个命中的（hits）文档所返回的（returned）信息。这些是通过文档编号（document number）来做为key得到的。

3 Term字典（dictionary）：一个包含（contains）所有terms的字典，被使用在所有文档中所有被索引的fields中。它还包含了该term所在的文档的数目（the number of documents which contains the term），并且指向了（pointer to）term的频率（frequency）和接近度（proximity）的数据（data）。

4 Term频率数据（frequency data）：对字典中的每一个term来说，所有包含该term（contains the term）的文档的编号（numbers of all documents），以及该term出现在该文档中的频率（frequency）。

5 Term接近度数据（proximity data）：对字典中的每一个term来说，该term出现在（occur）每一篇文档中的位置（positions）。

6 调整因子（normalization factors）：对每一篇文档的每一个field来说，为一个存储的值（a value is stored）用来加入到（multiply into）命中该field的分数（score for hits on that field）中。

7 Term向量（vectors）：对每一篇文档的每一个field来说，term向量（有时候被称做文档向量）可以被存储。一个term向量由term文本和term的频率（frequency）组成（consists of）。怎么添加term向量到你的索引中请参考Field类的构造方法（constructors）。

8 删除的文档（deleted documents）：一个可选的（optional）文件标示（indicating）哪一篇文档被删除。

关于这些项的详细信息在随后的章节（subsequent sections）中逐一介绍。

1.1.7 索引文件中定义的数据类型

数据类型

所占字节长度（字节）

说明

Byte

基本数据类型，其他数据类型以此为基础定义

UInt32

32位无符号整数，高位优先

UInt64

64位无符号整数，高位优先

VInt

不定，最少1字节

动态长度整数，每字节的最高位表明还剩多少字节，每字节的低七位表明整数的值，高位优先。可以认为值可以为无限大。其示例如下

值	字节1	字节2	字节3
0	00000000
1	00000001
2	00000010
127	01111111
128	10000000	00000001
129	10000001	00000001
130	10000010	00000001
16383	10000000	10000000	00000001
16384	10000001	10000000	00000001
16385	10000010	10000000	00000001

Chars

不定，最少1字节

采用UTF-8编码^[20]的Unicode字符序列

String

不定，最少2字节

由VInt和Chars组成的字符串类型，VInt表示Chars的长度，Chars则表示了String的值

1.1.8 每个索引所包含的文件

本节介绍的文件存在于每个索引中（exist one-per-index），下图描述索引中的文件及组成结构：

1.1.8.1 Segments文件

索引中活动（active）的Segments被存储在segment info文件中，segments_N，在索引中可能会包含一个或多个segments_N文件。然而，最大一代的那个文件（the one with largest generation）是活动的片断文件（这时更旧的segments_N文件依然存在（are present）是因为它们暂时（temporarily）还不能被删除，或者，一个writer正在处理提交请求（in the process of committing），或者一个用户定义的（custom）IndexDeletionPolicy正被使用）。这个文件按照名称列举每一个片断（lists each segment by name），详细描述分离的标准（seperate norm）和要删除的文件（deletion files），并且还包含了每一个片断的大小。

对2.1版本来说，还有一个文件segments.gen。这个文件包含了该索引中当前生成的代（current generation）（segments_N中的_N）。这个文件仅用于一个后退处理（fallback）以防止（in case）当前代（current generation）不能被准确地（accurately）通过单独地目录文件列举（by directory listing alone）来确定（determened）（由于某些NFS客户端因为基于时间的目录（time-based directory）的缓存终止（cache expiration）而引起）。这个文件简单地包含了一个int32的版本头（version header）（SegmentInfos.FORMAT_LOCKLESS=-2），遵照代的记录（followed by the generation recorded）规则，对int64来说会写两次（write twice）。

版本	Segments包含的项	数目	类型	描述
2.1之前版本	Format	1	Int32	在Lucene1.4中为-1，而在Lucene 2.1中为-3（SegmentsInfos.FORMAT_SINGLE_NORM_FILE）
	Version	1	Int64	统计在删除和添加文档时，索引被更改了多少次。
	NameCounter	1	Int32	用于为新的片断文件生成新的名字。
	SegCount	1	Int32	片断的数目
	SegName	SegCount	String	片断的名字，用于所有构成片断索引的文件的文件名前缀。
	SegSize	SegCount	Int32	包含在片断索引中的文档的数目。
2.1及之后版本	Format	1	Int32	同上
	Version	1	Int64	同上
	NameCounter	1	Int32	同上
	SegCount	1	Int32	同上
	SegName	SegCount	String	同上
	SegSize	SegCount	Int32	同上
	DelGen	SegCount	Int64	为分离的删除文件的代的数目（generation count of the separate deletes file），如果值为-1，表示没有分离的删除文件。如果值为0，表示这是一个2.1版本之前的片断，这时你必须检查文件是否存在_X.del这样的文件。任意大于0的值，表示有分离的删除文件，文件名为_X_N.del。
	HasSingleNormFile	SegCount	Int8	该值如果为1，表示Norm域（field）被写为一个单一连接的文件（single joined file）中（扩展名为.nrm），如果值为0，表示每一个field的norms被存储为分离的.fN文件中，参考下面的“标准化因素（Normalization Factors）”
	NumField	SegCount	Int32	表示NormGen数组的大小，如果为-1表示没有NormGen被存储。
	NormGen	SegCount * NumField	Int64	记录分离的标准文件（separate norm file）的代（generation），如果值为-1，表示没有normGens被存储，并且当片断文件是2.1之前版本生成的时，它们全部被假设为0（assumed to be 0）。而当片断文件是2.1及更高版本生成的时，它们全部被假设为-1。这时这个代（generation）的意义与上面DelGen的意义一样。
	IsCompoundFile	SegCount	Int8	记录是否该片断文件被写为一个复合的文件，如果值为-1表示它不是一个复合文件（compound file），如果为1则为一个复合文件。另外如果值为0，表示我们需要检查文件系统是否存在_X.cfs。

1.1.8.2 Lock文件

写锁（write lock）文件名为“write.lock”，它缺省存储在索引目录中。如果锁目录（lock directory）与索引目录不一致，写锁将被命名为“XXXX-write.lock”，其中“XXXX”是一个唯一的前缀（unique prefix），来源于（derived from）索引目录的全路径（full path）。当这个写锁出现时，一个writer当前正在修改索引（添加或者清除文档）。这个写锁确保在一个时刻只有一个writer修改索引。

需要注意的是在2.1版本之前（prior to），Lucene还使用一个commit lock，这个锁在2.1版本里被删除了。

1.1.8.3 Deletable文件

在Lucene 2.1版本之前，有一个“deletable”文件，包含了那些需要被删除文档的详细资料。在2.1版本后，一个writer会动态地（dynamically）计算哪些文件需要删除，因此，没有文件被写入文件系统。

Annotated Lucene：第四节什么是索引

2007-05-13T22:16:00.000-07:00

1 什么是索引

下面先了解一下索引结构的一些术语。

1.1 索引数据结构介绍

1.1.1 术语定义

Lucene中基本的概念（fundamental concepts）是index、Document、Field和term。

ú 一条索引（index）包含（contains）了一连串（a sequence of）文档（documents）。

ú 一个文档（document）是由一连串fields组成。

ú 一个field是由一连串命名了（a named sequence of）的terms组成。

ú 一个term是一个string（字符串）。

1.1.2 倒排索引（inverted indexing）

1.1.3 Fields的种类

1.1.4 片断（segments）

1. 为新添加的文档（newly added documents）创建新的片断（segments）。

2. 合并已存在的片断（merging existing segments）。

1.1.5 文档编号（document numbers）

ú 存储在每个segment中的编号仅仅是在所在的segment中是唯一的（unique），在它能够被使用在（be used in）一个更大的上下文（a larger context）中前必须被转变（converted）。标准的技术（standard technique）是给每一个segment分配（allocate）一个范围的值（a range of values），基于该segment所使用的编号的范围（the range of numbers）。为了将一篇文档的编号从一个segment转变为一个扩展的值（an external value），该片断的基础的文档编号（base document number）被添加（is added）。为了将一个扩展的值（external value）转变回一个segment的特定的值（specific value），该segment将该扩展的值所在的范围标识出来（be indentified），并且该segment的基础值（base value）将被减少（substracted）。例如，两个包含5篇文档的segments可能会被合并（combined），所以第一个segment有一个基础的值（base value）为0，第二个segment则为5。在第二个segment中的第3篇文档（document three from the second segment）将有一个扩展的值为8。

ú 当文档被删除的时候，在编号序列中（in the numbering）将产生（created）间隔段（gaps）。这些最后（eventually）在索引通过合并演进时（index evolves through merging）将会被清除（removed）。当segments被合并后（merged），已删除的文档将会被丢弃（dropped），一个刚被合并的（freshly-merged）segment因此在它的编号序列中（in its numbering）不再有间隔段（gaps）。

1.1.6 索引结构概述

每一个片断的索引（segment index）管理（maintains）如下的数据：

ú Fields名称：这包含了（contains）在索引中使用的一系列fields的名称（the set of field names）。

ú 已存储的field的值：它包含了，对每篇文档来说，一个属性-值数据对（attribute-value pairs）的清单（a list of），其中属性即为field的名字。这些被用来存储关于文档的备用信息（auxiliary information），比如它的标题（title）、url、或者一个访问一个数据库（database）的唯一标识（identifier）。这套存储的fields就是那些在检索时对每一个命中的（hits）文档所返回的（returned）信息。这些是通过文档编号（document number）来做为key得到的。

ú Term字典（dictionary）：一个包含（contains）所有terms的字典，被使用在所有文档中所有被索引的fields中。它还包含了该term所在的文档的数目（the number of documents which contains the term），并且指向了（pointer to）term的频率（frequency）和接近度（proximity）的数据（data）。

ú Term频率数据（frequency data）：对字典中的每一个term来说，所有包含该term（contains the term）的文档的编号（numbers of all documents），以及该term出现在该文档中的频率（frequency）。

ú Term接近度数据（proximity data）：对字典中的每一个term来说，该term出现在（occur）每一篇文档中的位置（positions）。

ú 调整因子（normalization factors）：对每一篇文档的每一个field来说，为一个存储的值（a value is stored）用来加入到（multiply into）命中该field的分数（score for hits on that field）中。

ú Term向量（vectors）：对每一篇文档的每一个field来说，term向量（有时候被称做文档向量）可以被存储。一个term向量由term文本和term的频率（frequency）组成（consists of）。怎么添加term向量到你的索引中请参考Field类的构造方法（constructors）。

ú 删除的文档（deleted documents）：一个可选的（optional）文件标示（indicating）哪一篇文档被删除。

关于这些项的详细信息在随后的章节（subsequent sections）中逐一介绍。

Annotated Lucene：第三节索引是如何创建的

2007-05-09T08:49:00.000-07:00

4 索引是如何创建的

为了使用Lucene来索引数据，首先你比把它转换成一个纯文本（plain-text）tokens的数据流（stream），并通过它创建出Document对象，其包含的Fields成员容纳这些文本数据。一旦你准备好些Document对象，你就可以调用IndexWriter类的addDocument(Document)方法来传递这些对象到Lucene并写入索引中。当你做这些的时候，Lucene首先分析（analyzer）这些数据来使得它们更适合索引。详见《Lucene In Action》

    // Store the index on disk
    Directory directory = FSDirectory.getDirectory("/tmp/testindex");
    // Use standard analyzer
    Analyzer analyzer = new StandardAnalyzer();
    // Create IndexWriter object
    IndexWriter iwriter = new IndexWriter(directory, analyzer, true);
    iwriter.setMaxFieldLength(25000);
    // make a new, empty document
    Document doc = new Document();
    File f = new File("/tmp/test.txt");
    // Add the path of the file as a field named "path".  Use a field that is
    // indexed (i.e. searchable), but don't tokenize the field into words.
    doc.add(new Field("path", f.getPath(), Field.Store.YES, Field.Index.UN_TOKENIZED));
    String text = "This is the text to be indexed.";
    doc.add(new Field("fieldname", text, Field.Store.YES,      Field.Index.TOKENIZED));
    // Add the last modified date of the file a field named "modified".  Use
    // a field that is indexed (i.e. searchable), but don't tokenize the field
    // into words.
    doc.add(new Field("modified",
        DateTools.timeToString(f.lastModified(), DateTools.Resolution.MINUTE),
        Field.Store.YES, Field.Index.UN_TOKENIZED));
    // Add the contents of the file to a field named "contents".  Specify a Reader,
    // so that the text of the file is tokenized and indexed, but not stored.
    // Note that FileReader expects the file to be in the system's default encoding.
    // If that's not the case searching for special characters will fail.
    doc.add(new Field("contents", new FileReader(f)));
    iwriter.addDocument(doc);
    iwriter.optimize();
    iwriter.close();

下面详细介绍每一个类的处理机制。

4.1 索引创建类IndexWriter

一个IndexWriter对象创建并且维护(maintains) 一条索引.

它的构造函数(constructor)的create参数(argument)确定(determines)是否一条新的索引将被创建，或者是否一条已经存在的索引将被打开。需要注意的是你可以使用create=true参数打开一条索引，即使有其他readers也在在使用这条索引。旧的readers将继续检索它们已经打开的”point in time”快照（snapshot），并不能看见那些新已创建的索引，直到它们再次打开（re-open）。另外还有一个没有create参数的构造函数，如果提供的目录（provided path）中没有已经存在的索引，它将创建它，否则将打开此存在的索引。

另一方面（in either case），添加文档使用addDocument()方法，删除文档使用removeDocument()方法，而且一篇文档可以使用updateDocument()方法来更新（仅仅是先执行delete在执行add操作而已）。当完成了添加、删除、更新文档，应该需要调用close方法。

这些修改会缓存在内存中（buffered in memory），并且定期地（periodically）刷新到（flush）Directory中（在上述方法的调用期间）。一次flush操作会在如下时候触发（triggered）：当从上一次flush操作后有足够多缓存的delete操作（参见setMaxBufferedDeleteTerms(int)），或者足够多已添加的文档（参见setMaxBufferedDocs(int)），无论哪个更快些（whichever is sooner）。当一次flush发生时，等待的（pending）delete和add文档都会被flush到索引中。一次flush可能触发一个或更多的片断合并（segment merges）。

构造函数中的可选参数（optional argument）autoCommit控制（controls）修改对IndexReader实体（instance）读取相同索引的能见度（visibility）。当设置为false时，修改操作将不可见（visible）直到close()方法被调用后。需要注意的是修改将依然被flush进Directory，就像新文件一样（as new files），但是却不会被提交（commit）（没有新的引用那些新文件的segments_N文件会被写入（written referencing the new files））直道close()方法被调用。如果在调用close()之前发生了某种严重错误（something goes terribly wrong）（例如JVM崩溃了），于是索引将反映（reflect）没有任何修改发生过（none of changes made）（它将保留它开始的状态（remain in its starting state））。你还可以调用close()，这样可以关闭那些没有提交任何修改操作的writers，并且清除所有那些已经flush但是现在不被引用的（unreferenced）索引文件。这个模式（mode）对防止（prevent）readers在一个错误的时间重新刷新（refresh）非常有用（例如在你完成所有delete操作后，但是在你完成添加操作前的时候）。它还能被用来实现简单的single-writer的事务语义（transactional semantics）（"all or none"）。

当autoCommit设为true的时候，每次flush也会是一次提交（IndexReader实体将会把每次flush当作一次提交）。这是缺省的设置，目的是为了匹配（match）2.2版本之前的行为（behavior）。当以这种模式运行时，当优化（optimize）或者片断合并（segment merges）正在进行（take place）的时候需要小心地重新刷新（refresh）你的readers，因为这两个操作会绑定（tie up）可观的（substantial）磁盘空间。

当一条索引暂时（for a while）将不会有更多的文档被添加，并且期望（desired）得到最理想（optimal）的检索性能（performance），于是optimize()方法应该在索引被关闭之前被调用。

打开IndexWriter会为使用的Directory创建一个lock文件。尝试对相同的Directory打开另一个IndexWriter将会导致（lead to）一个LockObtainFailedException异常。如果一个建立在相同的Directory的IndexReader对象被用来从这条索引中删除文档的时候，这个异常也会被抛出。

专家（Expert）：IndexWriter允许指定（specify）一个可选的（optional）IndexDeletionPolicy实现。你可以通过这个控制什么时候优先的提交（prior commit）从索引中被删除。缺省的策略（policy）是KeepOnlyLastCommitDeletionPolicy类，在一个新的提交完成的时候它会马上所有的优先提交（prior commit）（这匹配2.2版本之前的行为）。创建你自己的策略能够允许你明确地（explicitly）保留以前的”point in time”提交（commit）在索引中存在（alive）一段时间。为了让readers刷新到新的提交，在它们之下没有被删除的旧的提交（without having the old commit deleted out from under them）。这对那些不支持“在最后关闭时才删除”语义（”delete on last close” semantics）的文件系统（filesystem）如NFS，而这是Lucene的“point in time”检索通常所依赖的（normally rely on）。

Annotated Lucene 作者：naven 日期：2007-5-1

Annotated Lucene：第二节认识一下与索引有关的类

2007-05-07T04:44:00.001-07:00

Annotated Lucene(中文版)

Annotated Lucene 作者：naven

3 索引类关系图

下面逐个介绍与建立索引有关的一些类及它们的关系。

3.1 org.apache.lucene.store.IndexWriter

一个IndexWriter对象只创建并维护一个索引。IndexWriter通过指定存放的目录（Directory）以及文档分析器（Analyzer）来构建，direcotry代表索引存储（resides）在哪里；analyzer表示如何来分析文档的内容；similarity用来规格化（normalize）文档，给文档算分（scoring）；IndexWriter类里还有一些SegmentInfos对象用于存储索引片段信息，以及发生故障回滚等。以下是它们的类图：

3.2 org.apache.lucene.store.Directory

一个Directory对象是一系列统一的文件列表（a flat list of files）。文件可以在它们被创建的时候一次写入，一旦文件被创建，它再次打开后只能用于读取（read）或者删除（delete）操作。并且同时在读取和写入的时候允许随机访问（random access）。

在这里并不直接使用Java I/O API，但是更确切地说，所有I/O操作都是通过这个API处理的。这使得读写操作方式更统一起来，如基于内存的索引（RAM-based indices）的实现（即RAMDirectory）、通过JDBC存储在数据库中的索引、将一个索引存储为一个文件的实现（即FSDirectory）。

Directory的锁机制是一个LockFactory的实例实现的，可以通过调用Directory实例的setLockFactory()方法来更改。

3.3 org.apache.lucene.store.FSDirectory

FSDirectory类直接实现Directory抽象类为一个包含文件的目录。目录锁的实现使用缺省的SimpleFSLockFactory，但是可以通过两种方式修改，即给getLockFactory()传入一个LockFactory实例，或者通过调用setLockFactory()方法明确制定LockFactory类。

目录将被缓存（cache）起来，对一个指定的符合规定的路径（canonical path）来说，同样的FSDirectory实例通常通过getDirectory()方法返回。这使得同步机制（synchronization）能对目录起作用。

3.4 org.apache.lucene.store.RAMDirectory

RAMDirectory类是一个驻留内存的（memory-resident）Directory抽象类的实现。目录锁的实现使用缺省的SingleInstanceLockFactory，但是可以通过setLockFactory()方法修改。

3.5 org.apache.lucene.store.IndexInput

IndexInput类是一个为了从一个目录（Directory）中读取文件的抽象基类，是一个随机访问（random-access）的输入流（input stream），用于所有Lucene读取Index的操作。BufferedIndexInput是一个实现了带缓冲的IndexInput的基础实现。

3.6 org.apache.lucene.store.IndexOutput

IndexOutput类是一个为了写入文件到一个目录（Directory）中的抽象基类，是一个随机访问（random-access）的输出流（output stream），用于所有Lucene写入Index的操作。BufferedIndexOutput是一个实现了带缓冲的IndexOutput的基础实现。RAMOuputStream是一个内存驻留（memory-resident）的IndexOutput的实现类。

3.7 org.apache.lucene.store.Analyzer

Analyzer类构建用于分析文本的TokenStream对象，因此（thus）它表示（represent）用于从文本中分解（extract）出组成索引的terms的一个规则器（policy）。典型的（typical）实现首先创建一个Tokenizer，它将那些从Reader对象中读取字符流（stream of characters）打碎为（break into）原始的Tokens（raw Tokens）。然后一个或更多的TokenFilters可以应用在这个Tokenizer的输出上。警告：你必须在你的子类（subclass）中覆写（override）定义在这个类中的其中一个方法，否则的话Analyzer将会进入一个无限循环（infinite loop）中。

3.8 org.apache.lucene.store.StandardAnalyzer

StandardAnalyzer类是使用一个English的stop words列表来进行tokenize分解出文本中word，使用StandardTokenizer类分解词，再加上StandardFilter以及LowerCaseFilter以及StopFilter这些过滤器进行处理的这样一个Analyzer类的实现。

3.9 org.apache.lucene.search. Similarity

Similarity类实现算分（scoring）的API，它的子类实现了检索算分的算法。DefaultSimilarity类是缺省的算分的实现，SimilarityDelegator类是用于委托算分（delegating scoring）的实现，在Query.getSimilarity(Searcher)}的实现里起作用，以便覆写（override）一个Searcher中Similarity实现类的仅有的确定方法（certain methods）。

查询q相对于文档d的分数与在文档和查询向量（query vectors）之间的余弦距离（cosing-distance）或者点乘积（dot-product）有关系（correlates to），文档和查询向量存于一个信息检索（Information Retrieval）的向量空间模型（Vector Space Model (VSM)）之中。一篇文档的向量与查询向量越接近（closer to），它的得分也越高（scored higher），这个分数按如下公式计算：

其中：

1. tf(t in d) 与term的出现次数（frequency）有关系（correlate to），定义为（defined as）term t在当前算分（currently scored）的文档d中出现（appear in）的次数（number of times）。对一个给定（gived）的term，那些出现此term的次数越多（more occurences）的文档将获得越高的分数（higher score）。缺省的tf(t in d)算法实现在DefaultSimilarity类中，公式如下：

2. idf(t) 代表（stand for）反转文档频率（Inverse Document Frequency）。这个分数与反转（inverse of）的docFreq（出现过term t的文档数目）有关系。这个分数的意义是越不常出现（rarer）的term将为最后的总分贡献（contribution）更多的分数。缺省idff(t in d)算法实现在DefaultSimilarity类中，公式如下：

3. coord(q,d) 是一个评分因子，基于（based on）有多少个查询terms在特定的文档（specified document）中被找到。通常（typically），一篇包含了越多的查询terms的文档将比另一篇包含更少查询terms的文档获得更高的分数。这是一个搜索时的因子（search time factor）是在搜索的时候起作用（in effect at search time），它在Similarity对象的coord(q,d)函数中计算。

4. queryNorm(q) 是一个修正因子（normalizing factor），用来使不同查询间的分数更可比较（comparable）。这个因子不影响文档的排名（ranking）（因为搜索排好序的文档（ranked document）会增加（multiplied）相同的因数（same factor）），更确切地说只是（but rather just）为了尝试（attempt to）使得不同查询条件（甚至不同索引（different indexes））之间更可比较性。这是一个搜索时的因子是在搜索的时候起作用，由Similarity对象计算。缺省queryNorm(q)算法实现在DefaultSimilarity类中，公式如下：

sumOfSquaredWeights（查询的terms）是由查询Weight对象计算的，例如一个布尔（boolean）条件查询的计算公式为：

5. t.getBoost() 是一个搜索时（search time）的代表查询q中的term t的boost数值，具体指定在（as specified in）查询的文本中（参见查询语法），或者由应用程序调用setBoost()来指定。需要注意的是实际上（really）没有一个直接（direct）的API来访问（accessing）一个多个term的查询（multi term query）中的一个term 的boost值，更确切地说（but rather），多个terms（multi terms）在一个查询里的表示形式（represent as）是多个TermQuery对象，所以查询里的一个term的boost值的访问是通过调用子查询（sub-query）的getBoost()方法实现的。

6. norm(t,d) 是提炼取得（encapsulate）一小部分boost值（在索引时间）和长度因子（length factor）：

ú document boost – 在添加文档到索引之前通过调用doc.setBoost()来设置。

ú Field boost – 在添加Field到文档之前通过调用field.setBoost()来设置。

ú lengthNorm(field) – 在文档添加到索引的时候，根据（in accordance with）文档中该field的tokens数目计算得出，所以更短（shorter）的field会贡献更多的分数。lengthNorm是在索引的时候起作用，由Similarity类计算得出。

当一篇文档被添加到索引的时候，所有上面计算出的因子将相乘起来（multiplied）。如果文档拥有多个相同名字的fields（multiple fields with same name），所有这些fields的boost值也会被一起相乘起来（multiplied together）：

然而norm数值的结果在被存储（stored）之前被编码成（encoded as）一个单独的字节(single byte)。在检索的时候，这个norm字节值从索引目录（index directory）中读取出来，并解码回（decoded back）一个norm浮点数值（float value）。这个编/解码（encoding/decoding）行为，会缩减（reduce）索引的大小（index size），这得自于（come with）精度损耗的代价（price of precision loss）- 它不保证decode(encode(x))=x，举例来说decode(encode(0.89))=0.75。还有需要注意的是，检索的时候再修改评分（scoring）的这个norm部分已近太迟了，例如，为检索使用不同的Similarity。

Annotated Lucene 作者：naven 日期：2007-5-1

Annotated Lucene：第一节 Lucene是什么

2007-05-07T04:40:00.000-07:00

Annotated Lucene(中文版)

Annotated Lucene 作者：naven

1 Lucene是什么

Lucene 通过一些简单的接口（simple API）提供了强大的特征（powerful features）：

可扩展的高性能的索引能力（Scalable, High-Performance Indexing）

ü 超过20M/分钟的处理能力（Pentium M 1.5GHz）

ü 很少的RAM内存需求，只需要1MB heap

ü 增量索引（incremental indexing）的速度与批量索引（batch indexing）的速度一样快

ü 索引的大小粗略（roughly）为被索引的文本大小的20-30%

强大的精确的高效率的检索算法（Powerful, Accurate and Efficient Search Algorithms）

ü 分级检索（ranked searching）能力，最好的结果优先推出在前面

ü 很多强大的query种类：phrase queries, wildcard queries, proximity queries, range queries等

ü 支持域检索（fielded searching），如标题、作者、正文等

ü 支持日期范围检索（date-range searching）

ü 可以按任意域排序（sorting by any field）

ü 支持多个索引的检索（multiple-index searching）并合并结果集（merged results）

ü 允许更新和检索（update and searching）并发进行（simultaneous）

跨平台解决方案（Cross-Platform Solution）

ü 以Open Source方式提供并遵循Apache License，允许你可以在即包括商业应用也包括Open Source程序中使用Lucene

ü 100%-pure Java（纯Java实现）

ü 提供其他开发语言的实现版本并且它们的索引文件是兼容的

Lucene API被分成（divide into）如下几种包（package）

org.apache.lucene.analysis 定义了一个抽象的Analyser API，用于将text文本从一个java.io.Reader转换成一个TokenStream，即包括一些Tokens的枚举容器（enumeration）。一个TokenStream的组成（compose）是通过在一个Tokenizer的输出的结果上再应用TokenFilters生成的。一些少量的Analysers实现已经提供，包括StopAnalyzer和基于语法（gramar-based）分析的StandardAnalyzer。

org.apache.lucene.document 提供一个简单的Document类，一个document只不过包括一系列的命名了（named）的Fields（域），它们的内容可以是文本（strings）也可以是一个java.io.Reader的实例。

org.apache.lucene.index 提供两个主要地饿类，一个是IndexWriter用于创建索引并添加文档（document），另一个是IndexReader用于访问索引中的数据。

org.apache.lucene.search 提供数据结构（data structures）来呈现（represent）查询（queries）：TermQuery用于单个的词（individual words），PhraseQuery用于短语，BooleanQuery用于通过boolean关系组合（combinations）在一起的queries。而抽象的Searcher用于转变queries为命中的结果（hits）。IndexSearcher实现了在一个单独（single）的IndexReader上检索。

org.apache.lucene.queryParser 使用JavaCC实现一个QueryParser。

org.apache.lucene.store 定义了一个抽象的类用于存储呈现的数据(storing persistent data)，即Directory（目录），一个收集器（collection）包含了一些命名了的文件（named files），它们通过一个IndexOutput来写入，以及一个IndexInput来读取。提供了两个实现，FSDirectory使用一个文件系统目录来存储文件，而另一个RAMDirectory则实现了将文件当作驻留内存的数据结构（memory-resident data structures）。

org.apache.lucene.util 包含了一小部分有用（handy）的数据结构，如BitVector和PriorityQueue等。

2 Hello World!

下面是一段简单的代码展示如何使用Lucene来进行索引和检索（使用JUnit来检查结果是否是我们预期的）：

    // Store the index in memory:
    Directory directory = new RAMDirectory();
    // To store an index on disk, use this instead:
    //Directory directory = FSDirectory.getDirectory("/tmp/testindex");
    IndexWriter iwriter = new IndexWriter(directory, analyzer, true);
    iwriter.setMaxFieldLength(25000);
    Document doc = new Document();
    String text = "This is the text to be indexed.";
    doc.add(new Field("fieldname", text, Field.Store.YES,
        Field.Index.TOKENIZED));
    iwriter.addDocument(doc);
    iwriter.optimize();
    iwriter.close();

    // Now search the index:
    IndexSearcher isearcher = new IndexSearcher(directory);
    // Parse a simple query that searches for "text":
    QueryParser parser = new QueryParser("fieldname", analyzer);
    Query query = parser.parse("text");
    Hits hits = isearcher.search(query);
    assertEquals(1, hits.length());
    // Iterate through the results:
    for (int i = 0; i < hits.length(); i++) {
      Document hitDoc = hits.doc(i);
      assertEquals("This is the text to be indexed.", hitDoc.get("fieldname"));
    }
    isearcher.close();
    directory.close();

为了使用Lucene，一个应用程序需要做如下几件事：

1. 通过添加一系列Fields来创建一批Documents对象。

2. 创建一个IndexWriter对象，并且调用它的AddDocument()方法来添加进Documents。

3. 调用QueryParser.parse()处理一段文本（string）来建造一个查询（query）对象。

4. 创建一个IndexReader对象并将查询对象传入到它的search()方法中。

Annotated Lucene 作者：naven 日期：2007-5-1

Naven原创系列文章下载

2007-05-07T04:37:00.000-07:00

      这是本人原创的系列文章制作的pdf，已陆续发布cppblog上，现开放下载，谢谢支持！

      1，《Javen库的设计和使用》
      2，《LINQ，语言层面的OR映射技术，用面向对象操作数据库》
      3，《侯捷《C++OOPGPDP》讲座心得》

Javen-Studio咖啡小屋软件工作室

Hawk搜索引擎平台0.6.22测试版(免费下载)

Annotated Lucene （源码剖析）

Hawk搜索引擎平台应用：词典搜索和文档搜索

Hawk搜索引擎平台0.6.9测试版(提供下载)

欢迎光临 Javen-Studio 新网址：http://javenstudio.org

Hawk 搜索引擎平台 0.4.50 开发版

Annotated Hadoop （源码剖析）

Hawk-0.4.35搜索引擎平台开发版发布

Annotated Lucene：第五节 索引里有什么

1.1.3 Fields的种类

1.1.6 索引结构概述

1.1.7 索引文件中定义的数据类型

1.1.8 每个索引所包含的文件

1.1.8.1 Segments文件

1.1.8.2 Lock文件

1.1.8.3 Deletable文件

Annotated Lucene：第四节 什么是索引

1.1.3 Fields的种类

1.1.6 索引结构概述

Annotated Lucene：第三节 索引是如何创建的

4 索引是如何创建的

4.1 索引创建类IndexWriter

Annotated Lucene：第二节 认识一下与索引有关的类

Annotated Lucene(中文版)

3 索引类关系图

3.1 org.apache.lucene.store.IndexWriter

3.2 org.apache.lucene.store.Directory

3.3 org.apache.lucene.store.FSDirectory

3.4 org.apache.lucene.store.RAMDirectory

3.5 org.apache.lucene.store.IndexInput

3.6 org.apache.lucene.store.IndexOutput

3.7 org.apache.lucene.store.Analyzer

3.8 org.apache.lucene.store.StandardAnalyzer

3.9 org.apache.lucene.search. Similarity

Annotated Lucene：第一节 Lucene是什么

Annotated Lucene(中文版)

1 Lucene是什么

2 Hello World!

Annotated Lucene 作者：naven 日期：2007-5-1

Naven原创系列文章下载

Annotated Lucene：第五节索引里有什么

Annotated Lucene：第四节什么是索引

Annotated Lucene：第三节索引是如何创建的

Annotated Lucene：第二节认识一下与索引有关的类