分类目录归档:search

基于lucene实现自己的推荐引擎

  采用基于数据挖掘的算法来实现推荐引擎是各大电子商务网站、SNS社区最为常用的方
法,推荐引擎常用的Content-Based推荐算法及协同过滤算法(Item-Based
、User-based)在电子商务推荐系统入门v2.0 、电子商务推荐系统入门基础 中已经有所阐述。但从实际应用来看,对于大部分中小型企业来说,
要在电子商务系统完整采用以上算法有很大的难度。

1、常用推荐引擎算法问题

1)、相对成熟、完整、现成的开源解决方案较少

粗略分来,目前与数据挖掘及推荐引擎相关的开源项目主要有如下几类:

数据挖掘相关:主要包括WekaR-ProjectKnimeRapidMinerOrange 等

文本挖掘相关:主要包括OpenNLPLingPipeFreeLingGATE 、Carrot2 等,具体可以参考LingPipe’s Competition

推荐引擎相关:主要包括Apache MahoutDuine frameworkSingular Value Decomposition (SVD) ,其他包可以参考Open Source Collaborative Filtering Written in Java

搜索引擎相关:Lucene、Solr、Sphinx、Hibernate Search等

2)、常用推荐引擎算法相对复杂,入门门槛较低

3)、常用推荐引擎算法性能较低,并不适合海量数据挖掘

以上这些包或算法,除了Lucene/Sor相对成熟外,大部分都还处于学术研究使用,并不能直接应用于互联网大规模的数据挖掘及推荐引擎引擎使用。

2、采用Lucene实现推荐引擎的优势

对很多众多的中小型网站而言,由于开发能力有限,如果有能够集成了搜索、推荐一体化的解决方案,这样的方案肯定大受欢迎。采用Lucene来实现推荐引擎具有如下优势:

1)、Lucene 入门门槛较低,大部分网站的站内搜索都采用了Lucene

2)、相对于协同过滤算法,Lucene性能较高

3)、Lucene对Text Mining、相似度计算等相关算法有很多现成方案

在开源的项目中,Mahout或者Duine Framework用于推荐引擎是相对完整的方案,尤其是Mahout
核心利用了Lucene,因此其架构很值得借鉴。只不过Mahout目前功能还不是很完整,直接用其实现电子商务网站的推荐引擎尚不是很成熟。只不过从
Mahout实现可以看出采用Lucene实现推荐引擎是一种可行方案。

3、采用Lucene实现推荐引擎需要解决的核心问题

Lucene擅长Text Mining较为擅长,Lucene在contrib包中提供了MoreLikeThis功能,可以较为容易实现Content-Based的推荐,但对于涉及用户协同过滤行为的结果(所谓的Relevance Feedback),Lucene目前并没有好的解决方案。需要在Lucene中内容相似算法中加入用户协同过滤行为对因素,将用户协同过滤行为结果转化为Lucene所支持的模型。

4、推荐引擎的数据源

电子商务网站与推荐引擎相关典型的行为:

  • 购买本商品的顾客还买过
  • 浏览本商品的顾客还看过
  • 浏览更多类似商品
  • 喜欢此商品的人还喜欢
  • 用户对此商品的平均打分

因此基于Lucene实现推荐引擎主要要处理如下两大类的数据

1)、内容相似度

例如:商品名称、作者/译者/制造商、商品类别、简介、评论、用户标签、系统标签

2)、用户协同行为相似度

例如:打标签、购买商品、点击流、搜索、推荐、收藏、打分、写评论、问答、页面停留时间、所在群组等等

5、实现方案

5.1、内容相似度

基于Lucene MoreLikeThis实现即可。

5.1、对用户协同行为的处理

1)、用户每一次协同行为都使用lucene来进行索引,每次行为一条记录

2)、索引记录中包含如下重要信息:

商品名、商品id、商品类别、商品简介、标签等重要特征值、用户关联行为的其他商品的特征元素、商品缩略图地址、协同行为类型(购买、点击、收藏、评分等)、Boost值(各协同行为在setBoost时候的权重值)

3)、对评分、收藏、点击等协同行为以商品特征值(标签、标题、概要信息)来表征

4)、不同的协同行为类型(例如购买、评分、点击)设置不同的值setBoost

5)、搜索时候采用Lucene MoreLikeThis算法,将用户协同转化为内容相似度

以上方案只是基于Lucene来实现推荐引擎最为简单的实现方案,方案的准确度及细化方案以后再细说。

更为精细的实现,可以参考Mahout的算法实现来优化。

文章来源:http://www.yeeach.com/2010/10/01/%E5%9F%BA%E4%BA%8Elucene%E5%AE%9E%E7%8E%B0%E8%87%AA%E5%B7%B1%E7%9A%84%E6%8E%A8%E8%8D%90%E5%BC%95%E6%93%8E/

更为精细的实现,可以参考Mahout的算法实现来优化。

lucene

lucene3.0中BooleanQuery 实现与或的复合搜索 .
BooleanClause用于表示布尔查询子句关系的类,


括:

BooleanClause.Occur.MUST,

BooleanClause.Occur.MUST_NOT,

BooleanClause.Occur.SHOULD。

 

必须包含,不能包含,可以包含三种.有以下6种组合: 
 
1.MUST和MUST:取得连个查询子句的交集。 
2.MUST和MUST_NOT:表示查询结果中不能包含MUST_NOT所对应得查询子句的检索结果。 
3.SHOULD与MUST_NOT:连用时,功能同MUST和MUST_NOT。
4.SHOULD与MUST连用时,结果为MUST子句的检索结果,但是SHOULD可影响排序。
5.SHOULD与SHOULD:表示“或”关系,最终检索结果为所有检索子句的并集。
6.MUST_NOT和MUST_NOT:无意义,检索无结果。

...

构造出“与”的关系: bquery.Add(query, BooleanClause.Occur.MUST);

构造“或”关系:bquery.Add(query, BooleanClause.Occur.SHOULD);

构造“非”关系:bquery.Add(query, BooleanClause.Occur.MUST_NOT);

...

Field.Store.YES:存储字段值(未分词前的字段值) 

       Field.Store.NO:不存储,存储与索引没有关系 

       Field.Store.COMPRESS:压缩存储,用于长文本或二进制,但性能受损 



       Field.Index.ANALYZED:分词建索引 

       Field.Index.ANALYZED_NO_NORMS:分词建索引,但是Field的值不像通常那样被保存,而是只取一个byte,这样节约存储空间 

       Field.Index.NOT_ANALYZED:不分词且索引 

       Field.Index.NOT_ANALYZED_NO_NORMS:不分词建索引,Field的值去一个byte保存 



       TermVector表示文档的条目(由一个Document和Field定位)和它们在当前文档中所出现的次数 

       Field.TermVector.YES:为每个文档(Document)存储该字段的TermVector 

       Field.TermVector.NO:不存储TermVector 

       Field.TermVector.WITH_POSITIONS:存储位置 

       Field.TermVector.WITH_OFFSETS:存储偏移量 

       Field.TermVector.WITH_POSITIONS_OFFSETS:存储位置和偏移量

...

 Apache Lucene 几种分词系统

1、 StopAnalyzer

StopAnalyzer能过滤词汇中的特定字符串和词汇,并且完成大写转小写的功能。

2、 StandardAnalyzer

StandardAnalyzer根据空格和符号来完成分词,还可以完成数字、字母、E-mail地址、IP地址以及中文字符的分析处理,还可以支持过滤词表,用来代替StopAnalyzer能够实现的过滤功能。

3、 SimpleAnalyzer

SimpleAnalyzer具备基本西文字符词汇分析的分词器,处理词汇单元时,以非字母字符作为分割符号。分词器不能做词汇的过滤,之进行词汇的分析和分割。输出地词汇单元完成小写字符转换,去掉标点符号等分割符。

在全文检索系统开发中,通常用来支持西文符号的处理,不支持中文。由于不完成单词过滤功能,所以不需要过滤词库支持。词汇分割策略上简单,使用非英文字符作为分割符,不需要分词词库的支持。

4、 WhitespaceAnalyzer

WhitespaceAnalyzer使用空格作为间隔符的词汇分割分词器。处理词汇单元的时候,以空格字符作为分割符号。分词器不做词汇过滤,也不进行小写字符转换。

实际中可以用来支持特定环境下的西文符号的处理。由于不完成单词过滤和小写字符转换功能,也不需要过滤词库支持。词汇分割策略上简单使用非英文字符作为分割符,不需要分词词库支持。

5、 KeywordAnalyzer

KeywordAnalyzer把整个输入作为一个单独词汇单元,方便特殊类型的文本进行索引和检索。针对邮政编码,地址等文本信息使用关键词分词器进行索引项建立非常方便。

6、 CJKAnalyzer

CJKAnalyzer内部调用CJKTokenizer分词器,对中文进行分词,同时使用StopFilter过滤器完成过滤功能,可以实现中文的多元切分和停用词过滤。在Lucene3.0版本中已经弃用。

7、 ChineseAnalyzer

ChineseAnalyzer功能与StandardAnalyzer分析器在处理中文是基本一致,都是切分成单个的双字节中文字符。在Lucene3.0版本中已经弃用。

8、 PerFieldAnalyzerWrapper

PerFieldAnalyzerWrapper功能主要用在针对不同的Field采用不同的Analyzer的场合。比如对于文件名,需要使用KeywordAnalyzer,而对于文件内容只使用StandardAnalyzer就可以了。通过addAnalyzer()可以添加分类器。

9、 IKAnalyzer

实现了以词典为基础的正反向全切分,以及正反向最大匹配切分两种方法。IKAnalyzer是第三方实现的分词器,继承自Lucene的Analyzer类,针对中文文本进行处理。

10、JE-Analysis

JE-Analysis是Lucene的中文分词组件,需要下载。

11、 ICTCLAS4J

ictclas4j中文分词系统是sinboy在中科院张华平和刘群老师的研制的FreeICTCLAS的基础上完成的一个java开源分词项目,简化了原分词程序的复杂度,旨在为广大的中文分词爱好者一个更好的学习机会。

12、 Imdict-Chinese-Analyzer

imdict-chinese-analyzer 是 imdict智能词典 的智能中文分词模块,算法基于隐马尔科夫模型(Hidden Markov Model, HMM),是中国科学院计算技术研究所的ictclas中文分词程序的重新实现(基于Java),可以直接为lucene搜索引擎提供简体中文分词支持。

13、 Paoding Analysis

Paoding Analysis中文分词具有极 高效率 和 高扩展性。引入隐喻,采用完全的面向对象设计,构思先进。其效率比较高,在PIII 1G内存个人机器上,1秒可准确分词100万汉字。采用基于不限制个数的词典文件对文章进行有效切分,使能够将对词汇分类定义。能够对未知的词汇进行合理解析。

14、 MMSeg4J

mmseg4j 用 Chih-Hao Tsai 的 MMSeg 算法(http://technology.chtsai.org/mmseg/ )实现的中文分词器,并实现 lucene 的 analyzer 和 solr 的TokenizerFactory 以方便在Lucene和Solr中使用。 MMSeg 算法有两种分词方法:Simple和Complex,都是基于正向最大匹配。Complex 加了四个规则过虑。官方说:词语的正确识别率达到了 98.41%。mmseg4j 已经实现了这两种分词算法。

...

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Lucene.Net.Store;
using Lucene.Net.Analysis;
using Lucene.Net.Analysis.Standard;
using Lucene.Net.Index;
using Lucene.Net.Documents;
using Lucene.Net.Search;
using Lucene.Net.QueryParsers;
using System.Diagnostics;

namespace LuceneNet.Web.Controllers {
    public class HomeController : Controller {
        public ActionResult Index() {
            ViewBag.Message = "欢迎使用 ASP.NET MVC!";
            return View();
        }
        public ActionResult About() {
            return View();
        }
        /// <summary>
        /// 添加索引
        /// </summary>
        /// <returns></returns>
        public ActionResult AddIndex() {
            //为索引存储目录
            string INDEX_STORE_PATH = Server.MapPath("~/SearchIndex");
#if DEBUG
            ///如果存在文件则删除(测试用)
            if (System.IO.Directory.Exists(INDEX_STORE_PATH)) {
                System.IO.Directory.Delete(INDEX_STORE_PATH, true);
            }
#endif
            Directory indexDirectory = FSDirectory.Open(new System.IO.DirectoryInfo(INDEX_STORE_PATH));
            Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29);
            IndexWriter writer = null;

            try {
                //检查索引文件是否存在
                bool iscreate = !Lucene.Net.Index.IndexReader.IndexExists(indexDirectory);
                //如果索引文件不存在则创建索引文件,否则创建索引文件
                writer = new IndexWriter(indexDirectory, analyzer, iscreate, IndexWriter.MaxFieldLength.UNLIMITED);

                //开始添加索引
                foreach (var item in Get()) {
                    Document doc = new Document();
                    doc.Add(new Field("id", item.Id, Field.Store.YES, Field.Index.ANALYZED));//存储,不分词索引
                    doc.Add(new Field("classid", item.ClassId, Field.Store.YES, Field.Index.NOT_ANALYZED));//存储,不分词索引
                    doc.Add(new Field("classname", item.ClassName, Field.Store.YES, Field.Index.ANALYZED));//存储,不分词索引
                    doc.Add(new Field("title", item.Title, Field.Store.YES, Field.Index.ANALYZED));//存储,分词索引
                    doc.Add(new Field("summary", item.Summary, Field.Store.YES, Field.Index.ANALYZED));//存储,分词索引
                    doc.Add(new Field("createtime", item.CreateTime.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED));//存储,分词索引
                    writer.AddDocument(doc);
                }
                writer.Optimize();
            } catch (Exception) {
                throw;
            } finally {
                if (analyzer != null)
                    analyzer.Close();
                if (writer != null)
                    writer.Close();
                if (indexDirectory != null)
                    indexDirectory.Close();
            }
            return RedirectToAction("index");
        }
        /// <summary>
        /// 搜索
        /// </summary>
        /// <param name="k"></param>
        /// <param name="cid"></param>
        /// <returns></returns>
        public ActionResult Search(string k, string cid) {
            Stopwatch st = new Stopwatch();
            st.Start();//计时开始  
            //为索引存储目录
            string INDEX_STORE_PATH = Server.MapPath("~/SearchIndex");
            var ver = Lucene.Net.Util.Version.LUCENE_29;
            Directory indexDirectory = FSDirectory.Open(new System.IO.DirectoryInfo(INDEX_STORE_PATH));
            Analyzer analyzer = new StandardAnalyzer(ver);
            IndexSearcher searcher = null;
            List<Article> list;
            int recCount = 0;
            try {
                searcher = new IndexSearcher(indexDirectory, true);
                string[] fields = { "title", "summary" };
                BooleanQuery booleanQuery = new BooleanQuery();
                //多字段查询同时搜索title和summary
                MultiFieldQueryParser parser = new MultiFieldQueryParser(ver, fields, analyzer);
                Query query = parser.Parse(k);
                //Query query1 = new QueryParser(ver, "classid", analyzer).Parse("1");

                //TermQuery只能查询不分词的索引(Field.Index.NOT_ANALYZED)
                Query query1 = new TermQuery(new Term("id", "1"));
                //当classname为ANALYZED时搜不到
                // Query query2 = new TermQuery(new Term("classname", "体育新闻"));
                //只有当classname为NOT_ANALYZED才可以搜得到,
                //由此得出TermQuery只能查询不分词的索引(Field.Index.NOT_ANALYZED)的结论
                //但当id为ANALYZED时TermQuery却可以收的到,
                //当搜classname中包含“体”时即Query query2 = new TermQuery(new Term("classname", "体"));
                //当搜classname中包含“育”时即Query query2 = new TermQuery(new Term("classname", "育"));
                //可以搜得到。因此,由此得出,TermQuery搜的是最小单位,由此又得出Lucene是把“体育新闻”拆分成了"体/育/新/闻"四部分
                //听说Lucene分词是按空格分的,那么把“体育新闻”,改成“体育 新闻”后再重新生成索引是不是可以搜的到呢?
                //Query query2 = new TermQuery(new Term("classname", "体育"));
                //但是结果却是搜不到,纳闷...难道Lucene的分词不是这么分而是更复杂?
                //StandardAnalyzer看来是对中文分词不怎么好,当ClassName = "sports news"可以搜sports和news
                //StandardAnalyzer只支持英文的空格分词
                Query query2 = new TermQuery(new Term("classname", k));
                //关于QueryParser的搜索当k为Empty或null时会报错注意处理
                //Query query3 = new QueryParser(ver, "title", analyzer).Parse(k);
                Query query3 = new QueryParser(ver, "title", analyzer).Parse(k);

                Query query4 = new PrefixQuery(new Term("classname", k));
                Query query5 = new QueryParser(ver, "title", analyzer).Parse(k);
                TermRangeQuery query6 = new TermRangeQuery("createtime", "2012-1-3", "2012-5-3", true, true);

                //booleanQuery.Add(query1, BooleanClause.Occur.MUST);
                //booleanQuery.Add(query2, BooleanClause.Occur.MUST);
                //booleanQuery.Add(query3, BooleanClause.Occur.MUST);
                booleanQuery.Add(query4, BooleanClause.Occur.MUST);
                //booleanQuery.Add(query5, BooleanClause.Occur.MUST);
                booleanQuery.Add(query6, BooleanClause.Occur.MUST);
                TopDocs ts = searcher.Search(booleanQuery, null, 100);//执行搜索,获取查询结果集对象

                recCount = ts.totalHits;//获取命中的文档个数
                ScoreDoc[] hits = ts.scoreDocs;//获取命中的文档信息对象
                st.Stop();//计时停止
                ViewBag.EvenTime = string.Format("{0}毫秒,生成的Query语句:{1}", st.ElapsedMilliseconds, booleanQuery.ToString());
                ViewBag.Count = recCount;
                list = new List<Article>();
                foreach (var item in hits) {
                    list.Add(new Article()
                    {
                        Id = searcher.Doc(item.doc).Get("id"),
                        ClassId = searcher.Doc(item.doc).Get("classid"),
                        ClassName = searcher.Doc(item.doc).Get("classname"),
                        Title = searcher.Doc(item.doc).Get("title"),
                        Summary = searcher.Doc(item.doc).Get("summary"),
                        Score = item.score.ToString(),
                        CreateTime = DateTime.Parse(searcher.Doc(item.doc).Get("createtime"))
                    });
                }
            } catch (Exception) {
                throw;
            } finally {
                if (searcher != null) {
                    searcher.Close();
                }
            }

            return View(list);
        }

        public List<Article> Get() {
            List<Article> list = new List<Article>();
            list.Add(new Article() { Id = "1", ClassId = "1", ClassName = "体育新闻", Title = "微软发布MVC4.0了", Summary = "微软发布MVC4.0了,此版本更加强大", CreateTime = DateTime.Parse("2012-2-3") });
            list.Add(new Article() { Id = "2", ClassId = "1", ClassName = "IT新闻", Title = "跟谷歌测试工程师的对话", Summary = "本文主人公Alan是谷歌的一名的软件测试工程师,他的工作对象是谷歌的DoubleClick广告管理系统(Bid Manager),这个系统提供让广告代理商和广告客户在多个广告上进行报价竞标的功能。", CreateTime = DateTime.Parse("2012-3-3") });
            list.Add(new Article() { Id = "3", ClassId = "1", ClassName = "体育 新闻", Title = "好的程序员应该熟悉的几门编程语言", Summary = "如果想成为一个好的程序员,甚至架构师、技术总监等,显然只精通一种编程语言是不够的,还应该在常见领域学会几门编程语言,正如我们要成为高级人才不仅要会中文还要会英文", CreateTime = DateTime.Parse("2012-4-3") });
            list.Add(new Article() { Id = "4", ClassId = "2", ClassName = "娱乐新闻", Title = "Javascript开发《三国志曹操传》-开源讲座(五)-可移动地图的实现", Summary = "这一讲的内容很简单,大家理解起来会更快。因此我只对重点加以分析,其他的就轮到大家思考哦!首先来说,我对游戏开发可以算是不怎么深入,因为现在的程序员爱用canvas,我却就只会拿几个div凑和。", CreateTime = DateTime.Parse("2012-5-3") });
            list.Add(new Article() { Id = "5", ClassId = "2", ClassName = "体育新闻", Title = "Android之BaseExpandableListAdapter使用心得", Summary = " 但是我最近做那个QQ项目是遇到一个问题,如果给这个ExpandableListView添加动态从网上获取的数据呢?前面跟大家分享的时候,是用了静态的数据,很好处理。", CreateTime = DateTime.Parse("2012-6-3") });
            list.Add(new Article() { Id = "6", ClassId = "3", ClassName = "sports news", Title = "对话CSDN蒋涛:微软移动互联网马太效应不可避免,小团队需学会利用平台", Summary = "CSDN是全球最大的中文IT社区,也是雷锋网最重要的合作伙伴之一,自1999年创办至今,有着非常强大的业界影响力和号召力,其专注IT信息传播、技术交流、教育培训和专业技术人才服务,在2012年移动开发者大会即将举办之际,雷锋网对CSDN的掌门人蒋涛做了一次专访,一起探讨移动互联网的新技术浪潮和下一波发展趋势。", CreateTime = DateTime.Parse("2012-7-3") });
            list.Add(new Article() { Id = "7", ClassId = "3", ClassName = "体育新闻", Title = "基于MySQL的分布式事务控制方案", Summary = "基于MySQL的分布式事务控制方案", CreateTime = DateTime.Parse("2012-8-3") });
            list.Add(new Article() { Id = "8", ClassId = "4", ClassName = "sports news", Title = "IOS和Android开发的一些个人感受", Summary = "最近公司的产品 Android版本第二版也算到了收尾,新加了几个功能性模块,我基本也就捡了几个好玩的模块做了下。", CreateTime = DateTime.Parse("2012-9-3") });
            list.Add(new Article() { Id = "9", ClassId = "5", ClassName = "IT资讯", Title = "Google Code的简单使用", Summary = "google code简介:用于管理代码的仓库,反正我是这么理解的。就比我们在公司的时候也会有个用于存放公司代码的主机一样,google同样给我们提供了这样的一个host。这样我们可以在不同电脑不同地方随时的checkout,commit,同时分享我们的项目。", CreateTime = DateTime.Parse("2012-10-3") });
            list.Add(new Article() { Id = "10", ClassId = "33", ClassName = "IT资讯", Title = "谷歌在印度推Gmail免费短信服务", Summary = "歌一直在努力桥接发展中国家功能手机SMS服务和Gmail之间的服务,这不,近日谷歌在印度推出“Gmail SMS”服务,这使得印度的Gmail用户可以从Gmail的窗口发送信息到手机上并且接受聊天信息的回复,目前谷歌的这项服务已经得到印度的八大运营商的支持。", CreateTime = DateTime.Parse("2012-11-3") });
            list.Add(new Article() { Id = "11", ClassId = "11", ClassName = "体育新闻", Title = "鲍尔默:微软新时代 软硬结合“赢”未来", Summary = "微软CEO鲍尔默在年度公开信中表示,微软在未来将紧密结合硬件和软件。鲍尔默认为,这是微软的一个新时代。“我们看到了前所未有的机会,我们对此很兴奋,并且保持着乐观的心态。”", CreateTime = DateTime.Parse("2012-12-3") });
            return list;
        }
    }

    public class Article {
        public string Id { get; set; }
        public string ClassId { get; set; }
        public string ClassName { get; set; }
        public string Title { get; set; }
        public string Summary { get; set; }
        public string Score { get; set; }
        public DateTime CreateTime { get; set; }
    }
}

 

 

 

 

 

 

...

...

lucene 搜索语法

Lucene提供了丰富的API来组合定制你所需要的查询器,同时也可以利用Query Parser提供的强大的查询语法解析来构造你想要的查询器。本文章详细的介绍了Lucene的查询语法。通过Java语法分析器把一个查询字符串解析成 Lucene的查询器。在你选择使用Query Parser前,请考虑以下事项:

如果你打算在程序中拼接查询语法串然后再利用Query Parser转换,那么强烈建议你利用相应的API来自己构造查询器。也就是说,Query Parser是为手工输入高级查询设计的,而不是为程序拼接语法串而设计的。不分词的字段也最好通过相应的API添加到查询器中,而不是通过Query Parser。Query Parser 使用的Analyser分析器,作用是将用户手工输入的文本转化为相应的Term。如果一个字段的值是通过程序生成的(例如日期字段,关键词字段等),那么在查询的时候也应该保持前后一致,利用程序生成相应的格式来查询。

在查询的目标中,如果字段全部是程序生成的文本,(例如补齐的日期字段等),最好使用Query Parser以便查询的时候也是一致的格式。至于其它的,例如日期范围查询,关键字查询等,最好调用相应的API来构建查询器。目标字段中如果仅仅拥有有限的枚举值时,最好通过下拉列表提供给用户选择,然后利用TermQuery添加到查询器中,而不是而其拼接到查询字符串然后利用Query Parser来解析。

Terms 
一个查询将分解为若干Term以及操作符,有两种Term,其一是单一Term,其二为短语。单一Term是经过分析器分词后的最小单元,他就是一个简单的词,例如“Test”和“Hello”。短语则是一组被双引号括起来的一组词,例如:“Hello dolly”,多个Term可以通过布尔操作合并在一个更加复杂的查询器中。
注意:一般来说,创建索引的分析器和查询的分析器最好保持一致(当然也有特殊情况,比如单字索引,分词组合查询),所以选择一个不会干扰查询词的分析器是很重要的。

Fields 
Lucene支持多字段数据,当你在查询的时候你可以指定一个字段查询,也可以使用默认的字段。你可以使用 字段名 + “:” + 查询词来指定字段名搜索。举个例子,让我们假定Lucene的索引中含有两个字段,Title字段和Text字段,其中Text字段是默认字段,当你想找到一篇文档其中标题包含“The Right Way”同时文本中包含“go”,你可以输入:
title:"The Right Way" AND text:go 
或者:
title:" The Right Way " AND go 
如果字段是默认字段的话,在查询语法中可以不需要显式指定。注意,使用默认字段有可能会造成如下的结果:
title:Do it right 
以上查询将查找标题中含有“Do”,Text字段字段中含有“it”和“right”的文档,因为Text是默认字段,所以如果想要查找Title中完整包含的很用引号引起来。

Term Modifiers
Lucene支持在Term中使用通配符来支持模糊查询。

Wildcard Searches 
Lucene支持单个或者多个字符的通配符查询,匹配单一字符使用符号“?”,匹配多个字符使用符号“*”。
“?”通配符将查找所有满足通过一个字符替换后符合条件的文档。比如:搜索“test”和“text”你可以使用:
te?t 
“*”通配符将查询0个或者多个字符替换后符合条件的。举例来说,查询test,tests或者tester,你可以使用一下字符串来搜索:
test*
当然,你也可以将“*”放在字符的中间
te*t 
注意:你不能将“*”和“?”放在第一个字符来查询。(Lucene应该是出于性能考虑,所以不支持该功能)

Fuzzy Searches 
Lucene支持基于编辑距离算法的模糊搜索,你可以使用波浪符号“~”放在查询词的后面,比如搜索一个与“roam”拼写相近的词可以使用:
roam~ 
该查询将寻找类似“foam”和“roams”等的词语。也可以说是相似度查询。

Proximity Searches 
Lucene支持指定距离查询,你可以使用波浪号“~”加数字在查询词后。举例来说搜索“apache”和“jakarta”距离10个字符以内,你可以使用如下语法:
"jakarta apache"~10 
通过这个语法支持,我们可以单字索引,分词查询,分词完后,满足每个词的单字必须间距为0。这样可以保证100%的召回率,但是在索引方面将造成索引臃肿,同时查询速度也将在某程度上降低,一般来说,在150W文章数据到200W数据的时候性能将会明显的降低。

Range Searches 
范围查询允许你指定某个字段最大值和最小值,查询在二者之间的所有文档。范围查询可以包含或者不包含最大值和最小值,排序是按照字典顺序来排序的。
mod_date:[20020101 TO 20030101] 
这个将查找满足mode_date字段在大于等于20020101,小于等于20030101范围的所有文档,注意:范围查询并不是为日期字段专设的,你也可以对非日期字段进行范围查询。
title:{Aida TO Carmen} 
这个将查找所有标题在Aida和Carmen之间但不包含Aida和Carmen的文档。包含最大值和最小值的查询使用方括号,排除则使用花括号。

Boosting a Term 
Lucene支持给不同的查询词设置不同的权重。设置权重使用“^”符号,将“^”放于查询词的尾部,同时跟上权重值,权重因子越大,该词越重要。设置权重允许你通过给不同的查询词设置不同的权重来影响文档的相关性,假如你在搜索:
jakarta apache 
如果你认为“jakarta”在查询时中更加重要,你可以使用如下语法:
jakarta^4 apache 
这将使含有Jakarta的文档具有更高的相关性,同样你也可以给短语设置权重如下:
"jakarta apache"^4 "jakarta lucene" 
在默认情况下,权重因子为1,当然权重因子也可以小于1。

Boolean operators 
布尔操作符可以将多个Term合并为一个复杂的逻辑查询。Lucene支持AND,
+,OR,NOT, -作为操作符号。注意,所有的符号必须为大写。

OR 
OR操作符默认的连接操作符。这意味着,当没有给多个Term显式指定操作符时,将使用OR,只要其中一个Term含有,则可以查询出文档,这跟逻辑符号||的意思相似。假设我们查询一个文档含有“jakarta apache”或者“jakarta”时,我们可以使用如下语法:
"jakarta apache" jakarta 
或者
"jakarta apache" OR jakarta 

AND 
AND操作符规定必须所有的Term都出现才能满足查询条件,这跟逻辑符号&&意思相似。如果我们要搜索一个文档中同时含有“jakarta apache”和“jakarta lucene”,我们可以使用如下语法:
   "jakarta apache" AND "jakarta lucene" 

+
+操作符规定在其后的Term必须出现在文档中,也就是查询词中的MUST属性。举个例子来说,当我们要查询一个文档必须包含“jakarta”,同时可以包含也可以不包含“lucene”时,我们可以使用如下语法:
+jakarta apache 

NOT 
NOT操作符规定查询的文档必须不包含NOT之后的Term,这跟逻辑符号中的!相似。当我们要搜索一篇文档中必须含有“jakarta apache”同时不能含有“Jakarta lucene”时,我们可以使用如下查询;
"jakarta apache" NOT "jakarta lucene" 
注意:NOT操作符不能使用在单独Term中,举例来说,以下查询将返回无结果:
NOT "jakarta apache" 


-操作符排除了包含其后Term的文档,跟NOT有点类似,假设我们要搜索“Jakarta apache”但不包含“Jakarta lucene”时,我们使用如下语法:
"jakarta apache" -"jakarta lucene" 

Grouping 
Lucene支持使用圆括号来将查询表达式分组,这将在控制布尔控制查询中非常有用。举例来说:当搜索必须含有“website”,另外必须含有“jakarta”和“apache”之一,我们可以用如下语法:
(jakarta OR apache) AND website 
这种语法对消除歧义,确保查询表达式的正确性具有很大的意义。

Field Grouping 
Lucene支持对字段用圆括号来进行分组,当我们要查询标题中含有“return”和“pink ranther”时,我们可以使用如下语法:
title:(+return +"pink panther") 

Escaping Special Characters 
Lucene支持转义查询中的特殊字符,以下是Lucene的特殊字符清单:
+ - && || ! ( ) { } [ ] ^ " ~ * ? : \
转义特殊字符我们可以使用符号“\”放于字符之前。比如我们要搜索(1+1):2,我们可以使用如下语法:
\(1\+1\)\:2 

转自:http://hi.baidu.com/expertsearch/blog/item/8d4f7d355a2e413c5ab5f547.html

 

构建实时索引

所谓事务性,本多指数据库的属性,包括ACID四个基本要素:原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation)、持久性(Durability)。

我们这里主要讨论隔离性,Lucene的IndexReader和IndexWriter具有隔离性。

  • 当IndexReader.open打开一个索引的时候,相对于给当前索引进行了一次snapshot,此后的任何修改都不会被看到。
  • 仅当IndexReader.open打开一个索引后,才有可能看到从上次打开后对索引的修改。
  • 当IndexWriter没有调用Commit的时候,其修改的内容是不能够被看到的,哪怕IndexReader被重新打开。
  • 欲使最新的修改被看到,一方面IndexWriter需要commit,一方面IndexReader重新打开。

下面我们举几个例子来说明上述隔离性:

(1) 首先做准备,索引十篇文档

File indexDir = new File("TestIsolation/index");

IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);

for(int i =0; i < 10; i++){

  indexDocs(writer);

}

writer.close();

(2) 然后再索引十篇文档,并不commit

writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), IndexWriter.MaxFieldLength.LIMITED);

for(int i =0; i < 10; i++){

  indexDocs(writer);

}

(3) 打开一个IndexReader,但是由于IndexWriter没有commit,所以仍然仅看到十篇文档。

IndexReader reader = IndexReader.open(FSDirectory.open(indexDir));

IndexSearcher searcher = new IndexSearcher(reader);

TopDocs docs = searcher.search(new TermQuery(new Term("contents","hello")), 50);

System.out.println(docs.totalHits);

(4) IndexWriter进行提交commit

writer.commit();

(5) 不重新打开IndexReader,进行搜索,仍然仅看到十篇文档。

docs = searcher.search(new TermQuery(new Term("contents","hello")), 50);

System.out.println(docs.totalHits);

(6) IndexReader重新打开,则可以看到二十篇文档。

reader = IndexReader.open(FSDirectory.open(indexDir));

searcher = new IndexSearcher(reader);

docs = searcher.search(new TermQuery(new Term("contents","hello")), 50);

System.out.println(docs.totalHits);

由于前一章所述的Lucene的事务性,使得Lucene可以增量的添加一个段,我们知道,倒排索引是有一定的格式的,而这个格式一旦写入是非常难以改变的,那么如何能够增量建索引呢?Lucene使用段这个概念解决了这个问题,对于每个已经生成的段,其倒排索引结构不会再改变,而增量添加的文档添加到新的段中,段之间在一定的时刻进行合并,从而形成新的倒排索引结构。

然而也正因为Lucene的事务性,使得Lucene的索引不够实时,如果想Lucene实时,则必须新添加的文档后IndexWriter需要commit,在搜索的时候IndexReader需要重新的打开,然而当索引在硬盘上的时候,尤其是索引非常大的时候,IndexWriter的commit操作和IndexReader的open操作都是非常慢的,根本达不到实时性的需要。

好在Lucene提供了RAMDirectory,也即内存中的索引,能够很快的commit和open,然而又存在如果索引很大,内存中不能够放下的问题。

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

1、初始化阶段

首先假设我们硬盘上已经有一个索引FileSystemIndex,由于IndexReader打开此索引非常的慢,因而其是需要事先打开的,并且不会时常的重新打开。

我们在内存中有一个索引MemoryIndex,新来的文档全部索引到内存索引中,并且是索引完IndexWriter就commit,IndexReader就重新打开,这两个操作时非常快的。

如下图,则此时新索引的文档全部能被用户看到,达到实时的目的。

点击查看原图

2、合并索引阶段

然而经过一段时间,内存中的索引会比较大了,如果不合并到硬盘上,则可能造成内存不够用,则需要进行合并的过程。

当然在合并的过程中,我们依然想让我们的搜索是实时的,这是就需要一个过渡的索引,我们称为MergingIndex。

一旦内存索引达到一定的程度,则我们重新建立一个空的内存索引,用于合并阶段索引新的文档,然后将原来的内存索引称为合并中索引,并启动一个后台线程进行合并的操作。

在合并的过程中,如果有查询过来,则需要三个IndexReader,一个是内存索引的IndexReader打开,这个过程是很快的,一个是合并中索引的IndexReader打开,这个过程也是很快的,一个是已经打开的硬盘索引的IndexReader,无需重新打开。这三个IndexReader可以覆盖所有的文档,唯一有可能重复的是,硬盘索引中已经有一些从合并中索引合并过去的文档了,然而不用担心,根据Lucene的事务性,在硬盘索引的IndexReader没有重新打开的情况下,背后的合并操作它是看不到的,因而这三个IndexReader所看到的文档应该是既不少也不多。合并使用IndexWriter(硬盘索引).addIndexes(IndexReader(合并中索引)),合并结束后Commit。

如下图:

点击查看原图

3、重新打开硬盘索引的IndexReader

当合并结束后,是应该重新打开硬盘索引的时候了,然而这是一个可能比较慢的过程,在此过程中,我们仍然想保持实时性,因而在此过程中,合并中的索引不能丢弃,硬盘索引的IndexReader也不要动,而是为硬盘索引打开一个临时的IndexReader,在打开的过程中,如果有搜索进来,返回的仍然是上述的三个IndexReader,仍能够不多不少的看到所有的文档,而将要打开的临时的IndexReader将能看到合并中索引和原来的硬盘索引所有的文档,此IndexReader并不返回给客户。如下图:

点击查看原图

4、替代IndexReader

当临时的IndexReader被打开的时候,其看到的是合并中索引的IndexReader和硬盘索引原来的IndexReader之和,下面要做的是:

(1) 关闭合并中索引的IndexReader

(2) 抛弃合并中索引

(3) 用临时的IndexReader替换硬盘索引原来的IndexReader

(4) 关闭硬盘索引原来的IndexReader。

上面说的这几个操作必须是原子性的,如果做了(2)但没有做(3),如果来一个搜索,则将少看到一部分数据,如果做了(3)没有做(2)则,多看到一部分数据。

所以在进行上述四步操作的时候,需要加一个锁,如果这个时候有搜索进来的时候,或者在完全没有做的时候得到所有的IndexReader,或者在完全做好的时候得到所有的IndexReader,这时此搜索可能被block,但是没有关系,这四步是非常快的,丝毫不影响替代性。

如下图:

点击查看原图

经过这几个过程,又达到了第一步的状态,则进行下一个合并的过程。

5、多个索引

有一点需要注意的是,在上述的合并过程中,新添加的文档是始终添加到内存索引中的,如果存在如下的情况,索引速度实在太快,在合并过程没有完成的时候,内存索引又满了,或者硬盘上的索引实在太大,合并和重新打开要花费太长的时间,使得内存索引以及满的情况下,还没有合并完成。

为了处理这种情况,我们可以拥有多个合并中的索引,多个硬盘上的索引,如下图:

点击查看原图

  • 新添加的文档永远是进入内存索引
  • 当内存索引到达一定的大小的时候,将其加入合并中索引链表
  • 有一个后台线程,每隔一定的时刻,将合并中索引写入一个新的硬盘索引中取。这样可以避免由于硬盘索引过大而合并较慢的情况。硬盘索引的IndexReader也是写完并重新打开后才替换合并中索引的IndexReader,新的硬盘索引也可保证打开的过程不会花费太长时间。
  • 这样会造成硬盘索引很多,所以,每隔一定的时刻,将硬盘索引合并成一个大的索引。也是合并完成后方才替换IndexReader

大家可能会发现,此合并的过程和Lucene的段的合并很相似。然而Lucene的一个函数IndexReader.reopen一直是没有实现的,也即我们不能选择哪个段是在内存中的,可以被打开,哪些是硬盘中的,需要在后台打开然后进行替换,而IndexReader.open是会打开所有的内存中的和硬盘上的索引,因而会很慢,从而降低了实时性。

在有关Lucene的问题(7),讨论了使用Lucene内存索引和硬盘索引构建实时索引的问题。

然而有的读者提到,如果涉及到文档的删除及更新,那么如何构建实时的索引呢?本节来讨论这个问题。

1、Lucene删除文档的几种方式

  • IndexReader.deleteDocument(int docID)是用 IndexReader 按文档号删除。  
  • IndexReader.deleteDocuments(Term  term)是用 IndexReader 删除包含此词(Term)的文档。  
  • IndexWriter.deleteDocuments(Term  term)是用 IndexWriter 删除包含此词(Term)的文档。  
  • IndexWriter.deleteDocuments(Term[]  terms)是用 IndexWriter 删除包含这些词(Term)的文档。  
  • IndexWriter.deleteDocuments(Query  query)是用 IndexWriter 删除能满足此查询(Query)的文档。  
  • IndexWriter.deleteDocuments(Query[] queries)是用 IndexWriter 删除能满足这些查询(Query)的文档。

删除文档既可以用reader进行删除,也可以用writer进行删除,不同的是,reader进行删除后,此reader马上能够生效,而用writer删除后,会被缓存,只有写入到索引文件中,当reader再次打开的时候,才能够看到。

2、Lucene文档更新的几个问题

2.1、使用IndexReader还是IndexWriter进行删除

既然IndexReader和IndexWriter都能够进行文档删除,那么到底是应该用哪个来进行删除呢?

本文的建议是,用IndexWriter来进行删除。

因为用IndexReader可能存在以下的问题:

(1) 当有一个IndexWriter打开的时候,IndexReader的删除操作是不能够进行的,否则会报LockObtainFailedException

(2) 当IndexReader被多个线程使用的时候,一个线程用其进行删除,会使得另一个线程看到的索引有所改变,使得另一个线程的结果带有不确定性。

(3) 对于更新操作,在Lucene中是先删除,再添加的,然而删除的被立刻看到的,而添加却不能够立刻看到,造成了数据的不一致性。

(4) 即便以上问题可以通过锁来解决,然而背后的操作影响到了搜索的速度,是我们不想看到的。

2.2、如何在内存中缓存文档的删除

在上一节中,为了能够做到实时性,我们使用内存中的索引,而硬盘上的索引则不经常打开,即便打开也在背后线程中打开。

而要删除的文档如果在硬盘索引中,如果不重新打开则看不到新的删除,则需要将删除的文档缓存到内存中。

那如何将缓存在内存中的文档删除在不重新打开IndexReader的情况下应用于硬盘上的索引呢?

在Lucene中,有一种IndexReader为FilterIndexReader,可以对一个IndexReader进行封装,我们可以实现一个自己的FilterIndexReader来过滤掉删除的文档。

一个例子如下:

public class MyFilterIndexReader extends FilterIndexReader {

  OpenBitSet dels;

  public MyFilterIndexReader(IndexReader in) {

    super(in);

    dels = new OpenBitSet(in.maxDoc());

  }

  public MyFilterIndexReader(IndexReader in, List<String> idToDelete) throws IOException {

    super(in);

    dels = new OpenBitSet(in.maxDoc());

    for(String id : idToDelete){

      TermDocs td = in.termDocs(new Term("id", id)); //如果能在内存中Cache从Lucene的ID到应用的ID的映射,Reader的生成将快得多。

      if(td.next()){

        dels.set(td.doc());

      }

    }

  }

  @Override

  public int numDocs() {

    return in.numDocs() - (int) dels.cardinality();

  }

  @Override

  public TermDocs termDocs(Term term) throws IOException {

    return new FilterTermDocs(in.termDocs(term)) {

      @Override

      public boolean next() throws IOException {

        boolean res;

        while ((res = super.next())) {

          if (!dels.get(doc())) {

            break;

          }

        }

        return res;

      }

    };

  }

  @Override

  public TermDocs termDocs() throws IOException {

    return new FilterTermDocs(in.termDocs()) {

      @Override

      public boolean next() throws IOException {

        boolean res;

        while ((res = super.next())) {

          if (!dels.get(doc())) {

            break;

          }

        }

        return res;

      }

    };

  }

}

2.3、文档更新的顺序性问题

Lucene的文档更新其实是删除旧的文档,然后添加新的文档。如上所述,删除的文档是缓存在内存中的,并通过FilterIndexReader应用于硬盘上的索引,然而新的文档也是以相同的id加入到索引中去的,这就需要保证缓存的删除不会将新的文档也过滤掉,将缓存的删除合并到索引中的时候不会将新的文档也删除掉。

Lucene的两次更新一定要后一次覆盖前一次,而不能让前一次覆盖后一次。

所以内存中已经硬盘中的多个索引是要被保持一个顺序的,哪个是老的索引,哪个是新的索引,缓存的删除自然是应该应用于所有比他老的索引的,而不应该应用于他自己以及比他新的索引。

3、具有更新功能的Lucene实时索引方案

3.1、初始化

首先假设我们硬盘上已经有一个索引FileSystemIndex,被事先打开的,其中包含文档1,2,3,4,5,6。

我们在内存中有一个索引MemoryIndex,新来的文档全部索引到内存索引中,并且是索引完IndexWriter就commit,IndexReader就重新打开,其中包含文档7,8。

点击查看原图

3.2、更新文档5

这时候来一个新的更新文档5, 需要首先将文档5删除,然后加入新的文档5。

需要做的事情是:

  • 首先在内存索引中删除文档5,当然没有文档5,删除无效。
  • 其次将对文档5的删除放入内存文档删除列表,并与硬盘的IndexReader组成FilterIndexReader
  • 最后,将新的文档5加入内存索引,这时候,用户可以看到的就是新的文档5了。
  • 将文档5放入删除列表以及将文档5提交到内存索引两者应该是一个原子操作,好在这两者都是比较块的。

注:此处对硬盘上的索引,也可以进行对文档5的删除,由于IndexReader没有重新打开,此删除是删不掉的,我们之所以没有这样做,是想保持此次更新要么全部在内存中,要么全部在硬盘中,而非删除部分已经应用到硬盘中,而新文档却在内存中,此时,如果系统crash,则新的文档5丢失了,而旧的文档5也已经在硬盘上被删除。我们将硬盘上对文档5的删除放到从内存索引向硬盘索引的合并过程。

点击查看原图

如果再有一次对文档5的更新,则首先将内存索引中的文档5删除,添加新的文档5,然后将文档5加入删除列表,发现已经存在,则不必删除。

3.3、合并索引

然而经过一段时间,内存中的索引需要合并到硬盘上。

在合并的过程中,需要重新建立一个空的内存索引,用于合并阶段索引新的文档,而合并中的索引的IndexReader以及硬盘索引和删除列表所组成的FilterIndexReader仍然保持打开,对外提供服务,而合并阶段从后台进行。

后台的合并包括以下几步:

  • 将删除列表应用到硬盘索引中。
  • 将内存索引合并到硬盘索引中。
  • IndexWriter提交。

点击查看原图

3.4、合并的过程中更新文档5

在合并的过程中,如果还有更新那怎么办呢?

  • 首先将合并中索引的文档5删除,此删除不会影响合并,因为合并之前,合并中索引的IndexReader已经打开,索引合并中索引的文档5还是会合并到硬盘中去的。此删除影响的是此后的查询在合并中索引是看不到文档5的。
  • 然后将文档5的删除放入删除列表,并同合并中索引的删除列表,已经硬盘索引一起构成FilterIndexReader。
  • 将新的文档5添加到内存中索引。
  • 提交在合并中索引对文档5的删除,将文档5添加到删除列表,提交在内存索引中对文档5的添加三者应该是一个原子操作,好在三者也是很快的。

点击查看原图

3.5、重新打开硬盘索引的IndexReader

当合并中索引合并到硬盘中的时候,是时候重新打开硬盘上的索引了,新打开的IndexReader是可以看到文档5的删除的。

如果这个时候有新的更新,也是添加到内存索引和删除列表的,比如我们更新文档6.

点击查看原图

3.6、替代IndexReader 

当IndexReader被重新打开后,则需要删除合并中的索引及其删除列表,将硬盘索引原来的IndexReader关闭,使用新的IndexReader。

 
点击查看原图