Engineers are versatile minds who create links between science, technology, and society
2015年12月
确定要删除当前文章？随笔 - 1352&
评论 - 579&
&&&&&&&&&&&
http://www.slideshare.net/lucenerevolution/what-is-inaluceneagrandfinal
http://www.slideshare.net/jpountz/how-does-lucene-store-your-data
http://www.infoq.com/cn/articles/database-timestamp-02?utm_source=infoq&utm_medium=related_content_link&utm_campaign=relatedContent_articles_clk
摘录一些重要的：
看一下Lucene的倒排索引是怎么构成的。
我们来看一个实际的例子，假设有如下的数据：
这里每一行是一个document。每个document都有一个docid。那么给这些document建立的倒排索引就是：
可以看到，倒排索引是per field的，一个字段有一个自己的倒排索引。18,20这些叫做 term，而[1,3]就是posting list。Posting list就是一个int的数组，存储了所有符合某个term的文档id。那么什么是term dictionary 和 term index？
那么什么是term dictionary 和 term index？
假设我们有很多个term，比如：
Carla,Sara,Elin,Ada,Patty,Kate,Selena
如果按照这样的顺序排列，找出某个特定的term一定很慢，因为term没有排序，需要全部过滤一遍才能找出特定的term。排序之后就变成了：
Ada,Carla,Elin,Kate,Patty,Sara,Selena
这样我们可以用二分查找的方式，比全遍历更快地找出目标的term。这个就是 term dictionary。有了term dictionary之后，可以用 logN 次磁盘查找得到目标。但是磁盘的随机读操作仍然是非常昂贵的（一次random access大概需要10ms的时间）。所以尽量少的读磁盘，有必要把一些数据缓存到内存里。但是整个term dictionary本身又太大了，无法完整地放到内存里。于是就有了term index。term index有点像一本字典的大的章节表。比如：
A开头的term ……………. Xxx页
C开头的term ……………. Xxx页
E开头的term ……………. Xxx页
如果所有的term都是英文字符的话，可能这个term index就真的是26个英文字符表构成的了。但是实际的情况是，term未必都是英文字符，term可以是任意的byte数组。而且26个英文字符也未必是每一个字符都有均等的term，比如x字符开头的term可能一个都没有，而s开头的term又特别多。实际的term index是一棵trie 树：
例子是一个包含 "A", "to", "tea", "ted", "ten", "i", "in", 和 "inn" 的 trie 树。这棵树不会包含所有的term，它包含的是term的一些前缀。通过term index可以快速地定位到term dictionary的某个offset，然后从这个位置再往后顺序查找。再加上一些压缩技术（搜索 Lucene Finite State Transducers） term index 的尺寸可以只有所有term的尺寸的几十分之一，使得用内存缓存整个term index变成可能。整体上来说就是这样的效果。
现在我们可以回答“为什么Elasticsearch/Lucene检索可以比mysql快了。Mysql只有term dictionary这一层，是以b-tree排序的方式存储在磁盘上的。检索一个term需要若干次的random access的磁盘操作。而Lucene在term dictionary的基础上添加了term index来加速检索，term index以树的形式缓存在内存中。从term index查到对应的term dictionary的block位置之后，再去磁盘上找term，大大减少了磁盘的random access次数。
额外值得一提的两点是：term index在内存中是以FST（finite state transducers）的形式保存的，其特点是非常节省内存。Term dictionary在磁盘上是以分block的方式保存的，一个block内部利用公共前缀压缩，比如都是Ab开头的单词就可以把Ab省去。这样term dictionary可以比b-tree更节约磁盘空间。
&--------------------------------------------------------
lucene并非使用Tree structure– sorted for range queries– O(log(n)) search
而是如下核心的数据结构，FST，delta encode压缩数组，列存储，LZ4压缩算法：●Terms index: map a term prefix to a block in the dict ○ FST: automaton with weighted arcs, compact thanks to shared prefixes/suffixes 核心数据结构，本质是前后缀共享的状态机，类似trie来搜索用户输入的某个单词是否能搜到，搜到的话就跳转到Terms dictionary里去，搜到的结果是单词在terms dict里的offset（本质是数组的偏移量）Lookup the term in the terms index– In-memory FST storing terms prefixes– Gives the offset to look at in the terms dictionary– Can fast-fail if no terms have this prefix●Terms dictionary: statistics + pointer in postings lists, Store terms and documents in arrays – binary searcho Jump to the given offset in the terms dictionary– compressed based on shared prefixes, similarly to a burst trie– called the “BlockTree terms dict”o read sequentially until the term is found●Postings lists: encodes matching docs in sorted order ○ + positions + offsets 倒排的文档ID都在此o Jump to the given offset in the postings listso Encoded using modified FOR (Frame of Reference) delta– 1. delta-encode– 2. split into block of N=128 values– 3. bit packing per block– 4. if remaining docs, encode with vInt●Stored fieldso In-memory index for a subset of the doc ids– memory-efficient thanks to monotonic compression– searched using binary searcho Stored fields– stored sequentially– compressed (LZ4) in 16+KB blocks
Query execution：o 2 disk seeks per field for searcho 1 disk seek per doc for stored fieldso It is common that the terms dict / postings lists fits into the file-system cacheo “Pulse” optimization– For unique terms (freq=1), postings are inlined in the terms dict– Only 1 disk seek– Will always be used for your primary keys
插入新数据：Insertion = write a new segment 一直写信segment可以防止使用锁o Merge segments when there are too many of them– concatenate docs, merge terms dicts and postings lists (merge sort!)删除：Deletion = turn a bit offo Ignore deleted documents when searching and merging (reclaims space)o Merge policies favor segments with many deletions
优缺点：Updates require writing a new segment– single-doc updates are costly, bulk updates preferred– writes are sequentialo Segments are never modified in place– filesystem-cache-friendly– lock-free!o Terms are deduplicated– saves space for high-freq termso Docs are uniquely identified by an ord– useful for cross-API communication– Lucene can use several indexes in a single queryo Terms are uniquely identified by an ord– important for sorting: compare longs, not strings– important for faceting (more on this later)
针对field使用列存储：Per doc and per field single numeric values, stored in a column-stride fashiono Useful for sorting and custom scoringo Norms are numeric doc values
一些设计原则：o Save file handles– don’t use one file per field or per doco Avoid disk seeks whenever possible– disk seek on spinning disk is ~10 mso BUT don’t ignore the filesystem cache– random access in small files is fineo Light compression helps– less I/O– smaller indexes– filesystem-cache-friendly
针对Compression techniques的数据结构：FSTs&LZ4
阅读(...) 评论()添加搜索功能
Lucene提供的搜索API：IndexSeacher、Query、QueryParser、TopDocs、ScoreDoc
简单的搜索功能
使用Lucene进行搜索时，可以选择编程来构建查询语句，也可以使用QueryParser将用户输入的文本转换为Query对象
对特定项的搜索：Term
QueryParser：使用一个分析器SimpleAnalyzer将查询语句分割成多个项
使用IndexSeacher类
创建一个IndexSeacher实例，负责打开索引，然后使用search方法搜索，返回的TopDocs。其中IndexReader完成了底层的操作。
使用TopDocs，它为检索搜索结果提供了少量的方法和属性，totalHits-文档数量，ScoreDocs-包含搜索结果的ScoreDoc对象数组，getMaxScore-返回最大评分
搜索结果分页，两种方式：1，将首次搜索获得的多页搜索结果收集起来并保存在ScoreDocs和IndexSeacher实例中，并在用户换页浏览时展现这几页结果；2，每次用户换页浏览时都重新查询
近实时搜索，它使你能够使用一个打开的IndexWriter快速搜索索引的变更内容，而不比首先关闭writer或向writer提交
理解Lucene评分机制
Lucene如何评分
每个文档被赋予一定的分值，用以反应匹配程度，该分值会计算文档和查询语句之间的相似程度。
Lucene有个相似度评分公式，得到一个原始评分（大于等于0.0的浮点数），对评分进行归一化处理，即用该条查询对应的评分除以最大评分。
公式中引入了加权因子，对某个查询或某域的评分效果进行控制，可以在索引时显式通过boost来设置。除了显式表达的因子之外，其它因子是作为查询标准（querynorm）因子的一部分在每次预查询前进行计算。
大多数因子的控制和实现都是通过Similarity抽象类的子类完成的，默认为DefaultSimilarity
使用explain()理解搜索结果评分
如果你想知道这些因子是如何计算出来的，有个Explanation类。IndexSearcher类包含一个explain方法，调用Query对象和一个文档ID，返回一个Explanation对象。
Lucene的多样化查询
通过项进行查询：TermQuery
在指定的项范围内搜索：TermRangeQuery
在指定的数字范围内搜索：NumericRangeQuery
字符串搜索：PrefixQuery
组合查询：BooleanQuery
短语搜索：PhraseQuery
通配符查询：WildcardQuery
搜索类似项：FuzzyQuery
匹配所有文档：MatchAllDocsQuery
解析查询表达式：QueryParser
Query.toString方法，输出全部项的域选择标识符
TermQuery，单个词默认情况下如果不被识别为更长的其他查询类型表达式的一部分，就作为单个TermQuery对象
分组查询，BooleanQuery嵌套复杂的子句
《开发自己的搜索引擎》读书笔记——Lucene搜索
使用IndexSearcher进行搜索
Lucene搜索相关的API多数都被包含在org.apache.lucene.search包中。其中，最重要的是IndexSearcher类。
（1）、In...
JAVAWEB开发之Lucene详解——Lucene入门及使用场景、全文检索、索引CRUD、优化索引库、分词器、高亮、相关度排序、各种查询
Lucene入门
windows系统中的有搜索功能：打开“我的电脑”，按“F3”就可以使用查找的功能，查找指定的文件或文件夹。搜索的范围是整个电脑中的文件资源。
Eclipse中的帮助子系统...
Lucene教程--维护索引、查询对象和相关度排序
1 索引维护
1.1 添加索引
1）创建存放索引的目录Directory
2）创建索引器配置管理类IndexWriterConfig
3）使用索引目录和配置管理类创建索引器
Lucene总结系列（一）--认识、helloworld以及基本的api操作。
这也是项目需要用的框架之一，为了不让自己轻易忘记它，在此记录一系列的lucene学习笔记（基于lucene4.4，IKAnalyzer2012分词器，只有4.0之前的api才大变，4.0后的api趋于...
Lucene 入门详解
Lucene 快速开发全文搜索， 关键字高亮功能， 应该是工程师必不可少的一个技能.....
整体思路：使用Redis做缓存，缓存策略为首次查询从数据库抓取，取出后存入Redis（有效期为48h），删除和更新操作在Redis中进行，并且定时同步至数据库；Lucene做全文检索，RAMDirec...
一个搜索功能：要求将所有包括搜索字段的文章的标题列出来（文章的内容存储在Oracle的CLOB字段中），也就是要用Lucene实现对数据库的大字段进行索引和搜索。创建lucene通过java定时任务来...
高级搜索技术
Lucene域缓存
倒排索引不支持快速访问各个文档中某个域的值，被存储的field和term可以通过文档号来访问所有的field，但是加载速度较慢。
域缓存是一个用户不可见的搜索功能，只...
Lucene简介
Lucent：Apache软件基金会Jakarta项目组的一个子项目，Lucene提供了一个简单却强大的应用程式接口，能够做全文索引和搜寻。在Java开发环境里Lucene是...
上一篇：JAVA_WEB项目之Lucene检索框架入门案例初步给出了一个r
没有更多推荐了，    Lucene有一个问题一直困扰着我, 就是如何在索引文件的时候节省空间, 合理的分配不大也不小的空间有助于在提高搜索速度的同时也能够监测内存的使用情况, 在内存使用到达某个阈值的时候可以触发合并的操作
    之前在写一个小程序, 来实现类似于Lucene索引文件的时候, 我是用c++写的, 没有使用内存池, 需要的时候就找操作系统&要&一块, 不需要的时候就还给它, 这样不仅仅在内存的频繁的分配中造成大量的内存碎片, 而且没有用内存池还会带来操作系统的换页情况, 使得本来一共就3M左右的文件读取到内存中, 进行分词操作后要70M(当然是增加了一些属性了, 不过也没有这么高吧!), 把豆腐都盘成肉价钱了.
    另外还是声明一下: 本文的著作权归LeftNoteasy所有, 如果需要转载请保留这句话并注明出处.
    在TermsHashPerField中有三个Pool, CharBlockPool, IntBlockPool, ByteBlockPool. 三者之间非常类似, 其实我觉得Lucene的开发者应该加以统一, 把代码进行规范化处理, 我看到Lucene中随处可见重复的代码, 这样不仅给开发带来很多重复的工作, 而且对维护也不一定好, 如果那一天发现某个算法可以改进或者出现了bug, 那估计得忙上一阵子了.
     三个缓存都是来自于TermsHashPerThread, 也就是说, 每个线程都有独立的Pool,这样的设计很好, 可以利用多核来对索引进行加速.
    1. CharBlockPool
1: final class CharBlockPool
char[][] buffers = new char[10][];
int bufferUpTo = -1;
int charUpTo = DocumentWriter.CHAR_BLOCK_SIZE;
int charOffset = -DocumentWriter.CHAR_BLOCK_SIZE;
      这里给出了CharBlockPool的主要成员变量, Lucene的Buffer设计有一个特点, 就是采用了二维数组, 就像房子一样, 最开始是个平房, 如果不够住了就往天上盖, 越盖越高, 当然, 是当前层住不下了才盖新的一层.
    buffers就是这个楼房
    bufferUpTo是这个楼房有多少层
    charUpTo是我们在当前层的定位(where we are)
    charOffset是我们总体的偏移量.
    下面看看CharBlockPool的nextBuffer()函数, 也就是房子不够, 修楼房的函数:
1: public void nextBuffer() {
if (1+bufferUpto == buffers.length) {
char[][] newBuffers = new char[(int) (buffers.length*1.5)][];
System.arraycopy(buffers, 0, newBuffers, 0, buffers.length);
buffers = newB
buffer = buffers[1+bufferUpto] = docWriter.getCharBlock();
bufferUpto++;
charUpto = 0;
charOffset += DocumentsWriter.CHAR_BLOCK_SIZE;
    程序应该是比较好理解的, 首先看看buffers.length(房子的规划)是不是不够了, 如果规划少了, 就把规划*1.5得到新的规划, 比如本来预计房子会修到10层, 就提高到15层.
    然后把bufferUpto指针++, 从docWriter.getCharBlock函数来&要&内存, 在getCharBlock()函数中还会对申请的内容进行记载, 以进行内存的监控.
    然后我们看看CharBlockPool是怎样被调用的, 在TermsHashPerField的add()函数中:
1: if (p == null) {
final int textLen1 = 1+tokenTextL
if (textLen1 + charPool.charUpto & DocumentsWriter.CHAR_BLOCK_SIZE) {
if (textLen1 & DocumentsWriter.CHAR_BLOCK_SIZE) {
if (docState.maxTermPrefix == null)
docState.maxTermPrefix = new String(tokenText, 0, 30);
consumer.skippingLongTerm();
charPool.nextBuffer();
     这段代码首先计算出当前单词的长度(textLen1), 然后看看当前缓存的&层&是否够住了, 如果不够, 就调用charPool.nextBuffer()加盖楼房.
1: final char[] text = charPool.
2: final int textUpto = charPool.charU
3: p.textStart = textUpto + charPool.charO
4: charPool.charUpto += textLen1;
5: System.arraycopy(tokenText, 0, text, textUpto, tokenTextLen);
6: text[textUpto+tokenTextLen] = 0
    这段代码就是怎么使用缓存的了. 首先拿到charBlockPool的buffer, 然后修改p.textStart, 这个成员变量的意思是这个posting(也就是这个单词了)是从charPool中什么位置起始的. 然后把单词结束后的一位设置为0xffff.
    可以看出, charBlockPool的用法还是很朴素的, 这可能也说明了, 越朴素, 越灵活吧, 或许lucene的开发者是这样考虑的, 呵呵.
     2. IntBlockPool, ByteBlockPool
     这个类非常类似于charBlockPool, 在lucene的缓存中, 对每一种类型都设置了一种内存池, 对于token来说, text使用charPool, 位置采用一个一个的byte来构成, 而表示位置byte的起始序列的值采用IntPool来保存, 起始我觉得IntBlockPool并不是那样的有必要, 我感觉保存在postingHash中也是可以的, 具体我慢慢再理解一下, 也欢迎大家讨论.
     IntBlockPool与ByteBlockPool结合非常紧密, 从代码中就可以看得出来:
1: intUptos = intPool.
2: intUptoStart = intPool.intU
3: intPool.intUpto += streamC
5: p.intStart = intUptoStart + intPool.intO
7: for(int i=0;i&streamCi++) {
final int upto = bytePool.newSlice(ByteBlockPool.FIRST_LEVEL_SIZE);
intUptos[intUptoStart+i] = upto + bytePool.byteO
11: p.byteStart = intUptos[intUptoStart];
13: consumer.newTerm(p);
15: else {
16: intUptos = intPool.buffers[p.intStart && DocumentsWriter.INT_BLOCK_SHIFT];
17: intUptoStart = p.intStart & DocumentsWriter.INT_BLOCK_MASK;
18: consumer.addTerm(p);
    streamCount就是表示使用几个int表示偏移指针. intUptos就是一个int[], 保留当前的&层&,  下面研究一下这个for循环:
1: for(int i=0;i&streamCi++) {
final int upto = bytePool.newSlice(ByteBlockPool.FIRST_LEVEL_SIZE);
intUptos[intUptoStart+i] = upto + bytePool.byteO
    newSlice就是为bytePool分配一个int大小的空间, FIRST_LEVEL_SIZE为5个byte, 如果按这个程序运行, intUptos[intUptoStart]的值与bytePool的byteUpto并不一致, 要小了5. 这样说吧. 我来画一个例子
....../xxxxxx/…… : in memory
      ^(A),xxxxxx为一段数据
……A, 指向的应该是这段数据的开始位置, 所以int的Upto要比byte的Upto小了一个size的大小, 这个size就是bytePool对应的这段数据的长度.
    接下来的问题是: 当对内存进行数据的写入的时候, 分配的内存不够怎么办呢, 之前已经说了, bytePool是存储单词出现的位置的, 但是在分配内存的时候, 却不知道单词将会出现多少次, 所以必然会出现扩展内存的情况, 下面举一个例子:
    AA. . .B . . . C . . .这样的一个buffer, 假设现在要在B后面写入4位, 但是B却只有3位的剩余空间了, 怎么办呢, 首先我们分配一个更大的片(slice), 具体的slice的大小可以参见levelSizeArray[], 然后把B的后三位复制到新的slice中, 并且把B的后三位改成一个offset, 指向新的slice, 可能看起来是这样的:
    AA. . .B offset C . . . (new B): B B B B, 这段程序请见TermsHashPerField中的writeByte.
    不过说起来, 这段Pool相关的代码写得也确实恶心了一点, 很容易让人糊涂, 而且注释也是很金贵的.
    另外在Lucene中还广泛应用的就是RawPostingList[]这样类似于数组的hash形式, 之前一直觉得很奇怪, 为什么作者不能用泛型的hashMap呢, 想了想, 觉得第一个这样做会造成一些不必要的时间开销, 另外要是需要对这个hash排序就不是那样的友好了. 这种hash形式确实很不错哦.
阅读(...) 评论()注明：本文是由本人在开发有关基于lucene资源检索系统时的一点总结，其中一部分是自己根据开发过程自己总结的，也有部分是摘自网络，因无法获取当时摘文的地址，所以在此没有写源地址。
转载请声明出处
Lucene-3.0.0配置
一、Lucene开发环境配置
step1.Lucene开发包下载
step2.Java开发环境配置
step3.Tomcat安装
step4.Lucene开发环境配置
解压下载的lucene-3.0.0.zip，可以看到lucene-core-3.0.0.jar和lucene-demos-3.0.0.jar这两个文件,将其解压(建议放在安装jdk的lib文件夹内)，并把路径添加到环境变量的classpath。
二、Lucene开发包中Demo调试
控制台应用程序
step1.建立索引
&java org.apache.lucene.demo.IndexFiles [C:\Java](已经存在的任意文件路径)
将对C:\Java下所有文件建立索引，同时，在当前命令行位置将生成index文件夹。
step2.执行查询
&java org.apache.lucene.demo.SearchFiles
将会出现Query:提示符，在其后输入关键字，回车，即可得到查询结果。
Web应用程序
step1.将lucene-core-3.0.0.jar和lucene-demos-3.0.0jar这两个文件复制到安装Tomcat 的\common\lib中
step2.解压下载的lucene-3.0.0.zip，可以看到luceneweb.war文件。将该文件复制到安装Tomcat的\webapps
step3.重启Tomcat服务器。
step4.建立索引
&java org.apache.lucene.demo.IndexHTML -create -index [索引数据存放路径] [被索引文件路径]（如：D:\lucene\temp\index D:\lucene\temp\docs）
step5.打开安装Tomcat的\webapps\luceneweb\configuration.jsp文件，找到String indexLocation = "***"，将"***"改为第四步中[索引数据存放路径]，保存关闭。
step6.执行查询
在文本框中输入关键字，执行，即可得到查询结果。
说明：本文采用lucene-3.0.0版本，运行step6 时查询报错，根据提示将安装Tomcat的webapps\luceneweb\results.jsp 中
QueryParser qp = new QueryParser("contents", analyzer);
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT,"contents", analyzer);
注：本文参考
总结一下lucene的环境搭建，查看以及了解lucene的原理，对其有个大概的了解。
1、下载lucene2.3.2
2、下载jdk1.6
3、下载tomcat
下载以上内容完成后，开始安装。
1、安装jdk
一路确定下去，无需选择。
2、安装tomcat
一路确定下去，无需选择。
3、解压文件即可
假设解压文件路径为d:\lucene\
现在可以建立目录(此处的目录为我们要进行检索的信息的原始数据文件，我们放置在docs中，还有一个是lucene生成的检索信息，我们放置于index中)，即可以在d:\lucene下建立一个temp\docs以及temp\index，此处两个文件夹目录可以随意，当然不一定非得放置于d:\lucene。
然后将需要检索的原始数据文件放置于docs文件夹中。
拷贝解压的lucene文件夹中的lucene-core-2.3.2.jar以及lucene-demos-2.3.2.jar到temp文件夹中，解压。
如果没有配置jdk环境，参考下方：
打开我的电脑-属性-高级-环境变量：
在系统变量中添加：
JAVA＿HOME C:\Program Files\Java\jdk1.6.0
PATH %JAVA_HOME%\bin
CLASSPATH .;%JAVA_HOME%\lib\tools.%JAVA_HOME%\jre\lib\rt.
打开命令行：将目录定位到temp文件夹。
输入命令：
java org.apache.lucene.demo.IndexHTML -create -index D:\lucene\temp\index D:\lucene\temp\docs
即建立索引与原始数据文件的关系。
完成后，会发现index文件夹中多处一部分数据，以后再研究。
然后找到tomcat的安装目录，拷贝lucene中的luceneweb.war进入tomcat的webapps\文件夹中，启动tomcat，会看见webapps\下多出一个文件夹，找到configuration.jsp文件，将其中的String indexLocation = "/opt/lucene/index"；修改为String indexLocation = "D:/lucene/temp/index"；就是刚才生成的文件。
打开浏览器，输入
输入需要查询的信息，看看结果如何。
简单地说：首先建立索引文件放置目录，cmd命令生成索引文件，部署工程，修改工程文件中目标为索引文件目录。
搜索引擎的组成
　搜索引擎一般由搜索器、索引器、检索器和四个部分组成：
　　其功能是在互联网中漫游，发现和搜集信息；
　　其功能是理解搜索器所搜索到的信息，从中抽取出索引项，用于表示文档以及生成文档库的索引表；
　　其功能是根据用户的查询在索引库中快速检索文档，进行相关度评价，对将要输出的结果排序，并能按用户的查询需求合理反馈信息；
　　其作用是接纳用户查询、显示查询结果、提供个性化查询项。
d:\lucene\index是上一篇学习笔记（[] ）中生成的索引文件的存放地址。具体步骤简介如下：
1、创建Directory对象，索引文件夹
2、创建IndexSearch对象，建立查询（参数是Directory对象）
3、创建QueryParser对象（lucene版本，查询Field字段，所用分词器）
4、生成Query对象，由QueryParser对象的parse函数生成（参数是所查的关键字）
5、建立TopDocs对象（IndexSearch的search函数，参数是Query查询对象，）
6、TopDocs对象数组里存放查询信息
7、关闭IndexSearch
索引创建和搜索过程所一个总结
Lucene教程
Lucene是apache组织的一个用java实现全文搜索引擎的开源项目。 其功能非常的强大，api也很简单。总得来说用Lucene来进行建立 和搜索和操作是差不多的(有点像)，Document可以看作是 数据库的一行记录，Field可以看作是数据库的字段。用lucene实 现搜索引擎就像用JDBC实现连接数据库一样简单。
Lucene2.0，它与以前广泛应用和介绍的Lucene 1.4.3并不兼容。 Lucene2.0的下载地址是
1、在windows系统下的的C盘，建一个名叫s的文件夹,在该文件夹里面随便建三个txt文件，随便起名啦，就叫"1.txt","2.txt"和"3.txt"啦
其中1.txt的内容如下：
中华人民共和国
而"2.txt"和"3.txt"的内容也可以随便写几写，这里懒写，就复制一个和1.txt文件的内容一样吧
2、下载lucene包，放在classpath路径中
lighter.javaeye.
java.io.BufferedR
java.io.FileInputS
java.io.IOE
java.io.InputStreamR
java.util.D
org.apache.lucene.analysis.A
org.apache.lucene.analysis.standard.StandardA
org.apache.lucene.document.D
org.apache.lucene.document.F
org.apache.lucene.index.IndexW
/** */ /**
* author lighter date
TextFileIndexer
main(String[] args)
指明要索引文件夹的位置,这里是C盘的S文件夹下
File fileDir
File( " c://s " );
这里放索引文件的位置
File indexDir
File( " c://index " );
Analyzer luceneAnalyzer
StandardAnalyzer();
//建立一个标准分析器
IndexWriter indexWriter
IndexWriter(indexDir, luceneAnalyzer,
//创建一个索引器
File[] textFiles
fileDir.listFiles();
Date().getTime();
//增加document到索引去
textFiles. i ++ )
(textFiles[i].isFile()
textFiles[i].getName().endsWith( " .txt " ))
System.out.println( " File
textFiles[i].getCanonicalPath()
"正在被索引 . " );
String temp
FileReaderAll(textFiles[i].getCanonicalPath(),
" GBK " );
System.out.println(temp);
Document document
Document();
//Document是一个记录。用来表示一个条目。就是搜索建立的倒排索引的条目。比如说，你要搜索自己电脑上的文件。这个时候就可以创建。然后用组合成 。最后会变成若干文件。这个和 文件系统不是一个概念。
Field FieldPath
Field( " path " , textFiles[i].getPath(),
Field.Store.YES, Field.Index.NO);
//创建一个字段
Field FieldBody
Field( " body " , temp, Field.Store.YES,
Field.Index.TOKENIZED,
Field.TermVector.WITH_POSITIONS_OFFSETS);
document.add(FieldPath);
document.add(FieldBody);
indexWriter.addDocument(document);
// optimize()方法是对索引进行优化
indexWriter.optimize();
indexWriter.close();
//测试一下索引的时间
Date().getTime();
System.out
.println( "这花费了 "
startTime)
毫秒来把文档增加到索引里面去! "
fileDir.getPath());
String FileReaderAll(String FileName, String charset)
IOException
BufferedReader reader
BufferedReader( new
InputStreamReader(
FileInputStream(FileName), charset));
String line
String temp
reader.readLine())
reader.close();
索引的结果：
File C:/s/ 1 .txt正在被索引 .
中华人民共和国全国人民2006年
File C:/s/ 2 .txt正在被索引 .
中华人民共和国全国人民2006年
File C:/s/ 3 .txt正在被索引 .
中华人民共和国全国人民2006年
这花费了297 毫秒来把文档增加到索引里面去 ! c:/s
3、建立了索引之后，查询啦....
lighter.javaeye.
java.io.IOE
org.apache.lucene.analysis.A
org.apache.lucene.analysis.standard.StandardA
org.apache.lucene.queryParser.ParseE
org.apache.lucene.queryParser.QueryP
org.apache.lucene.search.H
org.apache.lucene.search.IndexS
org.apache.lucene.search.Q
main(String[] args)
IOException, ParseException
String queryString
Query query
IndexSearcher searcher
IndexSearcher( " c://index " );
Analyzer analyzer
StandardAnalyzer();
QueryParser qp
QueryParser( " body " , analyzer);
qp.parse(queryString);
(ParseException e)
searcher.search(query);
(hits.length()
System.out.println( "找到: "
hits.length()
个结果! " );
其运行结果：
Lucene其实很简单的,它最主要就是做两件事:建立索引和进行搜索
来看一些在lucene中使用的术语,这里并不打算作详细的介绍,只是点一下而已----因为这一个世界有一种好东西，叫搜索。
IndexWriter:lucene中最重要的的类之一，它主要是用来将文档加入索引，同时控制索引过程中的一些参数使用。
Analyzer:分析器,主要用于分析搜索引擎遇到的各种文本。常用的有StandardAnalyzer分析器,StopAnalyzer分析器,WhitespaceAnalyzer分析器等。
Directory:索引存放的位置;lucene提供了两种索引存放的位置，一种是磁盘，一种是内存。一般情况将索引放在磁盘上；相应地lucene提供了FSDirectory和RAMDirectory两个类。
Document:文档;Document相当于一个要进行索引的单元，任何可以想要被索引的文件都必须转化为Document对象才能进行索引。
Field：字段。
IndexSearcher:是lucene中最基本的检索工具，所有的检索都会用到IndexSearcher工具;
Query:查询，lucene中支持模糊查询，语义查询，短语查询，组合查询等等,如有TermQuery,BooleanQuery,RangeQuery,WildcardQuery等一些类。
QueryParser:是一个解析用户输入的工具，可以通过扫描用户输入的字符串，生成Query对象。
Hits:在搜索完成之后，需要把搜索结果返回并显示给用户，只有这样才算是完成搜索的目的。在lucene中，搜索的结果的集合是用Hits类的实例来表示的。
上面作了一大堆名词解释，下面就看几个简单的实例吧:
1、简单的的StandardAnalyzer测试例子
lighter.javaeye.
java.io.IOE
java.io.StringR
org.apache.lucene.analysis.A
org.apache.lucene.analysis.T
org.apache.lucene.analysis.TokenS
org.apache.lucene.analysis.standard.StandardA
StandardAnalyzerTest
//构造函数，
StandardAnalyzerTest()
main(String[] args)
//生成一个StandardAnalyzer对象
Analyzer aAnalyzer
StandardAnalyzer();
//测试字符串
StringReader sr
StringReader( " lighter javaeye com is the are on " );
//生成TokenStream对象
TokenStream ts
aAnalyzer.tokenStream( " name " , sr);
ts.next();
while (t != null )
//辅助输出时显示行号
//输出处理后的字符
System.out.println( "第 " + i + "行: " + t.termText());
//取得下一个字符
t = ts.next();
(IOException e)
e.printStackTrace();
显示结果：
第1行:lighter
第2行:javaeye
提示一下：
StandardAnalyzer是lucene中内置的"标准分析器",可以做如下功能:
1、对原有句子按照空格进行了分词
2、所有的大写字母都可以能转换为小写的字母
3、可以去掉一些没有用处的单词，例如"is","the","are"等单词，也删除了所有的标点
查看一下结果与"new StringReader("lighter javaeye com is the are on")"作一个比较就清楚明了。
这里不对其API进行解释了，具体见lucene的官方文档。需要注意一点，这里的代码使用的是lucene2的API，与1.43版有一些明显的差别。
2、看另一个实例,简单地建立索引，进行搜索
lighter.javaeye.
org.apache.lucene.analysis.standard.StandardA
org.apache.lucene.document.D
org.apache.lucene.document.F
org.apache.lucene.index.IndexW
org.apache.lucene.queryParser.QueryP
org.apache.lucene.search.H
org.apache.lucene.search.IndexS
org.apache.lucene.search.Q
org.apache.lucene.store.FSD
FSDirectoryTest
//建立索引的路径
String path
" c://index2 " ;
main(String[] args)
Document doc1
Document();
Field( " name " ,
" lighter javaeye com " ,Field.Store.YES,Field.Index.TOKENIZED));
Document doc2
Document();
doc2.add( new
Field( " name " ,
" lighter blog " ,Field.Store.YES,Field.Index.TOKENIZED));
IndexWriter writer
IndexWriter(FSDirectory.getDirectory(path,
StandardAnalyzer(),
writer.setMaxFieldLength( 3 );
writer.addDocument(doc1);
writer.setMaxFieldLength( 3 );
writer.addDocument(doc2);
writer.close();
IndexSearcher searcher
IndexSearcher(path);
Query query
QueryParser qp
QueryParser( " name " , new
StandardAnalyzer());
qp.parse( " lighter " );
searcher.search(query);
System.out.println( "查找/ " lighter/ "
hits.length()
"个结果 " );
qp.parse( " javaeye " );
searcher.search(query);
System.out.println( "查找/ " javaeye/ "
hits.length()
"个结果 " );
运行结果：
查找 " lighter "
查找 " javaeye "
到现在我们已经可以用lucene建立索引了
下面介绍一下几个功能来完善一下：
1．索引格式
其实索引目录有两种格式，
一种是除配置文件外，每一个Document独立成为一个文件（这种搜索起来会影响速度）。
另一种是全部的Document成一个文件，这样属于复合模式就快了。
2.索引文件可放的位置：
索引可以存放在两个地方1.硬盘，2.内存
放在硬盘上可以用FSDirectory()，放在内存的用RAMDirectory()不过一关机就没了
FSDirectory.getDirectory(File file,
FSDirectory.getDirectory(String path,
两个工厂方法返回目录
New RAMDirectory()就直接可以
IndexWriter(Directory d, Analyzer a,
一配合就行了
IndexWrtier indexWriter
IndexWriter(FSDirectory.getDirectory(c://index, true ), new
StandardAnlyazer(), true );
IndexWrtier indexWriter
IndexWriter( new
RAMDirectory(), new
StandardAnlyazer(), true );
3.索引的合并
IndexWriter.addIndexes(Directory[] dirs)
将目录加进去
来看个例子:
UniteIndex()
IOException
IndexWriter writerDisk
IndexWriter(FSDirectory.getDirectory( " c://indexDisk " ,
true ), new
StandardAnalyzer(), true );
Document docDisk
Document();
docDisk.add( new
Field( " name " , "程序员之家 " ,Field.Store.YES,Field.Index.TOKENIZED));
writerDisk.addDocument(docDisk);
RAMDirectory ramDir
RAMDirectory();
IndexWriter writerRam
IndexWriter(ramDir, new
StandardAnalyzer(), true );
Document docRam
Document();
docRam.add( new
Field( " name " , "程序员杂志 " ,Field.Store.YES,Field.Index.TOKENIZED));
writerRam.addDocument(docRam);
writerRam.close(); //这个方法非常重要，是必须调用的
writerDisk.addIndexes( new
Directory[] {ramDir} );
writerDisk.close();
UniteSearch()
ParseException, IOException
QueryParser queryParser
QueryParser( " name " , new
StandardAnalyzer());
Query query
queryParser.parse( "程序员 " );
IndexSearcher indexSearcher
IndexSearcher( " c://indexDisk " );
indexSearcher.search(query);
System.out.println( "找到了 " + hits.length() + "结果 " );
Document doc
hits.doc(i);
System.out.println(doc.get( " name " ));
这个例子是将内存中的索引合并到硬盘上来.
注意：合并的时候一定要将被合并的那一方的IndexWriter的close()方法调用。
4.对索引的其它操作:
IndexReader类是用来操作索引的，它有对Document,Field的删除等操作。
下面一部分的内容是：全文的搜索
全文的搜索主要是用：IndexSearcher,Query,Hits,Document(都是Query的子类),有的时候用QueryParser
主要步骤：
QueryParser(Field字段， new
2 .Query query
QueryParser.parser(要查询的字串”);这个地方我们可以用反射api看一下query究竟是什么类型
IndexSearcher(索引目录).search(query);返回Hits
4 .用Hits.doc(n);可以遍历出Document
5 .用Document可得到Field的具体信息了。
其实1　，2两步就是为了弄出个Query实例，究竟是什么类型的看分析器了。
拿以前的例子来说吧
QueryParser queryParser
QueryParser( " name " , new
StandardAnalyzer());
Query query
queryParser.parse( "程序员 " );
/**/ /*这里返回的就是org.apache.lucene.search.PhraseQuery */
IndexSearcher indexSearcher
IndexSearcher( " c://indexDisk " );
indexSearcher.search(query);
不管是什么类型，无非返回的就是Query的子类，我们完全可以不用这两步直接new个Query的子类的实例就ok了，不过一般还是用这两步因为它返回的是PhraseQuery这个是非常强大的query子类它可以进行多字搜索用QueryParser可以设置各个关键字之间的关系这个是最常用的了。
IndexSearcher:
其实IndexSearcher它内部自带了一个IndexReader用来读取索引的，IndexSearcher有个close()方法，这个方法不是用来关闭IndexSearche的是用来关闭自带的IndexReader。
QueryParser呢可以用parser.setOperator()来设置各个关键字之间的关系（与还是或）它可以自动通过空格从字串里面将关键字分离出来。
注意：用QueryParser搜索的时候分析器一定的和建立索引时候用的分析器是一样的。
可以看一个lucene2.0的帮助文档有很多的子类:
BooleanQuery, ConstantScoreQuery, ConstantScoreRangeQuery, DisjunctionMaxQuery, FilteredQuery, MatchAllDocsQuery, MultiPhraseQuery, MultiTermQuery, PhraseQuery, PrefixQuery, RangeQuery, SpanQuery, TermQuery
各自有用法看一下文档就能知道它们的用法了
下面一部分讲一下lucene的分析器:
分析器是由分词器和过滤器组成的，拿英文来说吧分词器就是通过空格把单词分开，过滤器就是把the,to,of等词去掉不被搜索和索引。
我们最常用的是StandardAnalyzer()它是lucene的标准分析器它集成了内部的许多的分析器。
最后一部分了：lucene的高级搜索了
Lucene有内置的排序用IndexSearcher.search(query,sort)但是功能并不理想。我们需要自己实现自定义的排序。
这样的话得实现两个接口: ScoreDocComparator, SortComparatorSource
用IndexSearcher.search(query,new Sort(new SortField(String Field,SortComparatorSource)));
就看个例子吧：
这是一个建立索引的例子：
IndexSort()
IOException
IndexWriter writer
IndexWriter( " C://indexStore " , new
StandardAnalyzer(), true );
Document doc
Document()
doc.add( new
Field( " sort " , " 1 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
Document();
doc.add( new
Field( " sort " , " 4 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
Document();
doc.add( new
Field( " sort " , " 3 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
Document();
doc.add( new
Field( " sort " , " 5 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
Document();
doc.add( new
Field( " sort " , " 9 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
Document();
doc.add( new
Field( " sort " , " 6 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
Document();
doc.add( new
Field( " sort " , " 7 " ,Field.Store.YES,Field.Index.TOKENIZED));
writer.addDocument(doc);
writer.close();
下面是搜索的例子:
public void SearchSort1() throws IOException, ParseException
IndexSearcher indexSearcher = new IndexSearcher("C://indexStore");
QueryParser queryParser = new QueryParser("sort",new StandardAnalyzer());
Query query = queryParser.parse("4");
Hits hits = indexSearcher.search(query);
System.out.println("有"+hits.length()+"个结果");
Document doc = hits.doc(0);
System.out.println(doc.get("sort"));
public void SearchSort2() throws IOException, ParseException
IndexSearcher indexSearcher = new IndexSearcher("C://indexStore");
Query query = new RangeQuery(new Term("sort","1"),new Term("sort","9"),true);//这个地方前面没有提到，它是用于范围的Query可以看一下帮助文档.
Hits hits = indexSearcher.search(query,new Sort(new SortField("sort",new MySortComparatorSource())));
System.out.println("有"+hits.length()+"个结果");
for(int i=0;i
Document doc = hits.doc(i);
System.out.println(doc.get("sort"));
public class MyScoreDocComparator implements ScoreDocComparator
private Integer[]
public MyScoreDocComparator(String s,IndexReader reader, String fieldname) throws IOException
sort = new Integer[reader.maxDoc()];
for(int i = 0;i
Document doc =reader.document(i);
sort[i]=new Integer(doc.get("sort"));
public int compare(ScoreDoc i, ScoreDoc j)
if(sort[i.doc]&sort[j.doc])
if(sort[i.doc]
return -1;
public int sortType()
return SortField.INT;
public Comparable sortValue(ScoreDoc i)
// TODO自动生成方法存根
return new Integer(sort[i.doc]);
public class MySortComparatorSource implements SortComparatorSource
private static final long serialVersionUID = -7968361L;
public ScoreDocComparator newComparator(IndexReader reader, String fieldname)
throws IOException
if(fieldname.equals("sort"))
return new MyScoreDocComparator("sort",reader,fieldname);
SearchSort1()输出的结果没有排序,SearchSort2()就排序了。
2.多域搜索MultiFieldQueryParser
如果想输入关键字而不想关心是在哪个Field里的就可以用MultiFieldQueryParser了
用它的构造函数即可后面的和一个Field一样。
MultiFieldQueryParser. parse(String[] queries, String[] fields, BooleanClause.Occur[] flags, Analyzer analyzer)
~~~~~~~~~~~~~~~~~
第三个参数比较特殊这里也是与以前lucene1.4.3不一样的地方
看一个例子就知道了
String[] fields = {"filename", "contents", "description"};
BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
BooleanClause.Occur.MUST,//在这个Field里必须出现的
BooleanClause.Occur.MUST_NOT};//在这个Field里不能出现
MultiFieldQueryParser.parse("query", fields, flags, analyzer);
1、lucene的索引不能太大，要不然效率会很低。大于1G的时候就必须考虑分布索引的问题
2、不建议用多线程来建索引，产生的互锁问题很麻烦。经常发现索引被lock，无法重新建立的情况
3、中文分词是个大问题，目前免费的分词效果都很差。如果有能力还是自己实现一个分词模块，用最短路径的切分方法，网上有教材和demo源码，可以参考。
4、建增量索引的时候很耗cpu，在访问量大的时候会导致cpu的idle为0
5、默认的评分机制不太合理，需要根据自己的业务定制
整体来说lucene要用好不容易，必须在上述方面扩充他的功能，才能作为一个商用的搜索引擎
争取每日记录一些
Index.ANALYZED 索引并分词(适用于body, title, abstract等.).
Index.NOT_ANALYZED 索引但不分词,可以使用NORM方式.(可以人为干预提权)
Index.ANALYZED_NO_NORMS 索引并分词但不使用NORM方式(不可认为提权)
Index.NOT_ANALYZED_NO_NORMS 索引但不分词也不使用NORM方式(经常用到,存储标志值最好的方式.)
Index.NO 不索引
Store.YES 存储
TermVector选项
(除TermVector.NO外其他必须要求Index选项为Index.ANALYZED或Index.NOT_ANALYZED)
TermVector.YES 最基本的向量存储(特殊性,数量,在哪个文档)
TermVector.WITH_POSITIONS TermVector.YES+位置
TermVector.WITH_OFFSETS TermVector.YES+偏移
TermVector.WITH_POSITIONS_OFFSETS TermVector.YES+位置+偏移
TermVector.NO 不做向量存储
各选项组合应用场景
TermVector
NOT_ANALYZ
Technorati 标签:
ED_NO_NORMS
主键,电话,身份证号,URLs,日期和需要排序的字段
WITH_POSITIONS_OFFSETS
文档标题,摘要.
WITH_POSITIONS_OFFSETS
文档类型,数据库主键(如果不需要检索该字段的话)
NOT_ANALYZED
排序的注意事项
如果需要排序的字段是数字就用NumericField,如果是文本,一定要记得使用FIELD.Index.NOT_ANALYZED.
如果不需要提权则应该使用NOT_ANALYZED_NO_NORMS
多值字段的保存
在同一个Document下可以给同一个字段赋不同的值.例如
Document doc = new Document();
for (int i = 0; i & authors. i++) {
doc.add(new Field("author", authors[i],
Field.Store.YES,
Field.Index.ANALYZED));
LUCENE.NET QQ交流群()
被索引的文档用Document对象表示。
IndexWriter通过函数addDocument将文档添加到索引中，实现
创建索引的过程。
Lucene的索引是应用反向索引。
当用户有请求时，Query代表用户的查询语句。
IndexSearcher通过函数search搜索Lucene Index。
IndexSearcher计算term weight和score并且将结果返回给用户。
返回给用户的文档集合用TopDocsCollector表示。
Lucene搜索的的类主要有个 （包括子类）
一是搜索的入口，他的方法提供了搜索功能
Query有很多子类， 各种不同的子类代表了不同的查询条件下文详述
QueryParser是一个非常通用的帮助类，他的作用是把用户输入的文本转换为内置的对象（大多数搜索引擎都提供一个查询输入框来让用户输入查询条件）。内置提供了很多语法来使使用可以输入各种高级条件的。比如会被解析为一个关系的，他包含两个和。这些语法虽然强大，但都针对英文设计，对我们需要中文搜索来说都不需要了解太多的类型，一般几个简单的就够用了。的使用如下
QueryParser.parse(String query, String field, Analyzer analyzer) throws ParseException
其中：是用户输入的内容是搜索默认的（其他需要显式指定），是用来将用户输入的内容也作分析处理（分词），一般情况下这里的是的时候采用的同一。
另外我们也可以自己构造一个含义同上这样做的好处是可以自己定义调整一些参数
搜索结果的处理对象
Hits对象是搜索结果的集合 主要有下面几个方法
length() ,这个方法记录有多少条结果返回
doc(n) 返回第个记录
id(in) 返回第个记录的
score(n) 第个记录的相关度积分
由于搜索的结果一般比较大，从性能上考虑，对象并不会真正把所有的结果全部取回，默认情况下是保留前个记录对于一般的搜索引擎个记录足够了
分页的处理
100条记录还是太多，我们多半会每页显示条记录，然后分为若干页显示，对于分页，一般有两个办法
在中保留对象和对象，翻页的时候提取内容
不使用，每次都简单处理为重新查询
lucene推荐先使用第二个办法，即每次都重新查询，这样做的好处是简单方便，不需要考虑的问题，的查询效率也能保证每次查询时间不长，除非真正有了性能问题，否则不用考虑第一个办法。
缓存：的用法
RAMDirectory对象很好用，通过它，我们可以把一个普通的完全读取到内存中用法如下：
RAMDirectory ramDir = new RAMDirectory(dir);
这样的效率自然比真正的文件系统快很多
lucence查询的纪录默认按照相关度排序，这个相关度就是的算法是比较复杂的对于我们做应用的人似乎没有什么帮助，（先说一下我的理解是为一个独立的查询词用户输入的的查询通过各种分词，大小写处理正规化消除等）以后，会已为基本单位），几个关键参数稍微留意一下即可。
Term在文章中出现的频率量包含同一个的文章的频率
field中的参数
term的长度
term在文章中的数量
一般来说这些参数我们都不可能去调整如果你想了解更多还提供了一个方法通过传入一个和你可以得到一个对象他是对内部算法信息的简单封装一下就可以看到详细的说明
二创建各种介绍
TermQuery最普通用就可以构造
TermQuery把查询条件视为一个要求和查询内容完全匹配比如类型就可以使用
RangeQuery
RangeQuery表示一个范围的搜索条件
最后一个值表示是否包含边界条件本身用字符表示为或者
PrefixQuery
顾名思义就是表示以某某开头的查询字符表示为
BooleanQuery
这个是一个组合的你可以把各种添加进去并标明他们的逻辑关系添加条件用
public void add(Query query, boolean required, boolean prohibited)
方法后两个变量是标示三种关系 字符表示为或 一个中可以添加多个如果超过的值默认个的话会抛出错误
PhraseQuery
表示不严格语句的查询比如要匹配等所以提供了一个参数在查询中会尝试调整单词的距离和位置这个参数表示可以接受调整次数限制如果实际的内容可以在这么多步内调整为完全匹配那么就被视为匹配在默认情况下的值是所以默认是不支持非严格匹配的通过设置参数比如匹配就需要个来把后移动位我们可以让来模糊查询值得注意的是不保证前后单词的次序在上面的例子中需要个也就是如果如果大于等于那么也会被认为是匹配的
WildcardQuery
使用和来表示一个或多个字母比如可以匹配 值得注意的是在中只要是匹配上的纪录他们的相关度都是一样的比如和的对于的相关度就是一样的
FuzzyQuery
这个对中文没有什么用处他能模糊匹配英文单词前面的都是词组比如和他们可以看成类似对于英文的各种时态变化和复数形式这个还算有用匹配结果的相关度是不一样的字符表示为
对于搜索引擎很多情况下用户只需要一个输入框就要输入所有的查询条件比如这时就派上用场了他的作用就是把各种用户输入转为或者组他把上面提到的的字符表示转化为实际的对象比如就会转换为不过用到了所以过后的再未必和原来的一样额外的语法有
比如就是括号分组很容易理解
FieldSelectiong
QueryParser的查询条件是对默认的进行的它在解析的时候编码指定如果用户需要在查询条件中选用另外的可以使用如下语法如果是多个分组可以用表示
QueryParse默认不允许号出现在开始部分，这样做的目的主要是为了防止用户误输入来头导致严重的性能问题（会把所有记录读出）
通过可以对这个进行，我想不到什么用户会这样么
QueryParser是一个准备好的立即可以工作的帮助类不过他还是提供了很多参数供程序员调整，首先我们需要自己构造一个新的然后对他的各种参数来定制化
Lucene分析
1.创建索引的步骤：
1）把要转换为索引的磁盘上的文件转换为文档：
Document doc = File2DocumentUtils.file2Document(filePath);
public static Document file2Document(String filePath) {
// TODO Auto-generated method stub
File file = new File(filePath);
Document doc = new Document();
doc.add(new Field("name", file.getName(), Store.YES, Index.ANALYZED));
doc.add(new Field("content", readFileContent(file), Store.YES,
Index.ANALYZED));
doc.add(new Field("size", String.valueOf(file.length()), Store.YES,
Index.ANALYZED));
doc.add(new Field("path", file.getAbsolutePath(), Store.YES,
Index.ANALYZED));
读取文件内容代码
public static String readFileContent(File file) {
// TODO Auto-generated method stub
BufferedReader br = new BufferedReader(new InputStreamReader(
new FileInputStream(file)));
StringBuffer buffer = new StringBuffer();
for (S (line = br.readLine()) !=) {
buffer.append(line).append("\n");
return buffer.toString();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
2）创建IndexWriter
IndexWriter indexWriter = new IndexWriter(indexPath, analyzer, true,
new MaxFieldLength(10000));
IndexWriter是用来操作（增、删、改）索引库的
3）把document文档加到IndexWriter
indexWriter.addDocument(doc);
4）关闭IndexWriter
Indexwriter。Close（）；
2.在索引库的搜素步骤
1）把要搜索的索引解析为query
String querystring="document";
String []fields={"name","content"};
QueryParser parser=new MultiFieldQueryParser(fields,analyzer);
//QueryParser是一个解析用户输入的工具，可以扫描用户输入的字符串，生成query对象。
Query query=parser.parse(querystring);
2）进行查询
IndexSearcher indexSearcher=new IndexSearcher(indexPath);
Filter filter=
topDocs=indexSearcher.search(query,(org.apache.lucene.search.Filter) filter,10000);
System.out.println("总共有【"+topDocs.totalHits+"】条匹配结果");
注：TopDocs 根据关键字搜索整个索引库，然后对所有结果进行排序，然后取前00条结果
3）输出搜索结果
for(ScoreDoc scoreDoc:topDocs.scoreDocs){
int docSn=scoreDoc.//文档内部编号
Document doc=indexSearcher.doc(docSn);//根据编号取出相应的文档
File2DocumentUtils.printDocumentInfo(doc);//打印出文档信息
获取name属性的值的两种方法
1.Filed f=doc.getFiled("name");
f.stringValue();
2.doc.get("name")
public static void printDocumentInfo(Document doc){
//Filed f=doc.getFiled("name");
// f.stringValue();
System.out.println("-------------------------------------------");
System.out.println("name
="+doc.get("name"));
System.out.println("content ="+doc.get("content"));
System.out.println("size
="+doc.get("size"));
System.out.println("path
="+doc.get("path"));
http://blog.csdn.net/csh/article/details/6823209
Lucene6入门教程（一）简介和学习流程
工作中需要用到Lucene6这个全文检索工具，为项目的开发打下基础。花了比较多的时间熟悉了Lucene，原理，一些网上的案例，以及基本的API使用等，在这里给大家分享一下我关于Lucene6.4.1的...
lucene教程--全文检索技术详解
一 什么是全文检索
1.1 全文检索概念
全文检索是一种将文件中所有文本与检索项匹配的检索方法。它可以根据需要获得全文中有关章、节、段、句、词等信息。计算机程序通过扫描文章中的每一...
Lucene从入门到进阶（6.6.0版本）
Lucene从入门到进阶（6.6.0版本）
Lucene入门教程
Lucene教程
1 lucene简介
1.1 什么是lucene
Lucene是一个全文搜索框架，而不是应用产品。因此它并不像www.baidu.com 或者googl...
Lucene 6.2.1入门教程（一） 创建索引和基本搜索索引
简单说两句，Lucene现在高版本的教程很少，网上基本是4.0以下的，目前最新版是6.2.1，所以我试着来写写这个版本的教程。
至于那些概念什么的，我就不多说了，大家可以参考以前的旧教程来了解L...
Lucene教程--入门程序详解
Lucene 入门程序
实现一个歌词搜索系统，通过关键字搜索，凡是文件名或文件内容包括关键字的文件都要找出来。
注意：该入门程序只对文本文件(.txt)搜索。
lucene简明教程
http://www.yiibai.com/lucene/lucene_deletedocument.html
Apache Lucene全局搜索引擎入门教程
Lucene简介
Lucent：Apache软件基金会Jakarta项目组的一个子项目，Lucene提供了一个简单却强大的应用程式接口，能够做全文索引和搜寻。在Java开发环境里Lucene是...
Lucene教程--维护索引、查询对象和相关度排序
1 索引维护
1.1 添加索引
1）创建存放索引的目录Directory
2）创建索引器配置管理类IndexWriterConfig
3）使用索引目录和配置管理类创建索引器
*版权证明: 只允许上传png/jpeg/jpg/gif格式的图片,且小于3M
*详细原因:
交 &em&lucene&/em&详细使用&em&教程&/em& 3积分 立即下载 ...
没有更多推荐了，}