基于Java的全文索引/检索引擎——Lucene
Lucene不是一个完整的全文索引应用，而是是一个用Java写的全文索引引擎工具包，它可以方便的嵌入到各种应用中实现针对应用的全文索引/检索功能。
Lucene的作者：Lucene的贡献者Doug Cutting是一位资深全文索引/检索专家，曾经是V-Twin搜索引擎(Apple的Copland操作系统的成就之一)的主要开发者，后在Excite担任高级系统架构设计师，目前从事于一些INTERNET底层架构的研究。他贡献出的Lucene的目标是为各种中小型应用程序加入全文检索功能。
Lucene的发展历程：早先发布在作者自己的www.lucene.com，后来发布在SourceForge，2001年年底成为APACHE基金会jakarta的一个子项目：http://jakarta.apache.org/lucene/
全文检索的实现机制
Lucene的API接口设计的比较通用，输入输出结构都很像数据库的表==>记录==>字段，所以很多传统的应用的文件、数据库等都可以比较方便的映射到Lucene的存储结构/接口中。总体上看：可以先把Lucene当成一个支持全文索引的数据库系统。
比较一下Lucene和数据库：
| Lucene | 数据库 |
索引数据源：doc(field1,field2...) doc(field1,field2...) |
索引数据源：record(field1,field2...) record(field1..) |
| Document：一个需要进行索引的“单元” 一个Document由多个字段组成 |
Record：记录，包含多个字段 |
| Field：字段 | Field：字段 |
| Hits：查询结果集，由匹配的Document组成 | RecordSet：查询结果集，由多个Record组成 |
通常比较厚的书籍后面常常附关键词索引表（比如：北京：12, 34页， 上海：3,77页……），它能够帮助读者比较快地找到相关内容的页码。
而数据库索引能够大大提高查询的速度原理也是一样，想像一下通过书后面的索引查找的速度要比一页一页地翻内容高多少倍……而索引之所以效率高，另外一个原因是它是排好序的。对于检索系统来说核心是一个排序问题。
建立一个高效检索系统的关键是建立一个类似于科技索引一样的反向索引机制，将数据源（比如多篇文章）排序顺序存储的同时，有另外一个排好序的关键词列表，用于存储关键词==>文章映射关系，利用这样的映射关系索引：[关键词==>出现关键词的文章编号，出现次数（甚至包括位置：起始偏移量，结束偏移量），出现频率]，检索过程就是把模糊查询变成多个可以利用索引的精确查询的逻辑组合的过程。从而大大提高了多关键词查询的效率，所以，全文检索问题归结到最后是一个排序问题。
全文检索和数据库应用最大的不同在于：让最相关的头100条结果满足98%以上用户的需求
Lucene的创新之处：
大部分的搜索（数据库）引擎都是用B树结构来维护索引，索引的更新会导致大量的IO操作，Lucene在实现中，对此稍微有所改进：不是维护一个索引文件，而是在扩展索引的时候不断创建新的索引文件，然后定期的把这些新的小索引文件合并到原先的大索引中（针对不同的更新策略，批次的大小可以调整），这样在不影响检索的效率的前提下，提高了索引的效率。
Lucene和其他一些全文检索系统/应用的比较：
| Lucene | 其他开源全文检索系统 | |
| 增量索引和批量索引 | 可以进行增量的索引(Append)，可以对于大量数据进行批量索引，并且接口设计用于优化批量索引和小批量的增量索引。 | 很多系统只支持批量的索引，有时数据源有一点增加也需要重建索引。 |
| 数据源 | Lucene没有定义具体的数据源，而是一个文档的结构，因此可以非常灵活的适应各种应用（只要前端有合适的转换器把数据源转换成相应结构）， | 很多系统只针对网页，缺乏其他格式文档的灵活性。 |
| 索引内容抓取 | Lucene的文档是由多个字段组成的，甚至可以控制那些字段需要进行索引，那些字段不需要索引，近一步索引的字段也分为需要分词和不需要分词的类型： 需要进行分词的索引，比如：标题，文章内容字段 不需要进行分词的索引，比如：作者/日期字段 |
缺乏通用性，往往将文档整个索引了 |
| 语言分析 | 通过语言分析器的不同扩展实现： 可以过滤掉不需要的词：an the of 等， 西文语法分析：将jumps jumped jumper都归结成jump进行索引/检索 非英文支持：对亚洲语言，阿拉伯语言的索引支持 |
缺乏通用接口实现 |
| 查询分析 | 通过查询分析接口的实现，可以定制自己的查询语法规则： 比如： 多个关键词之间的 + - and or关系等 |
|
| 并发访问 | 能够支持多用户的使用 |
关于亚洲语言的的切分词问题(Word Segment)
对于中文来说，全文索引首先还要解决一个语言分析的问题，对于英文来说，语句中单词之间是天然通过空格分开的，但亚洲语言的中日韩文语句中的字是一个字挨一个，所以，首先要把语句中按“词”进行索引的话，这个词如何切分出来就是一个很大的问题。
首先，肯定不能用单个字符作(si-gram)为索引单元，否则查“上海”时，不能让含有“海上”也匹配。
但一句话：“北京*”，计算机如何按照中文的语言习惯进行切分呢？
“北京 *” 还是“北 京 *”？让计算机能够按照语言习惯进行切分，往往需要机器有一个比较丰富的词库才能够比较准确的识别出语句中的单词。
另外一个解决的办法是采用自动切分算法：将单词按照2元语法(bigram)方式切分出来，比如："北京*" ==> "北京 京天 天安 安门"。
这样，在查询的时候，无论是查询"北京" 还是查询"*"，将查询词组按同样的规则进行切分："北京"，"天安安门"，多个关键词之间按与"and"的关系组合，同样能够正确地映射到相应的索引中。
这种方式对于其他亚洲语言：韩文，日文都是通用的。
基于自动切分的最大优点是没有词表维护成本，实现简单，缺点是索引效率低，但对于中小型应用来说，基于2元语法的切分还是够用的。
基于2元切分后的索引一般大小和源文件差不多，而对于英文，索引文件一般只有原文件的30%-40%不同，
| 自动切分 | 词表切分 | |
| 实现 | 实现非常简单 | 实现复杂 |
| 查询 | 增加了查询分析的复杂程度， | 适于实现比较复杂的查询语法规则 |
| 存储效率 | 索引冗余大，索引几乎和原文一样大 | 索引效率高，为原文大小的30％左右 |
| 维护成本 | 无词表维护成本 | 词表维护成本非常高：中日韩等语言需要分别维护。 还需要包括词频统计等内容 |
| 适用领域 | 嵌入式系统：运行环境资源有限 分布式系统：无词表同步问题 多语言环境：无词表维护成本 |
对查询和存储效率要求高的专业搜索引擎 |
目前比较大的搜索引擎的语言分析算法一般是基于以上2个机制的结合。
lucene的组成结构
对于外部应用来说索引模块(index)和检索模块(search)是主要的外部应用入口
| org.apache.Lucene.search/ | 搜索入口 |
| org.apache.Lucene.index/ | 索引入口 |
| org.apache.Lucene.analysis/ | 语言分析器 |
| org.apache.Lucene.queryParser/ | 查询分析器 |
| org.apache.Lucene.document/ | 存储结构 |
| org.apache.Lucene.store/ | 底层IO/存储结构 |
| org.apache.Lucene.util/ | 一些公用的数据结构 |
索引过程：从命令行读取文件名（多个），将文件分路径(path字段)和内容(body字段)2个字段进行存储，并对内容进行全文索引：
索引的单位是Document对象，每个Document对象包含多个字段Field对象，针对不同的字段属性和数据输出的需求，对字段还可以选择不同的索引/存储字段规则，
列表如下：
| 方法 | 切词 | 索引 | 存储 | 用途 |
|---|---|---|---|---|
| Field.Text(String name, String value) | Yes | Yes | Yes | 切分词索引并存储，比如：标题，内容字段 |
| Field.Text(String name, Reader value) | Yes | Yes | No | 切分词索引不存储，比如：META信息， 不用于返回显示，但需要进行检索内容 |
| Field.Keyword(String name, String value) | No | Yes | Yes | 不切分索引并存储，比如：日期字段 |
| Field.UnIndexed(String name, String value) | No | No | Yes | 不索引，只存储，比如：文件路径 |
| Field.UnStored(String name, String value) | Yes | Yes | No | 只全文索引，不存储 |
索引过程中可以看到：
- 语言分析器提供了抽象的接口，因此语言分析(Analyser)是可以定制的，虽然lucene缺省提供了2个比较通用的分析器SimpleAnalyser和StandardAnalyser，这2个分析器缺省都不支持中文，所以要加入对中文语言的切分规则，需要修改这2个分析器。
- Lucene并没有规定数据源的格式，而只提供了一个通用的结构（Document对象）来接受索引的输入，因此输入的数据源可以是：数据库，WORD文档，PDF文档，HTML文档……只要能够设计相应的解析转换器将数据源构造成成Docuement对象即可进行索引。
- 对于大批量的数据索引，还可以通过调整IndexerWrite的文件合并频率属性（mergeFactor）来提高批量索引的效率。
检索过程和结果显示：
- 搜索结果返回的是Hits对象，可以通过它再访问Document==>Field中的内容。
- 假设根据body字段进行全文检索，可以将查询结果的path字段和相应查询的匹配度(score)打印出来
- 在整个检索过程中，语言分析器，查询分析器，甚至搜索器（Searcher）都是提供了抽象的接口，可以根据需要进行定制。
简化的查询分析器
目前LUCENE支持的语法：
Query ::= ( Clause )*
Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")")
中间的逻辑包括：and or + - &&||等符号，而且还有"短语查询"和针对西文的前缀/模糊查询等，对于一般应用来说，这些功能有一些华而不实，其实能够实现目前类似于Google的查询语句分析功能其实对于大多数用户来说已经够了。
所以，Lucene早期版本的QueryParser仍是比较好的选择。
添加修改删除指定记录（Document）
Lucene提供了索引的扩展机制，因此索引的动态扩展应该是没有问题的，而指定记录的修改也似乎只能通过记录的删除，然后重新加入实现。
如何删除指定的记录呢？
删除的方法也很简单，只是需要在索引时根据数据源中的记录ID专门另建索引，然后利用IndexReader.delete(Termterm)方法通过这个记录ID删除相应的Document。
根据某个字段值的排序功能
lucene缺省是按照自己的相关度算法（score）进行结果排序的，但能够根据其他字段进行结果排序是一个在LUCENE的开发邮件列表中经常提到的问题，很多原先基于数据库应用都需要除了基于匹配度（score）以外的排序功能。
而从全文检索的原理我们可以了解到，任何不基于索引的搜索过程效率都会导致效率非常的低，如果基于其他字段的排序需要在搜索过程中访问存储字段，速度回大大降低，因此非常是不可取的。
但这里也有一个折中的解决方法：在搜索过程中能够影响排序结果的只有索引中已经存储的docID和score这2个参数，所以，基于score以外的排序，其实可以通过将数据源预先排好序，然后根据docID进行排序来实现。这样就避免了在LUCENE搜索结果外对结果再次进行排序和在搜索过程中访问不在索引中的某个字段值。
更通用的输入输出接口
虽然lucene没有定义一个确定的输入文档格式，但越来越多的人想到使用一个标准的中间格式作为Lucene的数据导入接口，然后其他数据，比如PDF只需要通过解析器转换成标准的中间格式就可以进行数据索引了。这个中间格式主要以XML为主，类似实现已经不下4，5个：
数据源: WORD PDF HTML DB other
\ | | | /
XML中间格式
|
Lucene INDEX
索引过程优化
索引一般分2种情况，一种是小批量的索引扩展，一种是大批量的索引重建。
在索引过程中，并不是每次新的DOC加入进去索引都重新进行一次索引文件的写入操作（文件I/O是一件非常消耗资源的事情）。
Lucene先在内存中进行索引操作，并根据一定的批量进行文件的写入。
这个批次的间隔越大，文件的写入次数越少，但占用内存会很多。反之占用内存少，但文件IO操作频繁，索引速度会很慢。
在IndexWriter中有一个MERGE_FACTOR参数可以帮助你在构造索引器后根据应用环境的情况充分利用内存减少文件的操作。
根据经验：缺省Indexer是每20条记录索引后写入一次，每将MERGE_FACTOR增加50倍，索引速度可以提高1倍左右。
搜索过程优化
Lucene面向全文检索的优化在于首次索引检索后，并不把所有的记录（Document）具体内容读取出来，而起只将所有结果中匹配度最高的头100条结果（TopDocs）的ID放到结果集缓存中并返回，这里可以比较一下数据库检索：如果是一个10,000条的数据库检索结果集，数据库是一定要把所有记录内容都取得以后再开始返回给应用结果集的。
所以即使检索匹配总数很多，Lucene的结果集占用的内存空间也不会很多。对于一般的模糊检索应用是用不到这么多的结果的，头100条已经可以满足90%以上的检索需求。
如果首批缓存结果数用完后还要读取更后面的结果时Searcher会再次检索并生成一个上次的搜索缓存数大1倍的缓存，并再重新向后抓取。
所以如果构造一个Searcher去查1－120条结果，Searcher其实是进行了2次搜索过程：头100条取完后，缓存结果用完，Searcher重新检索再构造一个200条的结果缓存，依此类推，400条缓存，800条缓存。
由于每次Searcher对象消失后，这些缓存也访问不到那了，你有可能想将结果记录缓存下来，缓存数尽量保证在100以下以充分利用首次的结果缓存，不让Lucene浪费多次检索，而且可以分级进行结果缓存。
Lucene的另外一个特点是在收集结果的过程中将匹配度低的结果自动过滤掉了。这也是和数据库应用需要将搜索的结果全部返回不同之处。
从Lucene学到更多
Luene的确是一个面向对象设计的典范
- 所有的问题都通过一个额外抽象层来方便以后的扩展和重用：你可以通过重新实现来达到自己的目的，而对其他模块则不需要；
- 简单的应用入口Searcher, Indexer，并调用底层一系列组件协同的完成搜索任务；
- 所有的对象的任务都非常专一：比如搜索过程：QueryParser分析将查询语句转换成一系列的精确查询的组合(Query),通过底层的索引读取结构IndexReader进行索引的读取，并用相应的打分器给搜索结果进行打分/排序等。所有的功能模块原子化程度非常高，因此可以通过重新实现而不需要修改其他模块。
- 除了灵活的应用接口设计，Lucene还提供了一些适合大多数应用的语言分析器实现（SimpleAnalyser,StandardAnalyser），这也是新用户能够很快上手的重要原因之一。
这些优点都是非常值得在以后的开发中学习借鉴的。作为一个通用工具包，Lunece的确给予了需要将全文检索功能嵌入到应用中的开发者很多的便利。
此外，通过对Lucene的学习和使用，理解了为什么很多数据库优化设计中要求，比如：
- 尽可能对字段进行索引来提高查询速度，但过多的索引会对数据库表的更新操作变慢，而对结果过多的排序条件，实际上往往也是性能的杀手之一。
- 很多商业数据库对大批量的数据插入操作会提供一些优化参数，这个作用和索引器的merge_factor的作用是类似的，
- 20%/80%原则：查的结果多并不等于质量好，尤其对于返回结果集很大，如何优化这头几十条结果的质量往往才是最重要的。
- 尽可能让应用从数据库中获得比较小的结果集，因为即使对于大型数据库，对结果集的随机访问也是一个非常消耗资源的操作。
Lucene学习示例
1.HelloWorld入门
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException; import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version; /* 【Lucene3.6.2入门系列】第01节_HelloWord
* @see 这里只需用到一个lucene-core-3.6.2.jar
* @see Lucene官网:http://lucene.apache.org
* @see Lucene下载:http://archive.apache.org/dist/lucene/java/
* @see Lucene文档:http://wiki.apache.org/lucene-java/
* @see -------------------------------------------------------------------------------------------------------------
* @see 1)对于全文搜索工具,都是由索引、分词、搜索三部分组成
* @see 2)被存储和被索引,是两个独立的概念
* @see -------------------------------------------------------------------------------------------------------------
* @see 域的存储选项
* @see Field.Store.YES--会把该域中的内容存储到文件中,方便进行文本的还原
* @see Field.Store.NO---表示该域中的内容不存储到文件中,但允许被索引,且内容无法完全还原(doc.get("##"))
* @see -------------------------------------------------------------------------------------------------------------
* @see 域的索引选项
* @see Field.Index.ANALYZED----------------进行分词和索引,适用于标题、内容等
* @see Field.Index.NOT_ANALYZED------------进行索引但不分词(如身份证号、姓名、ID等),适用于精确搜索
* @see Field.Index.ANALYZED_NOT_NORMS------进行分词但是不存储norms信息,这个norms中包括了创建索引的时间和权值等信息
* @see Field.Index.NOT_ANALYZED_NOT_NORMS--即不进行分词也不存储norms信息
* @see Field.Index.NO----------------------不进行索引
* @see norms:当数据被搜索出来后,便涉及到排序的问题,而排序是有一些评分规则的,于是NORMS中就存储了这些排序的信息
* @see -------------------------------------------------------------------------------------------------------------
* @see 域选项最佳实践
* @see Field.Store Field.Index 域值
* @see YES NOT_ANALYZED_NOT_NORMS 标识符（主键、文件名）,电话号码,身份证号,姓名,日期
* @see YES ANALYZED 文档标题和摘要
* @see NO ANALYZED 文档正文
* @see NO NOT_ANALYZED 隐藏关键字
* @see YES NO 文档类型,数据库主键（不进行索引）
* @see -------------------------------------------------------------------------------------------------------------
* @create Jun 29, 2012 4:20:19 PM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class Lucene_01_HelloWord {
private static final String PATH_OF_FILE = "E:/lucene_test/01_file/"; // 待索引文件的目录
private static final String PATH_OF_INDEX = "E:/lucene_test/01_index/"; // 存放索引文件的目录2 /**
* 测试时，要在E:/lucene_test/01_file/文件夹中准备几个包含内容的文件（比如txt格式的）
* 然后先执行createIndex()方法，再执行searchFile()方法，最后观看控制台输出即可
*/
public static void main(String[] args) {
Lucene_01_HelloWord instance = new Lucene_01_HelloWord();
instance.createIndex();
instance.searchFile();
} /**
* 创建索引
*
* @see ---------------------------------------------------------------------------------------------------------
* @see 1、创建Directory-----------------指定索引被保存的位置
* @see 2、创建IndexWriter---------------通过IndexWriter写索引
* @see 3、创建Document对象---------------我们索引的有可能是一段文本or数据库中的一张表
* @see 4、为Document添加Field------------相当于Document的标题、大小、内容、路径等等,二者类似于数据库表中每条记录和字段的关系
* @see 5、通过IndexWriter添加文档到索引中
* @see 6、关闭IndexWriter----------------用完IndexWriter之后,必须关闭之
* @see ---------------------------------------------------------------------------------------------------------
* @see _0.fdt和_0.fdx文件--保存域中所存储的数据(Field.Store.YES条件下的)
* @see _0.fnm文件----------保存域选项的数据(即new Field(name, value)中的name)
* @see _0.frq文件----------记录相同的文件(或查询的关键字)出现的次数,它是用来做评分和排序的
* @see _0.nrm文件----------存储一些评分信息
* @see _0.prx文件----------记录偏移量
* @see _0.tii和_0.tis文件--存储索引里面的所有内容信息
* @see segments_1文件------它是段文件,Lucene首先会到段文件中查找相应的索引信息
* @see ---------------------------------------------------------------------------------------------------------
*/
private void createIndex() {
Directory directory = null;
IndexWriter writer = null;
Document doc = null;
try {
// FSDirectory会根据当前的运行环境打开一个合理的基于File的Directory(若在内存中创建索引则new RAMDirectory())
// 这里是在硬盘上"E:/lucene_test/01_index/"文件夹中创建索引
directory = FSDirectory.open(new File(PATH_OF_INDEX));
// 由于Lucene2.9之后,其索引的格式就不会再兼容Lucene的所有版本了,所以在创建索引前,要指定其所匹配的Lucene版本号
// 这里通过IndexWriterConfig()构造方法的Version.LUCENE_36参数值指明索引所匹配的版本号,并使用了Lucene的标准分词器
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
for (File file : new File(PATH_OF_FILE).listFiles()) {
doc = new Document();
// 把内容添加到索引域中,即为该文档存储信息,供将来搜索时使用(下面的写法,其默认为Field.Store.NO和Field.Index.ANALYZED)
// 如果我们想把content的内容也存储到硬盘上,那就需要先把file转换成字符串,然后按照"fileName"的存储方式加到Field中
// 我们可以用commons-io-2.3.jar提供的FileUtils.readFileToString(file),这是很方便的工具包,有了它几乎都不用手写任何的IO方法了
// doc.add(new Field("content", FileUtils.readFileToString(file), Field.Store.YES, Field.Index.ANALYZED));
doc.add(new Field("content", new FileReader(file)));
// Field.Store.YES-----------这里是将文件的全名存储到硬盘中
// Field.Index.NOT_ANALYZED--这里是不对文件名进行分词
doc.add(new Field("fileName", file.getName(), Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("filePath", file.getAbsolutePath(), Field.Store.YES, Field.Index.NOT_ANALYZED));
// 通过IndexWriter添加文档到索引中
writer.addDocument(doc);
}
}
catch (Exception e) {
System.out.println("创建索引的过程中遇到异常,堆栈轨迹如下");
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close(); // IndexWriter在用完之后一定要关闭
}
catch (IOException ce) {
System.out.println("关闭IndexWriter时遇到异常,堆栈轨迹如下");
ce.printStackTrace();
}
}
}
} private String getContentFromFile(File myFile) {
StringBuffer sb = new StringBuffer();
if (!myFile.exists()) {
return "";
}
try {
BufferedReader in = new BufferedReader(new FileReader(myFile));
String str;
while ((str = in.readLine()) != null) {
sb.append(str);
}
in.close();
}
catch (IOException e) {
e.getStackTrace();
}
return sb.toString();
} /**
* 搜索文件
*
* @see 1、创建Directory
* @see 2、创建IndexReader
* @see 3、根据IndexReader创建IndexSearcher
* @see 4、创建搜索的Query
* @see 5、根据searcher搜索并返回TopDocs
* @see 6、根据TopDocs获取ScoreDoc对象
* @see 7、根据searcher和ScoreDoc对象获取具体的Document对象
* @see 8、根据Document对象获取需要的值
* @see 9、关闭IndexReader
*/
private void searchFile() {
IndexReader reader = null;
try {
reader = IndexReader.open(FSDirectory.open(new File(PATH_OF_INDEX)));
IndexSearcher searcher = new IndexSearcher(reader);
// 创建基于Parser搜索的Query,创建时需指定其"搜索的版本,默认搜索的域,分词器"....这里的域指的是创建索引时Field的名字
QueryParser parser = new QueryParser(Version.LUCENE_36, "content", new StandardAnalyzer(Version.LUCENE_36));
Query query = parser.parse("java"); // 指定==>搜索域为content(即上一行代码指定的"content")中包含"java"的文档
TopDocs tds = searcher.search(query, 10); // 第二个参数指定搜索后显示的条数,若查到5条则显示为5条,查到15条则只显示10条
ScoreDoc[] sds = tds.scoreDocs; // TopDocs中存放的并不是我们的文档,而是文档的ScoreDoc对象
for (ScoreDoc sd : sds) { // ScoreDoc对象相当于每个文档的ID号,我们就可以通过ScoreDoc来遍历文档
Document doc = searcher.doc(sd.doc); // sd.doc得到的是文档的序号
System.out.println(doc.get("fileName") + "[" + doc.get("filePath") + "]"); // 输出该文档所存储的信息
}
}
catch (Exception e) {
System.out.println("搜索文件的过程中遇到异常,堆栈轨迹如下");
e.printStackTrace();
}
finally {
if (null != reader) {
try {
reader.close();
}
catch (IOException e) {
System.out.println("关闭IndexReader时遇到异常,堆栈轨迹如下");
e.printStackTrace();
}
}
}
} }
2.针对索引文件的CRUD
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date; import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version; public class Lucene_02_HelloIndex {
/**
* 【Lucene3.6.2入门系列】第02节_针对索引文件的CRUD
*
* @see =============================================================================================================
* @see Lucene官网:http://lucene.apache.org
* @see Lucene下载:http://archive.apache.org/dist/lucene/java/
* @see Lucene文档:http://wiki.apache.org/lucene-java/
* @see =============================================================================================================
* @see 使用Luke查看分词信息(http://code.google.com/p/luke/)
* @see 1)引言:每一个Lucene版本都会有一个相应的Luke文件
* @see 2)打开:双击或java -jar lukeall-3.5.0.jar
* @see 3)选择索引的存放目录后点击OK即可
* @see 7)如果我们的索引有改变,可以点击右侧的Re-open按钮重新载入索引
* @see 4)Luke界面右下角的Top ranking terms窗口中显示的就是分词信息。其中Rank列表示出现频率
* @see 5)Luke菜单下的Documents选项卡中显示的就是文档信息,我们可以根据文档序号来浏览(点击向左和向右的方向箭头)
* @see 6)Luke菜单下的Search选项卡中可以根据我们输入的表达式来查文档内容
* @see 比如在Enter search expression here:输入content:my,再在右侧点击一个黑色粗体字的Search大按钮即可
* @see =============================================================================================================
* @create Jun 30, 2012 4:34:09 PM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
/*
* 定义一组数据,用来演示搜索(这里有一封邮件为例)
* 假设每一个变量代表一个Document,这里就定义了6个Document
*/
// 邮件编号
private String[] ids = { "1", "2", "3", "4", "5", "6" };
// 邮件主题
private String[] names = { "Michael", "Scofield", "Tbag", "Jack", "Jade", "Jadyer" };
// 邮件地址
private String[] emails = { "aa@jadyer.us", "bb@jadyer.cn", "cc@jadyer.cc", "dd@jadyer.tw", "ee@jadyer.hk", "ff@jadyer.me" };
// 邮件内容
private String[] contents = { "my blog", "my website", "my name", "I am JavaDeveloper", "I am from Haerbin", "I like Lucene" };
// 邮件附件(为数字和日期加索引,与,字符串加索引的方式不同)
private int[] attachs = { 9, 3, 5, 4, 1, 2 };
// 邮件日期
private Date[] dates = new Date[ids.length];
// 它的创建是比较耗时耗资源的,所以这里只让它创建一次,此时reader处于整个生命周期中,实际应用中也可能直接放到ApplicationContext里面
private static IndexReader reader = null;
private Directory directory = null; public static void main(String[] args) {
Lucene_02_HelloIndex instance = new Lucene_02_HelloIndex();
instance.createIndex();
instance.searchFile();
instance.updateIndex();
instance.getDocsCount();
} public Lucene_02_HelloIndex() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
try {
dates[0] = (Date) sdf.parse("20120601");
dates[1] = (Date) sdf.parse("20120603");
dates[2] = (Date) sdf.parse("20120605");
dates[3] = (Date) sdf.parse("20120607");
dates[4] = (Date) sdf.parse("20120609");
dates[5] = (Date) sdf.parse("20120611");
directory = FSDirectory.open(new File("E:/lucene_test/01_index/"));
}
catch (Exception e) {
e.printStackTrace();
}
} /**
* 获取IndexReader实例
*/
private IndexReader getIndexReader() {
try {
if (reader == null) {
reader = IndexReader.open(directory);
}
else {
// if the index was changed since the provided reader was opened, open and return a new reader; else,return null
// 如果当前reader在打开期间index发生改变,则打开并返回一个新的IndexReader,否则返回null
IndexReader ir = IndexReader.openIfChanged(reader);
if (ir != null) {
reader.close(); // 关闭原reader
reader = ir; // 赋予新reader
}
}
return reader;
}
catch (Exception e) {
e.printStackTrace();
}
return null; // 发生异常则返回null
} /**
* 通过IndexReader获取文档数量
*/
public void getDocsCount() {
System.out.println("maxDocs:" + this.getIndexReader().maxDoc());
System.out.println("numDocs:" + this.getIndexReader().numDocs());
System.out.println("deletedDocs:" + this.getIndexReader().numDeletedDocs());
} /**
* 创建索引
*/
public void createIndex() {
IndexWriter writer = null;
Document doc = null;
try {
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
writer.deleteAll(); // 创建索引之前,先把文档清空掉
for (int i = 0; i < ids.length; i++) { // 遍历ID来创建文档
doc = new Document();
doc.add(new Field("id", ids[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("name", names[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("email", emails[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("content", contents[i], Field.Store.NO, Field.Index.ANALYZED));
doc.add(new NumericField("attach", Field.Store.YES, true).setIntValue(attachs[i])); // 为数字加索引(第三个参数指定是否索引)
doc.add(new NumericField("date", Field.Store.YES, true).setLongValue(dates[i].getTime())); // 为日期加索引
/*
* 建立索引时加权
* 定义排名规则,即加权,这里是为指定邮件名结尾的emails加权
*/
if (emails[i].endsWith("jadyer.cn")) {
doc.setBoost(2.0f);
}
else if (emails[i].endsWith("jadyer.me")) {
doc.setBoost(1.5f); // 为文档加权....默认为1.0,权值越高则排名越高,显示得就越靠前
}
else {
doc.setBoost(0.5f); // 注意它的参数类型是Float
}
writer.addDocument(doc);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 搜索文件
*/
public void searchFile() {
IndexSearcher searcher = new IndexSearcher(this.getIndexReader());
Query query = new TermQuery(new Term("content", "my")); // 精确搜索:搜索"content"中包含"my"的文档
try {
TopDocs tds = searcher.search(query, 10);
for (ScoreDoc sd : tds.scoreDocs) {
Document doc = searcher.doc(sd.doc); // sd.doc得到的是文档的序号
// doc.getBoost()得到的权值与创建索引时设置的权值之间是不相搭的,创建索引时的权值的查看需要使用Luke工具
// 之所以这样,是因为这里的Document对象(是获取到的)与创建索引时的Document对象,不是同一个对象
// sd.score得到的是该文档的评分,该评分规则的公式是比较复杂的,它主要与文档的权值和出现次数成正比
System.out.print("(" + sd.doc + "|" + doc.getBoost() + "|" + sd.score + ")" + doc.get("name") + "[" + doc.get("email") + "]-->");
System.out.println(doc.get("id") + "," + doc.get("attach") + "," + new SimpleDateFormat("yyyyMMdd").format(new Date(Long.parseLong(doc.get("date")))));
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != searcher) {
try {
searcher.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 更新索引
*
* @see Lucene其实并未提供更新索引的方法,这里的更新操作内部是先删除再添加的方式
* @see 因为Lucene认为更新索引的代价,与删除后重建索引的代价,二者是差不多的
*/
public void updateIndex() {
IndexWriter writer = null;
Document doc = new Document();
try {
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
doc.add(new Field("id", "1111", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("name", names[0], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("email", emails[0], Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("content", contents[0], Field.Store.NO, Field.Index.ANALYZED));
doc.add(new NumericField("attach", Field.Store.YES, true).setIntValue(attachs[0]));
doc.add(new NumericField("date", Field.Store.YES, true).setLongValue(dates[0].getTime()));
// 其实它会先删除索引文档中id为1的文档,然后再将这里的doc对象重新索引,所以即便这里的1!=1111,但它并不会报错
// 所以在执行完该方法后:maxDocs=7,numDocs=6,deletedDocs=1,就是因为Lucene会先删除再添加
writer.updateDocument(new Term("id", "1"), doc);
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 删除索引
*
* @see -----------------------------------------------------------------------------------------------------
* @see 在执行完该方法后,再执行本类的searchFile()方法,得知numDocs=5,maxDocs=6,deletedDocs=1
* @see 这说明此时删除的文档并没有被完全删除,而是存储在一个回收站中,它是可以恢复的
* @see -----------------------------------------------------------------------------------------------------
* @see 从回收站中清空索引IndexWriter
* @see 对于清空索引,Lucene3.5之前叫做优化,调用的是IndexWriter.optimize()方法,但该方法已被禁用
* @see 因为optimize时它会全部更新索引,这一过程所涉及到的负载是很大的,于是弃用了该方法,使用forceMerge代替
* @see 使用IndexWriter.forceMergeDeletes()方法可以强制清空回收站中的内容
* @see 另外IndexWriter.forceMerge(3)方法会将索引合并为3段,这3段中的被删除的数据也会被清空
* @see 但其在Lucene3.5之后不建议使用,因为其会消耗大量的开销,而Lucene会根据情况自动处理的
* @see -----------------------------------------------------------------------------------------------------
*/
public void deleteIndex() {
IndexWriter writer = null;
try {
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
// 其参数可以传Query或Term....Query指的是可以查询出一系列的结果并将其全部删掉,而Term属于精确查找
writer.deleteDocuments(new Term("id", "1")); // 删除索引文档中id为1的文档
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 恢复索引
*
* @see 建议弃用
*/
@Deprecated
public void unDeleteIndex() {
IndexReader reader = null;
try {
// IndexReader.open(directory)此时该IndexReader默认的readOnly=true,而在恢复索引时应该指定其为非只读的
reader = IndexReader.open(directory, false);
// Deprecated. Write support will be removed in Lucene 4.0. There will be no replacement for this method.
reader.undeleteAll();
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != reader) {
try {
reader.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3.简述Lucene中常见的搜索功能
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date; import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.FuzzyQuery;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.NumericRangeQuery;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.PrefixQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TermRangeQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version; /**
* 【Lucene3.6.2入门系列】第03节_简述Lucene中常见的搜索功能
*
* @create Aug 1, 2013 3:54:27 PM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class Lucene_03_HelloSearch {
private Directory directory;
private IndexReader reader;
private String[] ids = { "1", "2", "3", "4", "5", "6" };
private String[] names = { "Michael", "Scofield", "Tbag", "Jack", "Jade", "Jadyer" };
private String[] emails = { "aa@jadyer.us", "bb@jadyer.cn", "cc@jadyer.cc", "dd@jadyer.tw", "ee@jadyer.hk", "ff@jadyer.me" };
private String[] contents = { "my java blog is http://blog.csdn.net/jadyer", "my website is http://www.jadyer.cn", "my name is jadyer", "I am JavaDeveloper", "I am from Haerbin", "I like Lucene" };
private int[] attachs = { 9, 3, 5, 4, 1, 2 };
private Date[] dates = new Date[ids.length]; static Lucene_03_HelloSearch instance = new Lucene_03_HelloSearch(); public static void main(String[] args) {
instance.searchByTerm("content", "my");
instance.searchByTermRange("name", "M", "o");// 范围，M~O
instance.searchByNumericRange("attach", 2, 5);
instance.searchByPrefix("content", "b");
instance.searchByWildcard("name", "Ja??er");
instance.searchByFuzzy("name", "Jadk");
instance.searchByPhrase();
instance.searchByQueryParse();
instance.searchPage();
instance.searchPageByAfter();
} public void searchPage() {
for (File file : new File("E:/lucene_test/01_index/").listFiles()) {
file.delete();
}
instance = new Lucene_03_HelloSearch(true);
instance.searchPage("mycontent:javase", 2, 10);
} public void searchPageByAfter() {
for (File file : new File("E:/lucene_test/01_index/").listFiles()) {
file.delete();
}
instance = new Lucene_03_HelloSearch(true);
instance.searchPageByAfter("mycontent:javase", 3, 10);
} public Lucene_03_HelloSearch() {
IndexWriter writer = null;
Document doc = null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
try {
dates[0] = sdf.parse("20120601");
dates[1] = sdf.parse("20120603");
dates[2] = sdf.parse("20120605");
dates[3] = sdf.parse("20120607");
dates[4] = sdf.parse("20120609");
dates[5] = sdf.parse("20120611");
directory = FSDirectory.open(new File("E:/lucene_test/01_index/"));
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
writer.deleteAll(); // 创建索引之前,先把文档清空掉
for (int i = 0; i < ids.length; i++) { // 遍历ID来创建文档
doc = new Document();
doc.add(new Field("id", ids[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("name", names[i], Field.Store.YES, Field.Index.ANALYZED_NO_NORMS));
doc.add(new Field("email", emails[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("email", "test" + i + "" + i + "@jadyer.com", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.add(new Field("content", contents[i], Field.Store.YES, Field.Index.ANALYZED));
doc.add(new NumericField("attach", Field.Store.YES, true).setIntValue(attachs[i])); // 为数字加索引(第三个参数指定是否索引)
doc.add(new NumericField("attach", Field.Store.YES, true).setIntValue((i + 1) * 100)); // 假设有多个附件
doc.add(new NumericField("date", Field.Store.YES, true).setLongValue(dates[i].getTime())); // 为日期加索引
writer.addDocument(doc);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 针对分页搜索创建索引
*/
public Lucene_03_HelloSearch(boolean pageFlag) {
String[] myNames = new String[50];
String[] myContents = new String[50];
for (int i = 0; i < 50; i++) {
myNames[i] = "file(" + i + ")";
myContents[i] = "I love JavaSE, also love Lucene(" + i + ")";
}
IndexWriter writer = null;
Document doc = null;
try {
directory = FSDirectory.open(new File("E:/lucene_test/01_index/"));
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
writer.deleteAll();
for (int i = 0; i < myNames.length; i++) {
doc = new Document();
doc.add(new Field("myname", myNames[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("mycontent", myContents[i], Field.Store.YES, Field.Index.ANALYZED));
writer.addDocument(doc);
}
}
catch (IOException e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 获取IndexSearcher实例
*/
private IndexSearcher getIndexSearcher() {
try {
if (reader == null) {
reader = IndexReader.open(directory);
}
else {
// if the index was changed since the provided reader was opened, open and return a new reader; else,return null
// 如果当前reader在打开期间index发生改变,则打开并返回一个新的IndexReader,否则返回null
IndexReader ir = IndexReader.openIfChanged(reader);
if (ir != null) {
reader.close(); // 关闭原reader
reader = ir; // 赋予新reader
}
}
return new IndexSearcher(reader);
}
catch (Exception e) {
e.printStackTrace();
}
return null; // 发生异常则返回null
} /**
* 执行搜索操作
*
* @param query
* (搜索的Query对象)
*/
private void doSearch(Query query) {
IndexSearcher searcher = this.getIndexSearcher();
try {
// 第二个参数指定搜索后显示的最多的记录数,其与tds.totalHits没有联系
TopDocs tds = searcher.search(query, 10);
System.out.println("本次搜索到[" + tds.totalHits + "]条记录");
for (ScoreDoc sd : tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
System.out.println("content =" + doc.get("content") + " ");
System.out.print("文档编号=" + sd.doc + " 文档权值=" + doc.getBoost() + " 文档评分=" + sd.score + " ");
System.out.print("id=" + doc.get("id") + " email=" + doc.get("email") + " name=" + doc.get("name") + " ");
// 获取多个同名域的方式
String[] attachValues = doc.getValues("attach");
for (String attach : attachValues) {
System.out.print("attach=" + attach + " ");
}
System.out.println();
}
}
catch (IOException e) {
e.printStackTrace();
}
finally {
if (null != searcher) {
try {
searcher.close(); // 记得关闭IndexSearcher
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 精确匹配搜索
*
* @param fieldName
* 域名(相当于表的字段名)
* @param keyWords
* 搜索的关键字
*/
public void searchByTerm(String fieldName, String keyWords) {
Query query = new TermQuery(new Term(fieldName, keyWords));
this.doSearch(query);
} /**
* 基于范围的搜索
*
* @param fieldName
* 域名(相当于表的字段名)
* @param start
* 开始字符
* @param end
* 结束字符
*/
public void searchByTermRange(String fieldName, String start, String end) {
Query query = new TermRangeQuery(fieldName, start, end, true, true); // 后面两个参数用于指定开区间或闭区间
this.doSearch(query);
} /**
* 针对数字的搜索
*/
public void searchByNumericRange(String fieldName, int min, int max) {
Query query = NumericRangeQuery.newIntRange(fieldName, min, max, true, true);
this.doSearch(query);
} /**
* 基于前缀的搜索
*
* @see 它是对Field分词后的结果进行前缀查找的结果
*/
public void searchByPrefix(String fieldName, String prefix) {
Query query = new PrefixQuery(new Term(fieldName, prefix));
this.doSearch(query);
} /**
* 基于通配符的搜索
*
* @see *-->任意多个字符
* @see ?-->一个字符
*/
public void searchByWildcard(String fieldName, String wildcard) {
Query query = new WildcardQuery(new Term(fieldName, wildcard));
this.doSearch(query);
} /**
* 模糊搜索
*
* @see 与通配符搜索不同
*/
public void searchByFuzzy(String fieldName, String fuzzy) {
Query query = new FuzzyQuery(new Term(fieldName, fuzzy));
this.doSearch(query);
} /**
* 多条件搜索
*
* @see 本例中搜索name值中以Ja开头,且content中包含am的内容
* @see Occur.MUST------表示此条件必须为true
* @see Occur.MUST_NOT--表示此条件必须为false
* @see Occur.SHOULD----表示此条件非必须
*/
public void searchByBoolean() {
BooleanQuery query = new BooleanQuery();
query.add(new WildcardQuery(new Term("name", "Ja*")), Occur.MUST);
query.add(new TermQuery(new Term("content", "am")), Occur.MUST);
this.doSearch(query);
} /**
* 短语搜索
*
* @see 很遗憾的是短语查询对中文搜索没有太大的作用,但对英文搜索是很好用的,但它的开销比较大,尽量少用
*/
public void searchByPhrase() {
PhraseQuery query = new PhraseQuery();
query.setSlop(1); // 设置跳数
query.add(new Term("content", "am")); // 第一个Term
query.add(new Term("content", "Haerbin")); // 产生距离之后的第二个Term
this.doSearch(query);
} /**
* 基于QueryParser的搜索
*/
public void searchByQueryParse() {
QueryParser parser = new QueryParser(Version.LUCENE_36, "content", new StandardAnalyzer(Version.LUCENE_36));
Query query = null;
try {
// query = parser.parse("Haerbin"); //搜索content中包含[Haerbin]的记录
// query = parser.parse("I AND Haerbin"); //搜索content中包含[I]和[Haerbin]的记录
// query = parser.parse("Lucene OR Haerbin"); //搜索content中包含[Lucene]或者[Haerbin]的记录
// query = parser.parse("Lucene Haerbin"); //搜索content中包含[Lucene]或者[Haerbin]的记录
// parser.setDefaultOperator(Operator.AND); //将空格的默认操作OR修改为AND
// //1)如果name域在索引时,不进行分词,那么无论这里写成[name:Jadyer]还是[name:jadyer],最后得到的都是0条记录
// //2)由于name原值为大写[J],若索引时不对name分词,除非修改name原值为小写[j],并且搜索[name:jadyer]才能得到记录
// query = parser.parse("name:Jadyer"); //修改搜索域为name=Jadyer的记录
// query = parser.parse("name:Ja*"); //支持通配符
// query = parser.parse("\"I am\""); //搜索content中包含[I am]的记录(注意不能使用parse("content:'I am'"))
// parser.setAllowLeadingWildcard(true); //设置允许[*]或[?]出现在查询字符的第一位,即[name:*de],否则[name:*de]会报异常
// query = parser.parse("name:*de"); //Lucene默认的第一个字符不允许为通配符,因为这样效率比较低
// //parse("+am +name:Jade")--------------搜索content中包括[am]的,并且name=Jade的记录
// //parse("am AND NOT name:Jade")--------搜索content中包括[am]的,并且nam不是Jade的记录
// //parse("(blog OR am) AND name:Jade")--搜索content中包括[blog]或者[am]的,并且name=Jade的记录
// query = parser.parse("-name:Jack +I"); //搜索content中包括[I]的,并且name不是Jack的记录(加减号要放到域说明的前面)
// query = parser.parse("id:[1 TO 3]"); //搜索id值从1到3的记录(TO必须大写,且这种方式没有办法匹配数字)
// query = parser.parse("id:{1 TO 3}"); //搜索id=2的记录
query = parser.parse("name:Jadk~"); // 模糊搜索
}
catch (ParseException e) {
e.printStackTrace();
}
this.doSearch(query);
} /**
* 普通的分页搜索
*
* @see 适用于lucene3.5之前
* @param expr
* 搜索表达式
* @param pageIndex
* 页码
* @param pageSize
* 分页大小
*/
public void searchPage(String expr, int pageIndex, int pageSize) {
IndexSearcher searcher = this.getIndexSearcher();
QueryParser parser = new QueryParser(Version.LUCENE_36, "mycontent", new StandardAnalyzer(Version.LUCENE_36));
try {
Query query = parser.parse(expr);
TopDocs tds = searcher.search(query, pageIndex * pageSize);
ScoreDoc[] sds = tds.scoreDocs;
for (int i = (pageIndex - 1) * pageSize; i < pageIndex * pageSize; i++) {
Document doc = searcher.doc(sds[i].doc);
System.out.println("文档编号:" + sds[i].doc + "-->" + doc.get("myname") + "-->" + doc.get("mycontent"));
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != searcher) {
try {
searcher.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 基于searchAfter的分页搜索
*
* @see 适用于Lucene3.5
* @param expr
* 搜索表达式
* @param pageIndex
* 页码
* @param pageSize
* 分页大小
*/
public void searchPageByAfter(String expr, int pageIndex, int pageSize) {
IndexSearcher searcher = this.getIndexSearcher();
QueryParser parser = new QueryParser(Version.LUCENE_36, "mycontent", new StandardAnalyzer(Version.LUCENE_36));
try {
Query query = parser.parse(expr);
TopDocs tds = searcher.search(query, (pageIndex - 1) * pageSize);
// 使用IndexSearcher.searchAfter()搜索,该方法第一个参数为上一页记录中的最后一条记录
if (pageIndex > 1) {
tds = searcher.searchAfter(tds.scoreDocs[(pageIndex - 1) * pageSize - 1], query, pageSize);
}
else {
tds = searcher.searchAfter(null, query, pageSize);
}
for (ScoreDoc sd : tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
System.out.println("文档编号:" + sd.doc + "-->" + doc.get("myname") + "-->" + doc.get("mycontent"));
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != searcher) {
try {
searcher.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
4.中文分词器
import java.io.IOException;
import java.io.StringReader; import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.analysis.StopAnalyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
import org.apache.lucene.analysis.tokenattributes.TypeAttribute;
import org.apache.lucene.util.Version; import com.chenlb.mmseg4j.analysis.ComplexAnalyzer;
import com.chenlb.mmseg4j.analysis.MMSegAnalyzer; /**
* 【Lucene3.6.2入门系列】第04节_中文分词器
*
* @see -----------------------------------------------------------------------------------------------------------------------
* @see Lucene3.5推荐的四大分词器:SimpleAnalyzer,StopAnalyzer,WhitespaceAnalyzer,StandardAnalyzer
* @see 这四大分词器有一个共同的抽象父类,此类有个方法public final TokenStream tokenStream(),即分词的一个流
* @see 假设有这样的文本"how are you thank you",实际它是以一个java.io.Reader传进分词器中
* @see Lucene分词器处理完毕后,会把整个分词转换为TokenStream,这个TokenStream中就保存所有的分词信息
* @see TokenStream有两个实现类,分别为Tokenizer和TokenFilter
* @see Tokenizer---->用于将一组数据划分为独立的语汇单元(即一个一个的单词)
* @see TokenFilter-->过滤语汇单元
* @see -----------------------------------------------------------------------------------------------------------------------
* @see 分词流程
* @see 1)将一组数据流java.io.Reader交给Tokenizer,由其将数据转换为一个个的语汇单元
* @see 2)通过大量的TokenFilter对已经分好词的数据进行过滤操作,最后产生TokenStream
* @see 3)通过TokenStream完成索引的存储
* @see -----------------------------------------------------------------------------------------------------------------------
* @see Tokenizer的一些子类
* @see KeywordTokenizer-----不分词,传什么就索引什么
* @see StandardTokenizer----标准分词,它有一些较智能的分词操作,诸如将'jadyer@yeah.net'中的'yeah.net'当作一个分词流
* @see CharTokenizer--------针对字符进行控制的,它还有两个子类WhitespaceTokenizer和LetterTokenizer
* @see WhitespaceTokenizer--使用空格进行分词,诸如将'Thank you,I am jadyer'会被分为4个词
* @see LetterTokenizer------基于文本单词的分词,它会根据标点符号来分词,诸如将'Thank you,I am jadyer'会被分为5个词
* @see LowerCaseTokenizer---它是LetterTokenizer的子类,它会将数据转为小写并分词
* @see -----------------------------------------------------------------------------------------------------------------------
* @see TokenFilter的一些子类
* @see StopFilter--------它会停用一些语汇单元
* @see LowerCaseFilter---将数据转换为小写
* @see StandardFilter----对标准输出流做一些控制
* @see PorterStemFilter--还原一些数据,比如将coming还原为come,将countries还原为country
* @see -----------------------------------------------------------------------------------------------------------------------
* @see eg:'how are you thank you'会被分词为'how','are','you','thank','you'合计5个语汇单元
* @see 那么应该保存什么东西,才能使以后在需要还原数据时保证正确的还原呢???其实主要保存三个东西,如下所示
* @see CharTermAttribute(Lucene3.5以前叫TermAttribute),OffsetAttribute,PositionIncrementAttribute
* @see 1)CharTermAttribute-----------保存相应的词汇,这里保存的就是'how','are','you','thank','you'
* @see 2)OffsetAttribute-------------保存各词汇之间的偏移量(大致理解为顺序),比如'how'的首尾字母偏移量为0和3,'are'为4和7,'thank'为12和17
* @see 3)PositionIncrementAttribute--保存词与词之间的位置增量,比如'how'和'are'增量为1,'are'和'you'之间的也是1,'you'和'thank'的也是1
* @see 但假设'are'是停用词(StopFilter的效果),那么'how'和'you'之间的位置增量就变成了2
* @see 当我们查找某一个元素时,Lucene会先通过位置增量来取这个元素,但如果两个词的位置增量相同,会发生什么情况呢
* @see 假设还有一个单词'this',它的位置增量和'how'是相同的,那么当我们在界面中搜索'this'时
* @see 也会搜到'how are you thank you',这样就可以有效的做同义词了,目前非常流行的一个叫做WordNet的东西,就可以做同义词的搜索
* @see -----------------------------------------------------------------------------------------------------------------------
* @see 中文分词器
* @see Lucene默认提供的众多分词器完全不适用中文
* @see 1)Paoding--庖丁解牛分词器,官网为http://code.google.com/p/paoding(貌似已托管在http://git.oschina.net/zhzhenqin/paoding-analysis)
* @see 2)MMSeg4j--据说它使用的是搜狗的词库,官网为https://code.google.com/p/mmseg4j(另外还有一个https://code.google.com/p/jcseg)
* @ses 3)IK-------https://code.google.com/p/ik-analyzer/
* @see -----------------------------------------------------------------------------------------------------------------------
* @see MMSeg4j的使用
* @see 1)下载mmseg4j-1.8.5.zip并引入mmseg4j-all-1.8.5-with-dic.jar
* @see 2)在需要指定分词器的位置编写new MMSegAnalyzer()即可
* @see 注1)由于使用的mmseg4j-all-1.8.5-with-dic.jar中已自带了词典,故直接new MMSegAnalyzer()即可
* @see 注2)若引入的是mmseg4j-all-1.8.5.jar,则应指明词典目录,如new MMSegAnalyzer("D:\\Develop\\mmseg4j-1.8.5\\data")
* @see 但若非要使用new MMSegAnalyzer(),则要将mmseg4j-1.8.5.zip自带的data目录拷入classpath下即可
* @see 总结:直接引入mmseg4j-all-1.8.5-with-dic.jar就行了
* @see -----------------------------------------------------------------------------------------------------------------------
* @create Aug 2, 2013 5:30:45 PM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class Lucene_04_HelloChineseAnalyzer {
/**
* 查看分词信息
*
* @see TokenStream还有两个属性,分别为FlagsAttribute和PayloadAttribute,都是开发时用的
* @see FlagsAttribute----标注位属性
* @see PayloadAttribute--做负载的属性,用来检测是否已超过负载,超过则可以决定是否停止搜索等等
* @param txt
* 待分词的字符串
* @param analyzer
* 所使用的分词器
* @param displayAll
* 是否显示所有的分词信息
*/
public static void displayTokenInfo(String txt, Analyzer analyzer, boolean displayAll) {
// 第一个参数没有任何意义,可以随便传一个值,它只是为了显示分词
// 这里就是使用指定的分词器将'txt'分词,分词后会产生一个TokenStream(可将分词后的每个单词理解为一个Token)
TokenStream stream = analyzer.tokenStream("此参数无意义", new StringReader(txt));
// 用于查看每一个语汇单元的信息,即分词的每一个元素
// 这里创建的属性会被添加到TokenStream流中,并随着TokenStream而增加(此属性就是用来装载每个Token的,即分词后的每个单词)
// 当调用TokenStream.incrementToken()时,就会指向到这个单词流中的第一个单词,即此属性代表的就是分词后的第一个单词
// 可以形象的理解成一只碗,用来盛放TokenStream中每个单词的碗,每调用一次incrementToken()后,这个碗就会盛放流中的下一个单词
CharTermAttribute cta = stream.addAttribute(CharTermAttribute.class);
// 用于查看位置增量(指的是语汇单元之间的距离,可理解为元素与元素之间的空格,即间隔的单元数)
PositionIncrementAttribute pia = stream.addAttribute(PositionIncrementAttribute.class);
// 用于查看每个语汇单元的偏移量
OffsetAttribute oa = stream.addAttribute(OffsetAttribute.class);
// 用于查看使用的分词器的类型信息
TypeAttribute ta = stream.addAttribute(TypeAttribute.class);
try {
if (displayAll) {
// 等价于while(stream.incrementToken())
for (; stream.incrementToken();) {
System.out.println(ta.type() + " " + pia.getPositionIncrement() + " [" + oa.startOffset() + "-" + oa.endOffset() + "] [" + cta + "]");
}
}
else {
System.out.println();
while (stream.incrementToken()) {
System.out.print("[" + cta + "]");
}
}
}
catch (IOException e) {
e.printStackTrace();
}
} /**
* 测试一下中文分词的效果
*/
public static void main(String[] args) {
String txt = "测试一下中文分词的效果";
// displayTokenInfo(txt, new StandardAnalyzer(Version.LUCENE_36), false);
// displayTokenInfo(txt, new StopAnalyzer(Version.LUCENE_36), false);
// displayTokenInfo(txt, new SimpleAnalyzer(Version.LUCENE_36), false);
// displayTokenInfo(txt, new WhitespaceAnalyzer(Version.LUCENE_36), false);
displayTokenInfo(txt, new MMSegAnalyzer(), true);
// displayTokenInfo(txt, new SimpleAnalyzer(), false);
// displayTokenInfo(txt, new ComplexAnalyzer(), false);
}
}
5.高级搜索之排序
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date; import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version; /**
* 【Lucene3.6.2入门系列】第06节_高级搜索之排序
*
* @create Aug 19, 2013 10:38:19 AM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class Lucene_05_AdvancedSearchBySort {
private Directory directory;
private IndexReader reader; public Lucene_05_AdvancedSearchBySort() {
/** 文件大小 */
int[] sizes = { 90, 10, 20, 10, 60, 50 };
/** 文件名 */
String[] names = { "Michael.java", "Scofield.ini", "Tbag.txt", "Jack", "Jade", "Jadyer" };
/** 文件内容 */
String[] contents = { "my java blog is http://blog.csdn.net/jadyer", "my Java Website is http://www.jadyer.cn", "my name is jadyer", "I am a Java Developer", "I am from Haerbin", "I like java of Lucene" };
/** 文件日期 */
Date[] dates = new Date[sizes.length];
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd HH:mm:ss");
IndexWriter writer = null;
Document doc = null;
try {
dates[0] = sdf.parse("20130407 15:25:30");
dates[1] = sdf.parse("20130407 16:30:45");
dates[2] = sdf.parse("20130213 11:15:25");
dates[3] = sdf.parse("20130808 09:30:55");
dates[4] = sdf.parse("20130526 13:54:22");
dates[5] = sdf.parse("20130701 17:35:34");
directory = FSDirectory.open(new File("E:/lucene_test/01_index/"));
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
writer.deleteAll();
for (int i = 0; i < sizes.length; i++) {
doc = new Document();
doc.add(new NumericField("size", Field.Store.YES, true).setIntValue(sizes[i]));
doc.add(new Field("name", names[i], Field.Store.YES, Field.Index.ANALYZED_NO_NORMS));
doc.add(new Field("content", contents[i], Field.Store.YES, Field.Index.ANALYZED));
doc.add(new NumericField("date", Field.Store.YES, true).setLongValue(dates[i].getTime()));
writer.addDocument(doc);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 获取IndexReader实例
*/
private IndexReader getIndexReader() {
try {
if (reader == null) {
reader = IndexReader.open(directory);
}
else {
// if the index was changed since the provided reader was opened, open and return a new reader; else,return null
// 如果当前reader在打开期间index发生改变,则打开并返回一个新的IndexReader,否则返回null
IndexReader ir = IndexReader.openIfChanged(reader);
if (ir != null) {
reader.close(); // 关闭原reader
reader = ir; // 赋予新reader
}
}
return reader;
}
catch (Exception e) {
e.printStackTrace();
}
return null; // 发生异常则返回null
} /**
* 搜索排序
*
* @see 关于Sort参数的可输入规则,如下所示
* @see 1)Sort.INDEXORDER--使用文档编号从小到大的顺序进行排序
* @see 2)Sort.RELEVANCE---使用文档评分从大到小的顺序进行排序,也是默认的排序规则,等价于search(query, 10)
* @see 3)new Sort(new SortField("size", SortField.INT))-----------使用文件大小从小到大的顺序排序
* @see 4)new Sort(new SortField("date", SortField.LONG))----------使用文件日期从以前到现在的顺序排序
* @see 5)new Sort(new SortField("name", SortField.STRING))--------使用文件名从A到Z的顺序排序
* @see 6)new Sort(new SortField("name", SortField.STRING, true))--使用文件名从Z到A的顺序排序
* @see 7)new Sort(new SortField("size", SortField.INT), SortField.FIELD_SCORE)--先按照文件大小排序,再按照文档评分排序(可以指定多个排序规则)
* @see 注意:以上7个Sort再打印文档评分时都是NaN,只有search(query, 10)才会正确打印文档评分
* @param expr
* 搜索表达式
* @param sort
* 排序规则
*/
public void searchBySort(String expr, Sort sort) {
IndexSearcher searcher = new IndexSearcher(this.getIndexReader());
QueryParser parser = new QueryParser(Version.LUCENE_36, "content", new StandardAnalyzer(Version.LUCENE_36));
TopDocs tds = null;
try {
if (null == sort) {
tds = searcher.search(parser.parse(expr), 10);
}
else {
tds = searcher.search(parser.parse(expr), 10, sort);
}
for (ScoreDoc sd : tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
System.out.println("content=" + doc.get("content"));
System.out.print("文档编号=" + sd.doc + " 文档权值=" + doc.getBoost() + " 文档评分=" + sd.score + " ");
System.out.println("size=" + doc.get("size") + " date=" + new SimpleDateFormat("yyyyMMdd HH:mm:ss").format(new Date(Long.parseLong(doc.get("date")))) + " name=" + doc.get("name"));
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (searcher != null) {
try {
searcher.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 测试一下排序效果
*/
public static void main(String[] args) {
Lucene_05_AdvancedSearchBySort advancedSearch = new Lucene_05_AdvancedSearchBySort();
// //使用文档评分从大到小的顺序进行排序,也是默认的排序规则
// advancedSearch.searchBySort("Java", null);
// advancedSearch.searchBySort("Java", Sort.RELEVANCE);
// //使用文档编号从小到大的顺序进行排序
// advancedSearch.searchBySort("Java", Sort.INDEXORDER);
// //使用文件大小从小到大的顺序排序
// advancedSearch.searchBySort("Java", new Sort(new SortField("size", SortField.INT)));
// //使用文件日期从以前到现在的顺序排序
// advancedSearch.searchBySort("Java", new Sort(new SortField("date", SortField.LONG)));
// //使用文件名从A到Z的顺序排序
// advancedSearch.searchBySort("Java", new Sort(new SortField("name", SortField.STRING)));
// //使用文件名从Z到A的顺序排序
// advancedSearch.searchBySort("Java", new Sort(new SortField("name", SortField.STRING, true)));
// 先按照文件大小排序,再按照文档评分排序(可以指定多个排序规则)
advancedSearch.searchBySort("Java", new Sort(new SortField("size", SortField.INT), SortField.FIELD_SCORE));
}
}
6.高级搜索之普通Filter和自定义Filter
import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date; import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericField;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.DocIdSet;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.NumericRangeFilter;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.OpenBitSet;
import org.apache.lucene.util.Version; /**
* 【Lucene3.6.2入门系列】第07节_高级搜索之普通Filter和自定义Filter
*
* @create Aug 19, 2013 11:13:40 AM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class Lucene_06_AdvancedSearchByFilter {
private Directory directory;
private IndexReader reader; /**
* 测试一下过滤效果
*/
public static void main(String[] args) throws ParseException {
Lucene_06_AdvancedSearchByFilter advancedSearch = new Lucene_06_AdvancedSearchByFilter();
// //过滤文件名首字母从'h'到'n'的记录(注意hn要小写)
// advancedSearch.searchByFilter("Java", new TermRangeFilter("name", "h", "n", true, true));
// //过滤文件大小在30到80以内的记录
// advancedSearch.searchByFilter("Java", NumericRangeFilter.newIntRange("size", 30, 80, true, true));
// //过滤文件日期在20130701 00:00:00到20130808 23:59:59之间的记录
// Long min = Long.valueOf(new SimpleDateFormat("yyyyMMdd").parse("20130701").getTime());
// Long max = Long.valueOf(new SimpleDateFormat("yyyyMMdd HH:mm:ss").parse("20130808 23:59:59").getTime());
// advancedSearch.searchByFilter("Java", NumericRangeFilter.newLongRange("date", min, max, true, true));
// //过滤文件名以'ja'打头的(注意ja要小写)
// advancedSearch.searchByFilter("Java", new QueryWrapperFilter(new WildcardQuery(new Term("name", "ja*"))));
// 自定义Filter
advancedSearch.searchByFilter("Java", advancedSearch.new MyFilter());
} public Lucene_06_AdvancedSearchByFilter() {
/** 文件大小 */
int[] sizes = { 90, 10, 20, 10, 60, 50 };
/** 文件名 */
String[] names = { "Michael.java", "Scofield.ini", "Tbag.txt", "Jack", "Jade", "Jadyer" };
/** 文件内容 */
String[] contents = { "my java blog is http://blog.csdn.net/jadyer", "my Java Website is http://www.jadyer.cn", "my name is jadyer", "I am a Java Developer", "I am from Haerbin", "I like java of Lucene" };
/** 文件日期 */
Date[] dates = new Date[sizes.length];
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd HH:mm:ss");
IndexWriter writer = null;
Document doc = null;
try {
dates[0] = sdf.parse("20130407 15:25:30");
dates[1] = sdf.parse("20130407 16:30:45");
dates[2] = sdf.parse("20130213 11:15:25");
dates[3] = sdf.parse("20130808 09:30:55");
dates[4] = sdf.parse("20130526 13:54:22");
dates[5] = sdf.parse("20130701 17:35:34");
directory = FSDirectory.open(new File("myExample/01_index/"));
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
writer.deleteAll();
for (int i = 0; i < sizes.length; i++) {
doc = new Document();
doc.add(new NumericField("size", Field.Store.YES, true).setIntValue(sizes[i]));
doc.add(new Field("name", names[i], Field.Store.YES, Field.Index.ANALYZED_NO_NORMS));
doc.add(new Field("content", contents[i], Field.Store.NO, Field.Index.ANALYZED));
doc.add(new NumericField("date", Field.Store.YES, true).setLongValue(dates[i].getTime()));
// 为每个文档添加一个fileID(与ScoreDoc.doc不同),专门在自定义Filter时使用
doc.add(new Field("fileID", String.valueOf(i), Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
writer.addDocument(doc);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 获取IndexReader实例
*/
private IndexReader getIndexReader() {
try {
if (reader == null) {
reader = IndexReader.open(directory);
}
else {
// if the index was changed since the provided reader was opened, open and return a new reader; else,return null
// 如果当前reader在打开期间index发生改变,则打开并返回一个新的IndexReader,否则返回null
IndexReader ir = IndexReader.openIfChanged(reader);
if (ir != null) {
reader.close(); // 关闭原reader
reader = ir; // 赋予新reader
}
}
return reader;
}
catch (Exception e) {
e.printStackTrace();
}
return null; // 发生异常则返回null
} /**
* 搜索过滤
*/
public void searchByFilter(String expr, Filter filter) {
IndexSearcher searcher = new IndexSearcher(this.getIndexReader());
QueryParser parser = new QueryParser(Version.LUCENE_36, "content", new StandardAnalyzer(Version.LUCENE_36));
TopDocs tds = null;
try {
if (null == filter) {
tds = searcher.search(parser.parse(expr), 10);
}
else {
tds = searcher.search(parser.parse(expr), filter, 10);
}
for (ScoreDoc sd : tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
System.out.print("文档编号=" + sd.doc + " 文档权值=" + doc.getBoost() + " 文档评分=" + sd.score + " ");
System.out.println("fileID=" + doc.get("fileID") + " size=" + doc.get("size") + " date=" + new SimpleDateFormat("yyyyMMdd HH:mm:ss").format(new Date(Long.parseLong(doc.get("date")))) + " name=" + doc.get("name"));
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (searcher != null) {
try {
searcher.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 自定义Filter
*
* @see ------------------------------------------------------------------------------------------
* @see 本例的应用场景
* @see 假设很多的数据,然后删除了其中的某几条数据,此时在接受搜索请求时为保证不会搜索到已删除的数据
* @see 那么可以更新索引,但更新索引会消耗很多时间(因为数据量大),而又要保证已删除的数据不会被搜索到
* @see 此时就可以自定义Filter,原理即搜索过程中,当发现此记录为已删除记录,则不添加到返回的搜索结果集中
* @see ------------------------------------------------------------------------------------------
* @see 自定义Filter步骤如下
* @see 1)继承Filter类并重写getDocIdSet()方法
* @see 2)根据实际过滤要求返回新的DocIdSet对象
* @see ------------------------------------------------------------------------------------------
* @see DocIdSet小解
* @see 这里Filter干的活其实就是创建一个DocIdSet,而DocIdSet其实就是一个数组,可以理解为其中只存放0或1的值
* @see 每个搜索出来的Document都有一个文档编号,所以搜索出来多少个Document,那么DocIdSet中就会有多少条记录
* @see 而DocIdSet中每一条记录的索引号与文档编号是一一对应的
* @see 所以当DocIdSet中的记录为1时,则对应文档编号的Document就会被添加到TopDocs中,为0就会被过滤掉
* @see ------------------------------------------------------------------------------------------
* @create Aug 6, 2013 7:28:53 PM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
class MyFilter extends Filter {
private static final long serialVersionUID = -8955061358165068L; // 假设这是已删除记录的fileID值的集合
private String[] deleteFileIDs = { "1", "3" }; @Override
public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
// 创建一个DocIdSet的子类OpenBitSet(创建之后默认所有元素都是0),传的参数就是本次"搜索到的"元素数目
OpenBitSet obs = new OpenBitSet(reader.maxDoc());
// 先把元素填满,即全部设置为1
obs.set(0, reader.maxDoc());
// 用于保存已删除元素的文档编号
int[] docs = new int[1];
for (String deleteDataID : deleteFileIDs) {
// 获取已删除元素对应的TermDocs
TermDocs tds = reader.termDocs(new Term("fileID", deleteDataID));
// 将已删除元素的文档编号放到docs中,将其出现的频率放到freqs中,最后返回查询出来的元素数目
int count = tds.read(docs, new int[1]);
if (count == 1) {
// 将这个位置docs[0]的元素删除
obs.clear(docs[0]);
}
}
return obs;
}
} }
7.高级搜索之自定义QueryParser
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Pattern; 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.document.NumericField;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.NumericRangeQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version; /**
* 【Lucene3.6.2入门系列】第09节_高级搜索之自定义QueryParser
*
* @create Aug 19, 2013 2:07:32 PM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class Lucene_07_AdvancedSearch {
private Directory directory;
private IndexReader reader; /**
* 测试一下搜索效果
*/
public static void main(String[] args) {
Lucene_07_AdvancedSearch advancedSearch = new Lucene_07_AdvancedSearch();
advancedSearch.searchByCustomQueryParser("name:Jadk~");
advancedSearch.searchByCustomQueryParser("name:Ja??er");
System.out.println("------------------------------------------------------------------------");
advancedSearch.searchByCustomQueryParser("name:Jade");
System.out.println("------------------------------------------------------------------------");
advancedSearch.searchByCustomQueryParser("name:[h TO n]");
System.out.println("------------------------------------------------------------------------");
advancedSearch.searchByCustomQueryParser("size:[20 TO 80]");
System.out.println("------------------------------------------------------------------------");
advancedSearch.searchByCustomQueryParser("date:[20130407 TO 20130701]");
} public Lucene_07_AdvancedSearch() {
/** 文件大小 */
int[] sizes = { 90, 10, 20, 10, 60, 50 };
/** 文件名 */
String[] names = { "Michael.java", "Scofield.ini", "Tbag.txt", "Jack", "Jade", "Jadyer" };
/** 文件内容 */
String[] contents = { "my java blog is http://blog.csdn.net/jadyer", "my Java Website is http://www.jadyer.cn", "my name is jadyer", "I am a Java Developer", "I am from Haerbin", "I like java of Lucene" };
/** 文件日期 */
Date[] dates = new Date[sizes.length];
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd HH:mm:ss");
IndexWriter writer = null;
Document doc = null;
try {
dates[0] = sdf.parse("20130407 15:25:30");
dates[1] = sdf.parse("20130407 16:30:45");
dates[2] = sdf.parse("20130213 11:15:25");
dates[3] = sdf.parse("20130808 09:30:55");
dates[4] = sdf.parse("20130526 13:54:22");
dates[5] = sdf.parse("20130701 17:35:34");
directory = FSDirectory.open(new File("E:/lucene_test/01_index/"));
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
writer.deleteAll();
for (int i = 0; i < sizes.length; i++) {
doc = new Document();
doc.add(new NumericField("size", Field.Store.YES, true).setIntValue(sizes[i]));
doc.add(new Field("name", names[i], Field.Store.YES, Field.Index.ANALYZED_NO_NORMS));
doc.add(new Field("content", contents[i], Field.Store.NO, Field.Index.ANALYZED));
doc.add(new NumericField("date", Field.Store.YES, true).setLongValue(dates[i].getTime()));
writer.addDocument(doc);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 获取IndexReader实例
*/
private IndexReader getIndexReader() {
try {
if (reader == null) {
reader = IndexReader.open(directory);
}
else {
// if the index was changed since the provided reader was opened, open and return a new reader; else,return null
// 如果当前reader在打开期间index发生改变,则打开并返回一个新的IndexReader,否则返回null
IndexReader ir = IndexReader.openIfChanged(reader);
if (ir != null) {
reader.close(); // 关闭原reader
reader = ir; // 赋予新reader
}
}
return reader;
}
catch (Exception e) {
e.printStackTrace();
}
return null; // 发生异常则返回null
} /**
* 自定义QueryParser的搜索
*
* @param expr
* 搜索的表达式
*/
public void searchByCustomQueryParser(String expr) {
IndexSearcher searcher = new IndexSearcher(this.getIndexReader());
QueryParser parser = new MyQueryParser(Version.LUCENE_36, "content", new StandardAnalyzer(Version.LUCENE_36));
try {
Query query = parser.parse(expr);
TopDocs tds = searcher.search(query, 10);
for (ScoreDoc sd : tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
System.out.print("文档编号=" + sd.doc + " 文档权值=" + doc.getBoost() + " 文档评分=" + sd.score + " ");
System.out.println("size=" + doc.get("size") + " date=" + new SimpleDateFormat("yyyyMMdd HH:mm:ss").format(new Date(Long.parseLong(doc.get("date")))) + " name=" + doc.get("name"));
}
}
catch (ParseException e) {
System.err.println(e.getMessage());
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != searcher) {
try {
searcher.close(); // 记得关闭IndexSearcher
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 自定义QueryParser
*
* @see --------------------------------------------------------------------------------------------------
* @see 实际使用QueryParser的过程中,通常会考虑两个问题
* @see 1)限制性能低的QueryParser--对于某些QueryParser在搜索时会使得性能降低,故考虑禁用这些搜索以提升性能
* @see 2)扩展基于数字和日期的搜索---有时需要进行一个数字的范围搜索,故需扩展原有的QueryParser才能实现此搜索
* @see --------------------------------------------------------------------------------------------------
* @see 限制性能低的QueryParser
* @see 继承QueryParser类并重载相应方法,比如getFuzzyQuery和getWildcardQuery
* @see 这样造成的结果就是,当输入普通的搜索表达式时,如'I AND Haerbin'可以正常搜索
* @see 但输入'name:Jadk~'或者'name:Ja??er'时,就会执行到重载方法中,这时就可以自行处理了,比如本例中禁止该功能
* @see --------------------------------------------------------------------------------------------------
* @see 扩展基于数字和日期的查询
* @see 思路就是继承QueryParser类后重载getRangeQuery()方法
* @see 再针对数字和日期的'域',做特殊处理(使用NumericRangeQuery.newIntRange()方法来搜索)
* @see --------------------------------------------------------------------------------------------------
* @create Aug 6, 2013 4:13:42 PM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class MyQueryParser extends QueryParser {
public MyQueryParser(Version matchVersion, String f, Analyzer a) {
super(matchVersion, f, a);
} @Override
protected Query getWildcardQuery(String field, String termStr) throws ParseException {
throw new ParseException("由于性能原因，已禁用通配符搜索，请输入更精确的信息进行搜索 ^_^ ^_^");
} @Override
protected Query getFuzzyQuery(String field, String termStr, float minSimilarity) throws ParseException {
throw new ParseException("由于性能原因，已禁用模糊搜索，请输入更精确的信息进行搜索 ^_^ ^_^");
} @Override
protected Query getRangeQuery(String field, String part1, String part2, boolean inclusive) throws ParseException {
if (field.equals("size")) {
// 默认的QueryParser.parse(String query)表达式中并不支持'size:[20 TO 80]'数字的域值
// 这样一来,针对数字的域值进行特殊处理,那么QueryParser表达式就支持数字了
return NumericRangeQuery.newIntRange(field, Integer.parseInt(part1), Integer.parseInt(part2), inclusive, inclusive);
}
else if (field.equals("date")) {
String regex = "\\d{8}";
String dateType = "yyyyMMdd";
if (Pattern.matches(regex, part1) && Pattern.matches(regex, part2)) {
SimpleDateFormat sdf = new SimpleDateFormat(dateType);
try {
long min = sdf.parse(part1).getTime();
long max = sdf.parse(part2).getTime();
// 使之支持日期的检索,应用时直接QueryParser.parse("date:[20130407 TO 20130701]")
return NumericRangeQuery.newLongRange(field, min, max, inclusive, inclusive);
}
catch (java.text.ParseException e) {
e.printStackTrace();
}
}
else {
throw new ParseException("Unknown date format, please use '" + dateType + "'");
}
}
// 如没找到匹配的Field域,那么返回默认的TermRangeQuery
return super.getRangeQuery(field, part1, part2, inclusive);
}
}
}
8.高亮
import java.io.File;
import java.io.IOException; import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.highlight.Formatter;
import org.apache.lucene.search.highlight.Fragmenter;
import org.apache.lucene.search.highlight.Highlighter;
import org.apache.lucene.search.highlight.QueryScorer;
import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
import org.apache.lucene.search.highlight.SimpleSpanFragmenter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.apache.tika.Tika; import com.chenlb.mmseg4j.analysis.MMSegAnalyzer; /**
* 【Lucene3.6.2入门系列】第11节_高亮
*
* @see 高亮功能属于Lucene的扩展功能(或者叫做贡献功能)
* @see 其所需jar位于Lucene-3.6.2.zip中的/contrib/highlighter/文件夹中
* @see 本例中需要以下4个jar
* @see lucene-core-3.6.2.jar
* @see lucene-highlighter-3.6.2.jar
* @see mmseg4j-all-1.8.5-with-dic.jar
* @see tika-app-1.4.jar
* @create Aug 7, 2013 11:37:10 AM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class Lucene_08_HelloHighLighter {
private Directory directory;
private IndexReader reader; public Lucene_08_HelloHighLighter() {
Document doc = null;
IndexWriter writer = null;
try {
directory = FSDirectory.open(new File("E:/lucene_test/01_index/"));
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new MMSegAnalyzer()));
writer.deleteAll();
for (File myFile : new File("E:/lucene_test/01_index/").listFiles()) {
doc = new Document();
doc.add(new Field("filecontent", new Tika().parse(myFile))); // Field.Store.NO,Field.Index.ANALYZED
doc.add(new Field("filepath", myFile.getAbsolutePath(), Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
writer.addDocument(doc);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 获取IndexSearcher实例
*/
private IndexSearcher getIndexSearcher() {
try {
if (reader == null) {
reader = IndexReader.open(directory);
}
else {
// if the index was changed since the provided reader was opened, open and return a new reader; else,return null
// 如果当前reader在打开期间index发生改变,则打开并返回一个新的IndexReader,否则返回null
IndexReader ir = IndexReader.openIfChanged(reader);
if (ir != null) {
reader.close(); // 关闭原reader
reader = ir; // 赋予新reader
}
}
return new IndexSearcher(reader);
}
catch (Exception e) {
e.printStackTrace();
}
return null; // 发生异常则返回null
} /**
* 高亮搜索
*
* @see 高亮搜索时,不建议把高亮信息存到索引里,而是搜索到内容之后再进行高亮处理
* @see 这里用的是MMSeg4j中文分词器,有关其介绍详见http://blog.csdn.net/jadyer/article/details/10049525
* @param expr
* 搜索表达式
*/
public void searchByHignLighter(String expr) {
Analyzer analyzer = new MMSegAnalyzer();
IndexSearcher searcher = this.getIndexSearcher();
// 搜索多个Field
QueryParser parser = new MultiFieldQueryParser(Version.LUCENE_36, new String[] { "filepath", "filecontent" }, analyzer);
try {
Query query = parser.parse(expr);
TopDocs tds = searcher.search(query, 50);
for (ScoreDoc sd : tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
// 获取文档内容
String filecontent = new Tika().parseToString(new File(doc.get("filepath")));
System.out.println("搜索到的内容为[" + filecontent + "]");
// 开始高亮处理
QueryScorer queryScorer = new QueryScorer(query);
Fragmenter fragmenter = new SimpleSpanFragmenter(queryScorer, filecontent.length());
Formatter formatter = new SimpleHTMLFormatter("<span style='color:red'>", "</span>");
Highlighter hl = new Highlighter(formatter, queryScorer);
hl.setTextFragmenter(fragmenter);
System.out.println("高亮后的内容为[" + hl.getBestFragment(analyzer, "filecontent", filecontent) + "]");
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != searcher) {
try {
searcher.close(); // 记得关闭IndexSearcher
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 高亮的使用方式
*
* @see 这里用的是MMSeg4j中文分词器,有关其介绍详见http://blog.csdn.net/jadyer/article/details/10049525
*/
private static void testHighLighter() {
String fieldName = "myinfo"; // 这个可以随便写,就是起个标识的作用
String text = "我来自中国黑龙江省哈尔滨市巴彦县兴隆镇长春乡民权村4队";
QueryParser parser = new QueryParser(Version.LUCENE_36, fieldName, new MMSegAnalyzer());
try {
// MMSeg4j的new MMSegAnalyzer()默认只会对'中国'和'兴隆'进行分词,所以这里就只高亮它们俩了
Query query = parser.parse("中国 兴隆");
// 针对查询出来的文本,查询其评分,以便于能够根据评分决定显示情况
QueryScorer queryScorer = new QueryScorer(query);
// 对字符串或文本进行分段,SimpleSpanFragmenter构造方法的第二个参数可以指定高亮的文本长度,默认为100
Fragmenter fragmenter = new SimpleSpanFragmenter(queryScorer);
// 高亮时的高亮格式,默认为<B></B>,这里指定为红色字体
Formatter formatter = new SimpleHTMLFormatter("<span style='color:red'>", "</span>");
// Highlighter专门用来做高亮显示
// 该构造方法还有一个参数为Encoder,它有两个实现类DefaultEncoder和SimpleHTMLEncoder
// SimpleHTMLEncoder可以忽略掉HTML标签,而DefaultEncoder则不会忽略HTML标签
Highlighter hl = new Highlighter(formatter, queryScorer);
hl.setTextFragmenter(fragmenter);
System.out.println(hl.getBestFragment(new MMSegAnalyzer(), fieldName, text));
}
catch (Exception e) {
e.printStackTrace();
}
} /**
* 小测试一下
*/
public static void main(String[] args) {
// 测试高亮的基本使用效果
Lucene_08_HelloHighLighter.testHighLighter();
// 测试高亮搜索的效果(测试前记得在myExample/myFile/文件夹中准备一个或多个内容包含"依赖"的doc或pdf的等文件)
// new Lucene_08_HelloHighLighter().searchByHignLighter("依赖");
}
}
9.近实时搜索
import java.io.File;
import java.io.IOException; import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.NRTManager;
import org.apache.lucene.search.NRTManager.TrackingIndexWriter;
import org.apache.lucene.search.NRTManagerReopenThread;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version; /**
* 【Lucene3.6.2入门系列】第12节_近实时搜索
*
* @see 实时搜索(near-real-time)---->只要数据发生变化,则马上更新索引(IndexWriter.commit())
* @see 近实时搜索------------------>数据发生变化时,先将索引保存到内存中,然后在一个统一的时间再对内存中的所有索引执行commit提交动作
* @see 为了实现近实时搜索,Lucene3.0提供的方式叫做reopen,后来的版本中提供了两个线程安全的类NRTManager和SearcherManager
* @see 不过这俩线程安全的类在Lucene3.5和3.6版本中的用法有点不太一样,这点要注意
* @create Aug 7, 2013 4:19:58 PM
* @author 玄玉<http://blog.csdn.net/jadyer>
*/
public class Lucene_09_HelloNRTSearch {
private IndexWriter writer;
private NRTManager nrtManager;
private TrackingIndexWriter trackWriter; /**
* 测试时，要在E:/lucene_test/01_file/文件夹中准备几个包含内容的文件（比如txt格式的）
* 然后先执行createIndex()方法，再执行searchFile()方法，最后观看控制台输出即可
*/
public static void main(String[] args) {
Lucene_09_HelloNRTSearch instance = new Lucene_09_HelloNRTSearch();
instance.createIndex();
instance.testSearchFile();
instance.getDocsCount();
} public void testSearchFile() {
Lucene_09_HelloNRTSearch hello = new Lucene_09_HelloNRTSearch();
for (int i = 0; i < 5; i++) {
hello.searchFile();
System.out.println("-----------------------------------------------------------");
hello.deleteIndex();
if (i == 2) {
hello.updateIndex();
}
try {
System.out.println(".........开始休眠2s(模拟近实时搜索情景)");
Thread.sleep(2000);
System.out.println(".........休眠结束");
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
// 不能单独去new HelloNRTSearch,要保证它们是同一个对象,否则所做的delete和update不会被commit
hello.commitIndex();
} public Lucene_09_HelloNRTSearch() {
try {
Directory directory = FSDirectory.open(new File("E:/lucene_test/01_index/"));
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
trackWriter = new NRTManager.TrackingIndexWriter(writer);
// /*
// * Lucene3.5中的NRTManager是通过下面的方式创建的
// * 并且Lucene3.5中可以直接使用NRTManager.getSearcherManager(true)获取到org.apache.lucene.search.SearcherManager
// */
// nrtManager = new NRTManager(writer,new org.apache.lucene.search.SearcherWarmer() {
// @Override
// public void warm(IndexSearcher s) throws IOException {
// System.out.println("IndexSearcher.reopen时会自动调用此方法");
// }
// });
nrtManager = new NRTManager(trackWriter, null);
// 启动一个Lucene提供的后台线程来自动定时的执行NRTManager.maybeRefresh()方法
// 这里的后俩参数,是根据这篇分析的文章写的http://blog.mikemccandless.com/2011/11/near-real-time-readers-with-lucenes.html
NRTManagerReopenThread reopenThread = new NRTManagerReopenThread(nrtManager, 5.0, 0.025);
reopenThread.setName("NRT Reopen Thread");
reopenThread.setDaemon(true);
reopenThread.start();
}
catch (Exception e) {
e.printStackTrace();
}
} /**
* 创建索引
*/
public void createIndex() {
String[] ids = { "1", "2", "3", "4", "5", "6" };
String[] names = { "Michael", "Scofield", "Tbag", "Jack", "Jade", "Jadyer" };
String[] contents = { "my blog", "my website", "my name", "my job is JavaDeveloper", "I am from Haerbin", "I like Lucene" };
IndexWriter writer = null;
Document doc = null;
try {
Directory directory = FSDirectory.open(new File("E:/lucene_test/01_index/"));
writer = new IndexWriter(directory, new IndexWriterConfig(Version.LUCENE_36, new StandardAnalyzer(Version.LUCENE_36)));
writer.deleteAll();
for (int i = 0; i < names.length; i++) {
doc = new Document();
doc.add(new Field("id", ids[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("name", names[i], Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("content", contents[i], Field.Store.YES, Field.Index.ANALYZED));
writer.addDocument(doc);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != writer) {
try {
writer.close();
}
catch (IOException ce) {
ce.printStackTrace();
}
}
}
} /**
* 通过IndexReader获取文档数量
*/
public void getDocsCount() {
IndexReader reader = null;
try {
reader = IndexReader.open(FSDirectory.open(new File("E:/lucene_test/01_index/")));
System.out.println("maxDocs:" + reader.maxDoc());
System.out.println("numDocs:" + reader.numDocs());
System.out.println("deletedDocs:" + reader.numDeletedDocs());
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (reader != null) {
try {
reader.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 搜索文件
*/
public void searchFile() {
// Lucene3.5里面可以直接使用NRTManager.getSearcherManager(true).acquire()
IndexSearcher searcher = nrtManager.acquire();
Query query = new TermQuery(new Term("content", "my"));
try {
TopDocs tds = searcher.search(query, 10);
for (ScoreDoc sd : tds.scoreDocs) {
Document doc = searcher.doc(sd.doc);
System.out.print("文档编号=" + sd.doc + " 文档权值=" + doc.getBoost() + " 文档评分=" + sd.score + " ");
System.out.println("id=" + doc.get("id") + " name=" + doc.get("name") + " content=" + doc.get("content"));
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
try {
// 这里就不要IndexSearcher.close()啦,而是交由NRTManager来释放
nrtManager.release(searcher);
// Lucene-3.6.2文档中ReferenceManager.acquire()方法描述里建议再手工设置searcher为null,以防止在其它地方被意外的使用
searcher = null;
}
catch (IOException e) {
e.printStackTrace();
}
}
} /**
* 更新索引
*/
public void updateIndex() {
Document doc = new Document();
doc.add(new Field("id", "11", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("name", "xuanyu", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
doc.add(new Field("content", "my name is xuanyu", Field.Store.YES, Field.Index.ANALYZED));
try {
// Lucene3.5中可以直接使用org.apache.lucene.search.NRTManager.updateDocument(new Term("id", "1"), doc)
trackWriter.updateDocument(new Term("id", "1"), doc);
}
catch (IOException e) {
e.printStackTrace();
}
} /**
* 删除索引
*/
public void deleteIndex() {
try {
// Lucene3.5中可以直接使用org.apache.lucene.search.NRTManager.deleteDocuments(new Term("id", "2"))
trackWriter.deleteDocuments(new Term("id", "2"));
}
catch (IOException e) {
e.printStackTrace();
}
} /**
* 提交索引内容的变更情况
*/
public void commitIndex() {
try {
writer.commit();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
参考文章
http://www.chedong.com/tech/lucene.html
http://blog.csdn.net/column/details/jadyerlucene.html