Net Core使用Lucene.Net和盘古分词器 实现全文检索

lucene.net

lucene.net是lucene的.net移植版本，是一个开源的全文检索引擎开发包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，是一个高性能、可伸缩的文本搜索引擎库。它的功能就是负责将文本数据按照某种分词算法进行切词，分词后的结果存储在索引库中，从索引库检索数据的速度非常快。lucene.net需要有索引库，并且只能进行站内搜索。（来自百度百科）

效果图

盘古分词

如何使用

将pangu.dil与pangu.lucenet.analyzer. dl并加入到项目中

 

将dict文件，拷贝到项目bin文件夹里面

字典文件夹下载：https://pan.baidu.com/s/1hnilp6bccodn8vqlck066g 提取码: xydc

测试

 可以看到，盘古分词相对lucene.net自带的一元分词来说，是比较好的，因为一元分词不适合进行中文检索。

一元分词是按字拆分的，比如上面一句话，使用一元分词拆分的结果是："有","一","种","方","言","叫","做","不","老","盖","儿"。如果查找“方言”这个词，是找不到查询结果的。不符合我们的检索习惯，所以基本不使用。

拓展

上面的"不老盖儿"（河南方言），这里想组成一个词，那么需要创建"不老盖儿"词组并添加到字典里面。

使用dictmanage工具：https://pan.baidu.com/s/1yla2dbm74ksbno8cg5kvgw 提取码：tphe

解压，运行 dictmanage.exe 

然后打开 dict 文件下的 dict.dct 文件，并添加"不老盖儿"词组

 然后查找就可以看到"不老盖儿"词组

 然后保存覆盖原有的 dict.dct 文件

刷新页面或者重新打开页面看下效果

demo文件说明

简单实现 

创建索引核心代码

        /// <summary>
        /// 创建索引
        /// </summary>
        /// <returns></returns>
        [httpget]
        [route("createindex")]
        public string createindex()
        {
            //索引保存位置
            var indexpath = directory.getcurrentdirectory() + "/index";
            if (!directory.exists(indexpath)) directory.createdirectory(indexpath);
            fsdirectory directory = fsdirectory.open(new directoryinfo(indexpath), new nativefslockfactory());
            if (indexwriter.islocked(directory))
            {
                //  如果索引目录被锁定（比如索引过程中程序异常退出），则首先解锁
                //  lucene.net在写索引库之前会自动加锁，在close的时候会自动解锁
                indexwriter.unlock(directory);
            }
            //lucene的index模块主要负责索引的创建
            //  创建向索引库写操作对象  indexwriter(索引目录,指定使用盘古分词进行切词,最大写入长度限制)
            //  补充:使用indexwriter打开directory时会自动对索引库文件上锁
            //indexwriter构造函数中第一个参数指定索引文件存储位置；
            //第二个参数指定分词analyzer，analyzer有多个子类，
            //然而其分词效果并不好，这里使用的是第三方开源分词工具盘古分词；
            //第三个参数表示是否重新创建索引，true表示重新创建（删除之前的索引文件），
            //最后一个参数指定field的最大数目。
            indexwriter writer = new indexwriter(directory, new panguanalyzer(), true,
                indexwriter.maxfieldlength.unlimited);
            var txtpath = directory.getcurrentdirectory() + "/upload/articles";
            for (int i = 1; i <= 1000; i++)
            {
                //  一条document相当于一条记录
                document document = new document();
                var title = "天骄战纪_" + i + ".txt";
                var content = system.io.file.readalltext(txtpath + "/" + title, encoding.default);
                //  每个document可以有自己的属性（字段），所有字段名都是自定义的，值都是string类型
                //  field.store.yes不仅要对文章进行分词记录，也要保存原文，就不用去数据库里查一次了
                document.add(new field("title", "天骄战纪_" + i, field.store.yes, field.index.not_analyzed));
                //  需要进行全文检索的字段加 field.index. analyzed
                //  field.index.analyzed:指定文章内容按照分词后结果保存，否则无法实现后续的模糊查询 
                //  with_positions_offsets:指示不仅保存分割后的词，还保存词之间的距离
                document.add(new field("content", content, field.store.yes, field.index.analyzed, field.termvector.with_positions_offsets));
                writer.adddocument(document);
            }
            writer.close(); // close后自动对索引库文件解锁
            directory.close(); //  不要忘了close，否则索引结果搜不到
            return "索引创建完毕";
        }

搜索代码

        /// <summary>
        /// 搜索
        /// </summary>
        /// <returns></returns>
        [httpget]
        [route("search")]
        public object search(string keyword, int pageindex, int pagesize)
        {
            stopwatch stopwatch = new stopwatch();
            stopwatch.start();
            string indexpath = directory.getcurrentdirectory() + "/index";
            fsdirectory directory = fsdirectory.open(new directoryinfo(indexpath), new nolockfactory());
            indexreader reader = indexreader.open(directory, true);
            //创建indexsearcher准备进行搜索。
            indexsearcher searcher = new indexsearcher(reader);
            // 查询条件
            keyword = getkeywordssplitbyspace(keyword, new pangutokenizer());
            //创建queryparser查询解析器。用来对查询语句进行语法分析。
            //queryparser调用parser进行语法分析，形成查询语法树，放到query中。
            queryparser msgqueryparser = new queryparser(lucene.net.util.version.lucene_29, "content", new panguanalyzer(true));
            query msgquery = msgqueryparser.parse(keyword);
            //topscoredoccollector:盛放查询结果的容器
            //numhits 获取条数
            topscoredoccollector collector = topscoredoccollector.create(1000, true);
            //indexsearcher调用search对查询语法树query进行搜索，得到结果topscoredoccollector。
            // 使用query这个查询条件进行搜索，搜索结果放入collector
            searcher.search(msgquery, null, collector);
            // 从查询结果中取出第n条到第m条的数据
            scoredoc[] docs = collector.topdocs(0, 1000).scoredocs;
            stopwatch.stop();
            // 遍历查询结果
            list<returnmodel> resultlist = new list<returnmodel>();
            var pm = new page<returnmodel>
            {
                pageindex = pageindex,
                pagesize = pagesize,
                totalrows = docs.length
            };
            pm.totalpages = pm.totalrows / pagesize;
            if (pm.totalrows % pagesize != 0) pm.totalpages++;
            for (int i = (pageindex - 1) * pagesize; i < pageindex * pagesize && i < docs.length; i++)
            {
                var doc = searcher.doc(docs[i].doc);
                var content = highlighthelper.highlight(keyword, doc.get("content"));
                var result = new returnmodel
                {
                    title = doc.get("title"),
                    content = content,
                    count = regex.matches(content, "<font").count
                };
                resultlist.add(result);
            }

            pm.lslist = resultlist;
            var elapsedtime = stopwatch.elapsedmilliseconds + "ms";
            var list = new { list = pm, ms = elapsedtime };
            return list;
        }

盘古分词

        /// <summary>
        /// 盘古分词
        /// </summary>
        /// <param name="words"></param>
        /// <returns></returns>
        public static object pangu(string words)
        {
            analyzer analyzer = new panguanalyzer();
            tokenstream tokenstream = analyzer.tokenstream("", new stringreader(words));
            lucene.net.analysis.token token = null;
            var str = "";
            while ((token = tokenstream.next()) != null)
            {
                string word = token.termtext(); // token.termtext() 取得当前分词
                str += word + "   |  ";
            }
            return str;
        }

搜索结果高亮显示

        /// <summary>
        /// 搜索结果高亮显示
        /// </summary>
        /// <param name="keyword"> 关键字 </param>
        /// <param name="content"> 搜索结果 </param>
        /// <returns> 高亮后结果 </returns>
        public static string highlight(string keyword, string content)
        {
            // simplehtmlformatter：这个类是一个html的格式类，构造函数有两个，一个是开始标签，一个是结束标签。
            simplehtmlformatter simplehtmlformatter =
                new simplehtmlformatter("<font style=\"color:red;" +
                                        "font-family:'cambria'\"><b>", "</b></font>");
            // 创建 highlighter ，输入htmlformatter 和 盘古分词对象semgent
            highlighter highlighter =
                new highlighter(simplehtmlformatter,
                    new segment());
            // 设置每个摘要段的字符数
            highlighter.fragmentsize = int.maxvalue;
            // 获取最匹配的摘要段
            var str = highlighter.getbestfragment(keyword, content);
            return str;
        }

对关键字进行盘古分词处理

        /// <summary>
        /// 对关键字进行盘古分词处理
        /// </summary>
        /// <param name="keywords"></param>
        /// <param name="kttokenizer"></param>
        /// <returns></returns>
        private static string getkeywordssplitbyspace(string keywords, pangutokenizer kttokenizer)
        {
            stringbuilder result = new stringbuilder();
            icollection<wordinfo> words = kttokenizer.segmenttowordinfos(keywords);

            foreach (wordinfo word in words)
            {
                if (word == null)
                {
                    continue;
                }
                result.appendformat("{0}^{1}.0 ", word.word, (int)math.pow(3, word.rank));
            }
            return result.tostring().trim();
        }

github：https://github.com/tenghao6/lucene-pangu