BlogJava--随笔分类-lucene

lucene实时搜索相关

leekiang — Mon, 22 Nov 2010 09:18:00 GMT

在做一个网站站内搜索中，使用lucene实现实时搜索时，我遇到了一对矛盾：在使用一个IndexSearcher单例时，搜索的效率极高，但是在 indexSearcher实例新建后新增的索引，这个单例是不可见的，除非我定时的去触发将这个IndexSearcher重新建一次，否则就不能搜索出最新的信息。假如我每来一个 request，就新建一个IndexSearcher实例，则可以搜索出最新的信息，但是，效率非常低。不知道大家有什么好的策略或插件，提出来讨论讨论。（我现在的策略是定时的reopen下insexSearcher）

可以使用这样的策略：
使用一个独立的线程去维护这个IndexSearcher,当索引有更新时，记录下索引已更新；当有request时，先去检验一下索引是否有更新，有则reopen后再查，无则直接查。

最简单的方法，用timer定时生成下indexSearcher，全文引擎有略微的延时也是可以接受的。

用2.3的包,有一个reopen()的方法,只会加载变化的索引片段。
每次索引更新之后，对于当前正在使用的IndexReader来说不是可见的，必须重新open一次Index，才能保证能够搜索到新加入的 document，2.3相当于做了一次增量的open。
每一次reopen前可以先判断一下是不是当前的索引文件,主要看有没有更新,
如果有更新,用reopen()方法打开,看它文档上说明是只加载更新了的索引文件,这样就不用全部重新打开了,时间主要耗在这里,如果判断结果是没有更新则直接返回那个实例就行了
IndexReader.reopen一直是没有实现的？

比如在你加了索引之后新生成一个searcher把那个单例给替换了，但是，当几十的并发增量索引过来的时候，就不能这么触发了，我现在只是弄了个timer，定时30秒钟来换个IndexSearcher实例。

the singleton of IndexSearcher will be more efficient.
see http://wiki.apache.org/lucene-java/ImproveSearchingSpeed

由于前一章所述的Lucene的事务性，使得Lucene可以增量的添加一个段，我们知道，倒排索引是有一定的格式的，而这个格式一旦写入是非常难以改变的，那么如何能够增量建索引呢？Lucene使用段这个概念解决了这个问题，对于每个已经生成的段，其倒排索引结构不会再改变，而增量添加的文档添加到新的段中，段之间在一定的时刻进行合并，从而形成新的倒排索引结构。
然而也正因为Lucene的事务性，使得Lucene的索引不够实时，如果想Lucene实时，则必须新添加的文档后IndexWriter需要commit，在搜索的时候IndexReader需要重新的打开，然而当索引在硬盘上的时候，尤其是索引非常大的时候，IndexWriter的commit操作和IndexReader的open操作都是非常慢的，根本达不到实时性的需要。
好在Lucene提供了RAMDirectory，也即内存中的索引，能够很快的commit和open，然而又存在如果索引很大，内存中不能够放下的问题。

所以要构建实时的索引，就需要内存中的索引RAMDirectory和硬盘上的索引 FSDirectory相互配合来解决问题。

Zoie 是linkedin支持的基于Lucene开源实时搜索引擎项目

Solr ( http://lucene.apache.org/solr/ )
说明：基于 Lucene 的企业级搜索的开箱即用的解决方案
优点：比较成熟的解决方案，也有很多的成功案例。Lucene 子项目，实现了大部分常见的搜索功能需求，包括 facet 搜索（搜索结果分类过滤）等。
缺点：可定制性比 Lucene 要差，一些不常见的需求，定制的难度比直接在 Lucene 上做要大的多。性能上，由于 Solr 的建索引和搜索是同一个进程，耦合度比较高，对于性能调优有一定的影响。

直接使用 Lucene ( http://lucene.apache.org )
说明：Lucene 是一个 JAVA 搜索类库，它本身并不是一个完整的解决方案，需要额外的开发工作
优点：成熟的解决方案，有很多的成功案例。apache顶级项目，正在持续快速的进步。庞大而活跃的开发社区，大量的开发人员。它只是一个类库，有足够的定制和优化空间：经过简单定制，就可以满足绝大部分常见的需求；经过优化，可以支持10亿+ 量级的搜索。
缺点：需要额外的开发工作。所有的扩展，分布式，可靠性等都需要自己实现；非实时，从建索引到可以搜索中间有一个时间延迟，而当前的“近实时” (Lucene Near Real Time search)搜索方案的可扩展性有待进一步完善

2.9新版本引入了IndexWriter.getReader()方法，它可用于搜索目前完整的索引，包括当前IndexWriter会话中还没有提交的改变，这带来了接近于实时搜索的能力。此外，你还可以调用IndexWriter.setMergedSegmentWarmer()方法进行“预热”，这样那些片断便可以立即投入使用了。

2.9版本之前的版本，都是基于文本搜索的，因为对于很多数字的处理方式就很头疼，例如在我们项目中遇到的很多问题都是由于把数字当作了文本处理出现的 BUG：1、搜索价格的5，把包含.5的也搜索出来了；2、排序（降序）时，把800排到5000前面；……这些都是由于Lucene把所有的都作为文本处理的方式造成的问题。Lucene 2.9以后已经自带对数字的处理方式。Field和Query类会采取合适的精度进行索引和搜索，这样大大降低了需要搜索的关键字数量，使查询的响应能力得以显著提高。

我们web应用是好几台机器，而索引也有好几种，如果用lucene的话，定时更新不能保证所有服务器同步。如果用mount方式，lucen也有问题，所以想用solr统一管理所有索引。然后让其它服务器从一个统一的地方查询索引。
http://lucene-group.group.javaeye.com/group/topic/23507

亿级数据的高并发通用搜索引擎架构设计 http://blog.s135.com/post/385/
http://lucene-group.group.javaeye.com/group/topic/2786
http://blog.fulin.org/2010/11/search_solutions_compare.html
http://www.javaeye.com/topic/117212
Twitter新搜索架构将采用开源Lucene http://cloud.csdn.net/a/20101008/280220.html?1286504886
用 Lucene构建实时的索引 http://www.cnblogs.com/forfuture1978/archive/2010/06/08/1753642.html
基于lucene实现自己的推荐引擎 http://blog.fulin.org/2010/10/recommendation_system_based_lucene.html
Lucene3.0(2.9)的主要变化 http://www.ourys.com/post/lucene3-0_about.html
Katta is a scalable, failure tolerant, distributed, data storage for real time access.

leekiang 2010-11-22 17:18 发表评论

lucene集群

leekiang — Fri, 19 Nov 2010 09:37:00 GMT

Lucene是作为嵌入式的工具包的形式出现的，在核心代码上没有提供对群集的支持。实现对Lucene的群集有三种方式：1、继承实现一个Directory；2、使用Solr 3、使用 Nutch+Hadoop；使用Solr你不得不用他的Index Server ，而使用Nutch你又不得不集成抓取的模块；
不选择使用lucene的6大原因 http://forchenyun.javaeye.com/blog/473779

Lucene集群 lucene in a cluster
http://blog.csdn.net/jsea/archive/2006/06/16/803043.aspx
http://hi.baidu.com/lucenehc/blog/item/4d83c387881ea22fc65cc3a1.html

Compass的Lucene Jdbc Directory implementation
Compass simplifies the creation of distributed Lucene index by allowing to store the Lucene index in a database, as well as storing the index simply with Data Grid products such as GigaSpaces, Coherence and Terracotta
这部分代码完全独立于Compass 的其他模块，可以使用在纯Lucene实现的环境中
http://robbank.blogbus.com/logs/3509279.html
http://robbank.blogbus.com/logs/4698460.html

solr本身支持分布式索引，是利用rsync来做的
http://paradise-qingfeng.javaeye.com/blog/123673

Nut是一个Lucene+Hadoop分布式搜索框架
http://code.google.com/p/nutla/
http://www.blogjava.net/nianzai/

Nutch 0.9版中，分布式搜索的核心部分只用了不到1000行代码就搞定了。
clustering是把查询请求分发到多台计算机上，主要是解决并发量的问题。
Distributed指的是多台计算机并行处理一个查询请求，使单个请求的检索时间降低
http://lucene-group.group.javaeye.com/group/topic/8983

谈谈Hadoop和分布式 Lucene http://www.chinacloud.cn/show.aspx?id=50&cid=12

1，Doug Cutting （Lucene－Nutch－Hadoop 创始人简介）http://zhutuncun0.javaeye.com/blog/746019
2，luke,lucene索引查看工具 http://code.google.com/p/luke/
3，Alfresco 看看这种CMS在集群环境下如何使用lucene
http://wiki.alfresco.com/wiki/Cluster_Configuration_V2.1.3_and_Later#Lucene_index_synchronization

leekiang 2010-11-19 17:37 发表评论

lucene线程相关

leekiang — Thu, 22 Jan 2009 07:29:00 GMT

1，Lucene 中的同步与线程安全
http://arbow.spaces.live.com/blog/cns!A25DE6AC7A5B029E!142.entry

附带:
MultiSearcher在多个索引上搜索

leekiang 2009-01-22 15:29 发表评论

lucene笔记之二

leekiang — Tue, 23 Dec 2008 15:22:00 GMT

1,范围查询，例如
Term begin=new Term("publishdate","1999-01-01");
Term end=new Term ("publishdate","1999-10-15");
RangeQuery q=new RangeQuery(begin,end,true);

1)，
Lucene-2.2.0 源代码阅读学习
2)
Lucene 中自定义排序的实现
3）
lucene学习笔记
4）
http://www.lucene.com.cn/sj.htm
5）LRU
LRU(最近最少使用算法) and MRU(最近最常使用算法) 所谓的LRU(Least recently used)算法的基本概念是:当内存的剩余的可用空间不够时,缓冲区尽可能的先保留使用者最常使用的数据,换句话说就是优先清除”较不常使用的数据”,并释放其空间.之所以”较不常使用的数据”要用引号是因为这里判断所谓的较不常使用的标准是人为的、不严格的.所谓的MRU(Most recently used)算法的意义正好和LRU算法相反.
oracle缓存用到了LRU
http://bluepopopo.javaeye.com/blog/180236
6，Apache lucene知识汇集
7，Lucene 2.3.1 阅读学习（41）
8，Lucene的score()实现
9，Lucene 的排序修改
10，6大原因让你不选择使用Lucene
11，解决lucene范围搜索中的TooManyClauses exception

leekiang 2008-12-23 23:22 发表评论

background merge hit exception错误

leekiang — Fri, 12 Sep 2008 10:37:00 GMT

Exception in thread "Thread-12" org.apache.lucene.index.MergePolicy$MergeException: java.io.FileNotFoundException: /doc/lucene/_5zk.fnm (没有该文件或目录 (errno:2))
   at org.apache.lucene.index.ConcurrentMergeScheduler$MergeThread.run(ConcurrentMergeScheduler.java:271)
Caused by: java.io.FileNotFoundException: /doc/lucene/_5zk.fnm (没有该文件或目录 (errno:2))
   at java.io.RandomAccessFile.open(Native Method)
   at java.io.RandomAccessFile.(RandomAccessFile.java:212)
   at org.apache.lucene.store.FSDirectory$FSIndexInput$Descriptor.(FSDirectory.java:506)
   at org.apache.lucene.store.FSDirectory$FSIndexInput.(FSDirectory.java:536)
   at org.apache.lucene.store.FSDirectory$FSIndexInput.(FSDirectory.java:531)
   at org.apache.lucene.store.FSDirectory.openInput(FSDirectory.java:440)
   at org.apache.lucene.index.FieldInfos.(FieldInfos.java:57)
   at org.apache.lucene.index.SegmentReader.initialize(SegmentReader.java:298)
   at org.apache.lucene.index.SegmentReader.get(SegmentReader.java:262)
   at org.apache.lucene.index.SegmentReader.get(SegmentReader.java:221)
   at org.apache.lucene.index.IndexWriter.mergeMiddle(IndexWriter.java:3093)
   at org.apache.lucene.index.IndexWriter.merge(IndexWriter.java:2834)
   at org.apache.lucene.index.ConcurrentMergeScheduler$MergeThread.run(ConcurrentMergeScheduler.java:240)
java.io.IOException: background merge hit exception: _5zk:C2223 _5zl:c1 _5zm:c1 _5zn:c1 into _5zo [optimize]
   at org.apache.lucene.index.IndexWriter.optimize(IndexWriter.java:1749)
   at org.apache.lucene.index.IndexWriter.optimize(IndexWriter.java:1689)
   at org.apache.lucene.index.IndexWriter.optimize(IndexWriter.java:1669)
   at com.lucene.index.ArticleIndex.addIndex(ArticleIndex.java:93)

   ------------------------------------------------------------------------
   Caused by: java.io.FileNotFoundException: /doc/lucene/_5zk.fnm (没有该文件或目录 (errno:2))
   at java.io.RandomAccessFile.open(Native Method)
   at java.io.RandomAccessFile.(RandomAccessFile.java:212)
   at org.apache.lucene.store.FSDirectory$FSIndexInput$Descriptor.(FSDirectory.java:506)
   at org.apache.lucene.store.FSDirectory$FSIndexInput.(FSDirectory.java:536)
   at org.apache.lucene.store.FSDirectory$FSIndexInput.(FSDirectory.java:531)
   at org.apache.lucene.store.FSDirectory.openInput(FSDirectory.java:440)
   at org.apache.lucene.index.FieldInfos.(FieldInfos.java:57)
   at org.apache.lucene.index.SegmentReader.initialize(SegmentReader.java:298)
   at org.apache.lucene.index.SegmentReader.get(SegmentReader.java:262)
   at org.apache.lucene.index.SegmentReader.get(SegmentReader.java:221)
   at org.apache.lucene.index.IndexWriter.mergeMiddle(IndexWriter.java:3093)
   at org.apache.lucene.index.IndexWriter.merge(IndexWriter.java:2834)
   at org.apache.lucene.index.ConcurrentMergeScheduler$MergeThread.run(ConcurrentMergeScheduler.java:240)
org.apache.lucene.index.MergePolicy$MergeException: java.io.FileNotFoundException: /doc/lucene/_5zk.fnm (没有该文件或目录 (errno:2))
   at org.apache.lucene.index.ConcurrentMergeScheduler$MergeThread.run(ConcurrentMergeScheduler.java:271)
Caused by: java.io.FileNotFoundException: /doc/lucene/_5zk.fnm (没有该文件或目录 (errno:2))
   at java.io.RandomAccessFile.open(Native Method)
   at java.io.RandomAccessFile.(RandomAccessFile.java:212)
   at org.apache.lucene.store.FSDirectory$FSIndexInput$Descriptor.(FSDirectory.java:506)
   at org.apache.lucene.store.FSDirectory$FSIndexInput.(FSDirectory.java:536)
   at org.apache.lucene.store.FSDirectory$FSIndexInput.(FSDirectory.java:531)
   at org.apache.lucene.store.FSDirectory.openInput(FSDirectory.java:440)
   at org.apache.lucene.index.FieldInfos.(FieldInfos.java:57)
   at org.apache.lucene.index.SegmentReader.initialize(SegmentReader.java:298)
   at org.apache.lucene.index.SegmentReader.get(SegmentReader.java:262)
   at org.apache.lucene.index.SegmentReader.get(SegmentReader.java:221)
   at org.apache.lucene.index.IndexWriter.mergeMiddle(IndexWriter.java:3093)
   at org.apache.lucene.index.IndexWriter.merge(IndexWriter.java:2834)
   at org.apache.lucene.index.ConcurrentMergeScheduler$MergeThread.run(ConcurrentMergeScheduler.java:240)
org.apache.lucene.store.LockObtainFailedException: Lock obtain timed out: SimpleFSLock@/doc/lucene/write.lock
   at org.apache.lucene.store.Lock.obtain(Lock.java:85)
   at org.apache.lucene.index.IndexWriter.init(IndexWriter.java:691)
   at org.apache.lucene.index.IndexWriter.(IndexWriter.java:502)
   at com.lucene.index.AttachIndex.addIndex(AttachIndex.java:80)
   at com.myapp.Article.uploadAttach(Article.java:793)
   at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
   at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
   at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
   at java.lang.reflect.Method.invoke(Method.java:585)

leekiang 2008-09-12 18:37 发表评论

lucene笔记

leekiang — Thu, 27 Mar 2008 08:15:00 GMT

1,Field.Store与Field.Index
Field.Store.COMPRESS:用压缩的格式存储最初的Field值
Field.Store.NO:不存储该Field的原始值
Field.Store.YES:存储该Field的原始值

Field.Index.NO:不索引Field的值
Field.Index.NO_NORMS:
Field.Index.TOKENIZED:作分词处理
Field.Index.UN_TOKENIZED:不分词，直接作为完整的信息段检索，可以支持全匹配和相似匹配，跟数据库中的like很类似。

2,实现Filter接口

    public BitSet bits(IndexReader reader) throws IOException {
        final BitSet bits = new BitSet(reader.maxDoc());// 默认所有都为false
        // 设置所有的都不能检索到
        // bits.set(0, bits.size() - 1, false);
        bits.set(3, true);
        bits.set(4);//设置为true
        int[] docs = new int[1000];
        int[] freqs = new int[1000];
        TermDocs termDocs = reader.termDocs(new Term("title", "测试"));
        int count = termDocs.read(docs, freqs);//
        for (int i = 0; i < docs.length; i++) {
            System.out.println(docs[i]+"--"+freqs[i]);
            bits.set(docs[i]);
        }
        return bits;
    }

3,Term t = new Term("content", "电力");
Query query = new TermQuery(t);
以上搜不到结果.原因是"电力"不是一个Term,用"电"或"力"则可以。

4,reader.terms()返回索引中的所有term,没有重复。而TermDocs存放term关联的Doc

TermEnum enumerator = reader.terms();
while (enumerator.next()) {
Term term = enumerator.term();
System.out.println(term.field() + " " + term.text());
}

5,lucene不支持中文的* ?匹配
因为英文是基于词的, 中文是基于字的
英文mo?ey可以匹配到money ,因为money是一个term, 中文怎么办？除非中文有个好的分词方案
6，两次过滤后，query对象的tostring:
filtered(filtered(title:oracle content:oracle)->com.lucene.search.PrivilegeFilter@133d0fc)->com.lucene.search.CategoryFilter@dd5415
7,Hyper Estraier是一个用C语言开发的全文检索引擎,
具有高速度,高稳定性,高可扩展性?提供java,ruby的调用方法
<迅速搭建全文搜索平台——开源搜索引擎实战教程>
http://www.162cm.com/archives/date/2007/07/18

8，Hits hits = searcher.search (filteredquery, new Sort("fieldname"));//可根据第二个参数进行排序
int n=hits.id(2) //参数是在hits中的下标,返回的结果是在过滤和排序之前在directory中的原始下标

9，
new一个BitSet(950)并不等于建立一个950大小的bs
只是说构建出来的bs初始大小至少能容纳950个bit,大小永远是系统控制的。而且他的大小是64的倍数，就算BitSet(1),他的大小也是64。
bitset.set(1, 4) 设置的是1,2,3,没有4

10，对Field再进行切词就是Term?Term和Token的区别

11，BooleanQuery的例子:
      BooleanQuery bq = new BooleanQuery();
    Query q1 = new TermQuery (new Term ("field", "one"));
    Query q2 = new TermQuery (new Term ("sorter", "b"));
    bq.add(q1, Occur.MUST);
    bq.add(q2, Occur.MUST);
    Hits hits = searcher.search(bq);

12，可用RAMDirectory作测试，见lucene自带的测试
    RAMDirectory directory = new RAMDirectory();
    IndexWriter writer = new IndexWriter (directory, new WhitespaceAnalyzer(), true)

13，进行过滤时如果有多个filter，则某个doc是否能查到取决于这多个filter各自返回的bitset的综合结果：要查得某一位置的doc，所有的filter的该位必须全部为true。所以查询结果与filter的先后顺序无关。

14，--按user为tom进行过滤
    Filter f1 = new Filter() {
            public BitSet bits(IndexReader reader) throws IOException {
                BitSet bitset = new BitSet(reader.maxDoc());
                TermDocs termDocs = reader.termDocs();// 实际是SegmentTermDocs
                Term term = new Term("user", "tom");
                termDocs.seek(term);//相当于持有了所有含有user为tom的doc的集合，但freq()和doc()还需要去文件中读取?
                while (termDocs.next()) {
                    System.out.println("freq:"+termDocs.freq());
                    bitset.set(termDocs.doc());
                }
                return bitset;
            }
        };

15，Trie，又称单词查找树，是一种特殊的树形结构，用于保存大量的字符串。它的优点是：利用字符串的公共前缀来节约存储空间。
http://www.javaeye.com/topic/299826

16,
doc相当于表中的记录
field相当于字段
不同的doc可能有相同的field，也可能有不一样的
我感觉比较适合用json格式存储
field+分词的关键字=term,是唯一的
term出现在哪些doc中，索引文件里有记载？
用Luke(http://code.google.com/p/luke)可以查看索引文件详细信息

leekiang 2008-03-27 16:15 发表评论

lucene查询

leekiang — Fri, 21 Mar 2008 05:56:00 GMT

http://www.cnblogs.com/bysshijiajia/archive/2008/01/24/1051317.html
http://hi.baidu.com/myj2ee/blog/item/2a6b2f1b110c3c1d8618bfb8.html

leekiang 2008-03-21 13:56 发表评论

lucene问题记录

leekiang — Thu, 21 Feb 2008 07:20:00 GMT

1,删索引时如果解锁，会不会有问题?
    IndexReader reader = IndexReader.open(directory);
            if (IndexReader.isLocked(directory)) {
                IndexReader.unlock(directory);
            }
            reader.deleteDocuments(term);
            reader.close();
2,到底是reader.deleteDocuments(term)还是writer.deleteDocuments(term)

3,writer.setUseCompoundFile(true)
创建索引库时，会合并多个 Segments 文件到一个 .cfs 中。此方式有助于减少索引文件数量，减少同时打开的文件数量。
可以使用 CompoundFileReader 查看 .cfs 文件内容。

CompoundFileReader reader = new CompoundFileReader(FSDirectory.GetDirectory("y:\\index", false), "_1oa.cfs");
foreach (string filename in reader.List())
{
Console.WriteLine(filename);
}

leekiang 2008-02-21 15:20 发表评论

lucene相关文档

leekiang — Wed, 20 Feb 2008 07:16:00 GMT

1，某人设计的中文分词算法
2，Lucene中文分词组件 JE-Analysis 1.5.1
3，转一篇lucene的使用的文章，写的比较全
   lucene使用与优化
4，基于字符串匹配的中文分词
5，计算所开源的FirteX介绍
6, 庖丁分词
   http://www.javaeye.com/topic/49441?page=1
   http://qieqie.javaeye.com/blog/126943
   http://code.google.com/p/paoding/
   http://groups.google.com/group/paoding/topics
7，http://www.chedong.com/tech/lucene.html(车东)
8，http://blog.donews.com/withshare/archive/2007/06/10/1173923.aspx

leekiang 2008-02-20 15:16 发表评论