Lucene的使用与重构

忽然一想好久不写博客了，工作原因个人原因，这些天一直希望一天假如36个小时该多好，但是，假如不可能。

由于近期在项目中接触了lucene，这个已经没有人维护的全文搜索框架，确实踩了不少坑，为什么用lucene呢?其实我也不知道

关于lucene原理和全文搜索引擎的一些介绍，园子里有这几篇写的还是很好的

http://www.cnblogs.com/skybreak/archive/2013/05/06/3063520.html

http://kb.cnblogs.com/page/52642/

由于完全没有接触过lucene，一开始当然是从X度，bing上搜索关于lucene.net的教程，发现找不到好用的，lucene已经好久没有维护了，如果细心阅读源码会发现许多匪夷所思的设计。对于lucene可以理解为一个数据库，lucene提供了添加数据(创建索引)，以及快速全文检索的api。

通过学习，我们发现，lucene.net给我们很多对象

Lucene.Net.Store.Directory：lucene文档的存放目录，我这里把它理解为一张表，实际上这一张表的字段可以不一样

Lucene.Net.Documents.Documents：lucene文档，相当于一条数据

Lucene.Net.Index.IndexWriter：用于向Lucene.Net.Store.Directory中添加Lucene.Net.Documents.Documents

Lucene.Net.Analysis.Standard.StandardAnalyzer：词法分析器

当然，还有一系列查询的类，这里就不列举了，说了这么多，我这篇随笔主要介绍什么呢？

既然把lucene理解为一个数据库了，从框架使用者的角度看，不需要拘泥于lucene究竟是如何存储和检索数据的，当然,第一次使用时还是要学习的，但是写完了就会发现代码写的好繁琐啊，每次都要创建Directory，Analyzer写查询语句创建对象，比如项目一开始对站内所有信息进行检索，一次加入所有数据，搜索所有数据，没有问题，后来需要对另一个模块的信息进行单表检索，会发现代码逐渐开始乱了，但是由于时间问题和开发经验一开始很难想到好的设计。刚开始时，项目经理指导将每个需要全文搜索的对象先独立出来，实现一个接口，程序运行时反射实现该接口的类（暂且成他为LuceneModel），即可实现搜索，但是后来需求要实现两种语言的搜索，根据当前前端提供的cookie来查询指定语言的数据，于是我就又给每一个LuceneModel添加一个Language字段，并且Language字段的搜索是一个且的关系（在满足搜索关键字后并且该条数据的语言必须 为从cookie中读取的）。

显然，需要对搜索这个模块进行单独的维护了，这样修改方便，并且也可以供其他项目使用，也是软件设计原则吧！

IndexerAttribute

    [AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
    public class IndexerAttribute : Attribute
    {
        public bool Index;
        public bool Store;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="index">是否为其创建索引</param>
        /// <param name="store">是否存储原始数据</param>
        public IndexerAttribute(bool index,bool store)
        {
            Index = index;
            Store = store;
        }
    }

表示对模型具体字段的索引方式

LuceneDB

    public abstract class LuceneDB:IDisposable
    {
        private ILunceneDBPathProvider_dbPathProvider = LunceneDBPathProviders.Current;
        private string _dbPath;
        protected System.IO.DirectoryInfo _sysDirectory;
        protected Lucene.Net.Store.Directory _luDirectory;
        protected Lucene.Net.Analysis.Standard.StandardAnalyzer _analyzer;
        protected Lucene.Net.Index.IndexWriter _indexWriter;
        protected bool _isOpen = false;
        public LuceneDB(string path)
        {
            _dbPath = path;
        }
        public LuceneDB() { }
        public void SetDBPath(Type type)
        {
            if (null == _dbPath)
            {
                _dbPath = _dbPathProvider.Get(type);
            }
        }

        public string DBPath
        {
            get
            {
                return _dbPath;
            }
        }

        protected abstract void Open();
        public  virtual void Dispose()
        {
            _analyzer.Close();
            _analyzer.Dispose();
        }
    }

首先LuceneDB，表示一个连接对象，有子类LuceneDBIndexer和LuceneDBSearcher，两者用到的资源不一样，所以提供了一个需要实现的Open方法。通常情况下一个Lucene文件夹下有多个索引文件夹，每个索引文件夹有着相似的数据结构(同一个数据类型)，为了使这一个模块能够让别的项目使用，第一个要解决的问题就是Lucene文件夹位置的问题了，对于web项目,可以存在APPData也可以存在bin目录下，这里也照顾了下对于Console应用。

ILunceneDBPathProvider

    public interface ILunceneDBPathProvider
    {
        string Get(Type type);
    }

默认的是一个AppDataLunceneDBPathProvider

    public class AppDataLunceneDBPathProvider : ILunceneDBPathProvider
    {
        private string _prePath = AppDomain.CurrentDomain.BaseDirectory;
        public string Get(Type type)
        {
            return _prePath + @"App_DataIndex" + type.Name;
        }
    }

这样如果有需要检索的User类，他的lucene文件夹就为App_DataIndexUser

LuceneDBIndexer

    public class LuceneDBIndexer: LuceneDB
    {
        private Dictionary<Type,IEnumerable<PropertyInfo>> _tempProps;
        public LuceneDBIndexer(string path) : base(path)
        {
        }
        public LuceneDBIndexer() { }
        protected override void Open()
        {
            if (_isOpen)
            {
                Dispose();
            }
            if (!System.IO.Directory.Exists(DBPath))
            {
                System.IO.Directory.CreateDirectory(DBPath);
            }
            _analyzer = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
            _luDirectory = Lucene.Net.Store.FSDirectory.Open(new System.IO.DirectoryInfo(DBPath));
            _indexWriter = new Lucene.Net.Index.IndexWriter(_luDirectory, _analyzer, true, Lucene.Net.Index.IndexWriter.MaxFieldLength.LIMITED);
            _isOpen = true;
        }
        public IEnumerable<PropertyInfo> GetProps(Type type)
        {
            if(null == _tempProps)
            {
                _tempProps = new Dictionary<Type, IEnumerable<PropertyInfo>>();
            }
            if (!_tempProps.ContainsKey(type))
            {
                _tempProps.Add(type, type.GetProperties().Where(prop => null != prop.GetCustomAttribute(typeof(IndexerAttribute), true)));
            }
            return _tempProps[type];
        }

        public void Add<T>(T obj)
        {
            SetDBPath(typeof(T));
            Open();

            Document document = new Document();
            foreach (var prop in GetProps(typeof(T)))
            {
                var value = prop.GetValue(obj)?.ToString();
                if(null != value)
                {
                    var attr = prop.GetCustomAttribute(typeof(IndexerAttribute), true) as IndexerAttribute;
                    var store = attr.Store ? Field.Store.YES : Field.Store.NO;
                    var index = attr.Index ? Field.Index.ANALYZED : Field.Index.NOT_ANALYZED;

                    document.Add(new Field(prop.Name, value, store, index));
                }
            }

            _indexWriter.AddDocument(document);
        }

        public void AddRange<T>(IEnumerable<T> objs)
        {
            SetDBPath(typeof(T));
            Open();

            foreach (var obj in objs)
            {
                Document document = new Document();
                foreach (var prop in GetProps(typeof(T)))
                {
                    var value = prop.GetValue(obj)?.ToString();
                    if (null != value)
                    {
                        var attr = prop.GetCustomAttribute<IndexerAttribute>();
                        var store = attr.Store ? Field.Store.YES : Field.Store.NO;
                        var index = attr.Index ? Field.Index.ANALYZED : Field.Index.NOT_ANALYZED;

                        document.Add(new Field(prop.Name, value, store, index));
                    }
                }
                _indexWriter.AddDocument(document);
            }
        }
        public override void Dispose()
        {
            _indexWriter.Optimize();
            _indexWriter.Dispose();
            base.Dispose();
        }
    }

这个类用于创建索引，会读取用在对象上的Indexer标签

LuceneDBSearcher

    public class LuceneDBSearcher: LuceneDB
    {
        private Type _searchType;
        public LuceneDBSearcher(string path) : base(path)
        {
        }
        public LuceneDBSearcher(Type type)
        {
            SetDBPath(type);
        }
        public LuceneDBSearcher() { }
        public Type SearchType
        {
            set
            {
                //判断该类型是否实现 某 约定
                _searchType = value;
            }
            get { return _searchType; }
        }
        public IEnumerable<T> Search<T>(string searchText, IEnumerable<string> fields, int page, int pageSize, Dictionary<string,string> condition= null) where T : new()
        {
            return GetModels<T>(SearchText(searchText, fields, page, pageSize, condition));
        }
  

        private IEnumerable<Document> SearchText(string searchText,IEnumerable<string> fields,int page,int pageSize, Dictionary<string,string> condition)
        {
            StringBuilder conditionWhere = new StringBuilder();

            foreach (var item in condition)
            {
                conditionWhere.Append(" +" + item.Key + ":" + item.Value);
            }

            Open();

            var parser = new Lucene.Net.QueryParsers.MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, fields.ToArray(), _analyzer);
            var search = new Lucene.Net.Search.IndexSearcher(_luDirectory, true);

            var query = parser.Parse("+" + searchText + conditionWhere.ToString());

            var searchDocs = search.Search(query, 100).ScoreDocs;

            return searchDocs.Select(t => search.Doc(t.Doc));
        }

        protected override void Open()
        {
            _luDirectory = Lucene.Net.Store.FSDirectory.Open(new System.IO.DirectoryInfo(DBPath));
            if (Lucene.Net.Index.IndexWriter.IsLocked(_luDirectory))
            {
                Lucene.Net.Index.IndexWriter.Unlock(_luDirectory);
            }
            var lockFilePath = System.IO.Path.Combine(DBPath, "write.lock");
            
            if (System.IO.File.Exists(lockFilePath))
            {
                System.IO.File.Delete(lockFilePath);
            }

            _analyzer = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
        }
        private IEnumerable<T> GetModels<T>(IEnumerable<Document> documents) where T:new()
        {
            var type = typeof(T);
            var props = type.GetProperties().Where(prop => null != prop.GetCustomAttribute(typeof(IndexerAttribute), true));
            var objs = new List<T>();
            foreach (var document in documents)
            {
                var obj = new T();
                foreach (var prop in props)
                {
                    var attr = prop.GetCustomAttribute<IndexerAttribute>();

                    if (null != attr && attr.Store)
                    {
                        object v = Convert.ChangeType(document.Get(prop.Name), prop.PropertyType);
                        prop.SetValue(obj, v);
                    }
                }
                objs.Add(obj);
            }
            return objs;
        }
        private T GetModel<T>(Document document) where T : new()
        {
            var type = typeof(T);
            var props = type.GetProperties().Where(prop => null != prop.GetCustomAttribute(typeof(IndexerAttribute), true));

            var obj = new T();
            foreach (var prop in props)
            {
                var attr = prop.GetCustomAttribute<IndexerAttribute>();

                if (null != attr && attr.Store)
                {
                    object v = Convert.ChangeType(document.Get(prop.Name), prop.PropertyType);
                    prop.SetValue(obj, v);
                }
            }
            return obj;
        }
        public override void Dispose()
        {
            _analyzer.Dispose();
            base.Dispose();
        }
    }

用于检索Lucene文件夹并将数据转为对象

LuceneEntityBase

    public abstract class LuceneEntityBase:ILuceneStored
    {
        #region private
        private Dictionary<string, PropertyInfo> _propertiesCache;
        #endregion

        #region IndexerFields
        #region ILuceneStored
        [Indexer(false, true)]
        public string ID { get; set; }
        [Indexer(true, false)]
        public string _Customer { get; set; }
        [Indexer(true, false)]
        public string _Category { get; set; }
        #endregion

        /// <summary>
        /// 图片
        /// </summary>
        [Indexer(false, true)]
        public string Picture { get; set; }
        /// <summary>
        /// 标题
        /// </summary>
        [Indexer(true, true)]
        public string Title { get; set; }
        /// <summary>
        /// 简介
        /// </summary>
        [Indexer(true, true)]
        public string Synopsis { get; set; }
        /// <summary>
        /// 链接
        /// </summary>
        [Indexer(false, true)]
        public string Url { get; set; }
        #endregion

        public LuceneEntityBase()
        {

        }
        

        protected IEnumerable<T> Search<T>(string searchText, int page, int pageSize, object condition = null) where T:new ()
        {
            var ConditionDictionary = null != condition ?  InitConditionSearchFields(condition) : new Dictionary<string, string>();

            var fullTextSearchFields = from propName in PropertiesCache.Select(t => t.Key)
                                       where !ConditionDictionary.ContainsKey(propName)
                                       select propName;

            using (var luceneDB = new LuceneDBSearcher(GetType()))
            {
                return luceneDB.Search<T>(searchText, fullTextSearchFields, page, pageSize, ConditionDictionary);
            }
        }
        /// <summary>
        /// 属性缓存
        /// </summary>
        protected Dictionary<string, PropertyInfo> PropertiesCache
        {
            get
            {
                if(null == _propertiesCache)
                {
                    _propertiesCache = new Dictionary<string, PropertyInfo>();
                    foreach (var prop in GetType().GetProperties())
                    {
                        var attr = prop.GetCustomAttribute<IndexerAttribute>(true);

                        if (null != attr && attr.Index)
                        {
                            _propertiesCache.Add(prop.Name, prop);
                        }
                    }
                }
                return _propertiesCache;
            }
        }

        /// <summary>
        /// 初始化 且 条件
        /// </summary>
        protected virtual Dictionary<string, string> InitConditionSearchFields(object andCondition)
        {
            var _conditionDictionary = new Dictionary<string, string>();

            var type = GetType();
            var andConditionType = andCondition.GetType();
            var conditions = type.GetInterfaces().Where(t => typeof(ICondition).IsAssignableFrom(t) && t!= typeof(ICondition))
                                                 .SelectMany(t => t.GetProperties() /*t.GetInterfaceMap(t).InterfaceMethods*/)
                                                 .Select(t => t.Name);
            foreach (var condition in conditions)
            {
                if (!_conditionDictionary.ContainsKey(condition))
                {
                    _conditionDictionary.Add(condition, andConditionType.GetProperty(condition).GetValue(andCondition)?.ToString() ?? string.Empty);
                }
            }

            return _conditionDictionary;
        }
    }

需要索引的抽象基类

一般而言搜索结果有一个标题，介绍，图片等等，介绍和标题是数据库（这里是db）中实际存储的，然而对于搜索的关键字确实没有的，比如（在博客园中）有一个博客表，表里面存博客标题，博客主要内容，还有一个问道表，用户提的问题，介绍，等等，此时如果用户来到博客园中，键入博客（可能已进入首页都是博客，但是用户还是键入了博客），然而db中却不知道那个是博客？？仔细想是不是这样子的，这里_Customer就是设定这些数据的，当然也可以是_Category。

结下来介绍一个比较重要的接口。

ICondition

    public interface ICondition { }

作为一个空接口，如果不能找到一个它不应该存在的理由，那它就真的不应该存在了。在上面说的LuceneEntityBase中，所有的字段都是全文搜索的，即任何一个字段数据匹配用户键入的值都可能称谓匹配的文档，这是假如需要匹配另一个条件该如何？写代码之初只考虑到一个语言条件，再添加一个参数，具体改一下搜索的方法就可以了，这样一样知识需要改三处，搜索入口（控制器），给该模型添加一个语言字段，具体的搜索方法也要改一下，甚至写索引的方法也都要改。然而有了这个接口，我们只需要实现一个ILanguage继承该接口,然后事具体的模型也继承ILanguage就行。

    public interface ILanguage: ICondition
    {
        string Language { get; set; }
    }

在看一下上面LuceneEntityBase中创建且条件的方法，会解析出ICondition中的属性并设置为必须条件

        var _conditionDictionary = new Dictionary<string, string>();

        var type = GetType();
        var andConditionType = andCondition.GetType();
        var conditions = type.GetInterfaces().Where(t => typeof(ICondition).IsAssignableFrom(t) && t!= typeof(ICondition))
                                             .SelectMany(t => t.GetProperties() /*t.GetInterfaceMap(t).InterfaceMethods*/)
                                             .Select(t => t.Name);
        foreach (var condition in conditions)
        {
            if (!_conditionDictionary.ContainsKey(condition))
            {
                _conditionDictionary.Add(condition, andConditionType.GetProperty(condition).GetValue(andCondition)?.ToString() ?? string.Empty);
            }
        }

实例之三国人物

用上面封装后的类建立了一个简易的搜索示例

核心代码只有以下三部分，数据的话都爬虫字自百度百科

    public class Figure : Lyrewing.Search.LuceneEntityBase, ICountry
    {
        [Indexer(true,true)]
        public string Country { get; set; }
        [Indexer(true,true)]
        public string FigureName { get; set; }
        /// <summary>
        /// 称谓
        /// </summary>
        [Indexer(true,true)]
        public string Appellation { get; set; }
        /// <summary>
        /// 关键字
        /// </summary>
        [Indexer(true,true)]
        public string KeyWords { get; set; }
        public IEnumerable<Figure> Search(string searchText, int page, int pageSize, object condition = null)
        {
            return Search<Figure>(searchText, page, pageSize, condition);
        }
    }
    public interface ICountry : ICondition
    {
        string Country { get; set; }
    }

   using (var luceneDB = new LuceneDBIndexer())
   {
        luceneDB.AddRange(Figures);
   }

    var seacher = new Figure();

    var result = seacher.Search(key, 1, 100, country != Country.默认 ? new { Country = country.ToString() } : null);

小结：

通过这次从lucene的踩坑，到lucene的重构，以及代码的一些思考，发现过程是艰辛的，代码现在也不是完美的，lucene的一些其他复杂的查询也没有加进去，但是从这个过程来说对自己来说是值得的，依稀记得实习的时候以为老师讲过的一句话，貌似高三语文老师也讲过哈，信达雅，但是这个过程是不易的，还需要更多的学习和挑战！