Lucene学习：工具类

1.1. Lucene工具类

为了后面的开发、测试方便，这里编写一个工具类：

  1 import java.io.IOException;
  2
  3 import java.nio.file.Paths;
  4
  5 import java.util.List;
  6
  7
  8
  9 import org.apache.lucene.analysis.Analyzer;
 10
 11 import org.apache.lucene.document.Document;
 12
 13 import org.apache.lucene.index.DirectoryReader;
 14
 15 import org.apache.lucene.index.IndexReader;
 16
 17 import org.apache.lucene.index.IndexWriter;
 18
 19 import org.apache.lucene.index.IndexWriterConfig;
 20
 21 import org.apache.lucene.index.IndexableField;
 22
 23 import org.apache.lucene.search.IndexSearcher;
 24
 25 import org.apache.lucene.search.Query;
 26
 27 import org.apache.lucene.search.ScoreDoc;
 28
 29 import org.apache.lucene.search.TopDocs;
 30
 31 import org.apache.lucene.search.highlight.Formatter;
 32
 33 import org.apache.lucene.search.highlight.Highlighter;
 34
 35 import org.apache.lucene.search.highlight.QueryScorer;
 36
 37 import org.apache.lucene.search.highlight.Scorer;
 38
 39 import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
 40
 41 import org.apache.lucene.store.Directory;
 42
 43 import org.apache.lucene.store.FSDirectory;
 44
 45 import org.slf4j.Logger;
 46
 47 import org.slf4j.LoggerFactory;
 48
 49 import org.wltea.analyzer.lucene.IKAnalyzer;
 50
 51
 52
 53 import cn.lmc.myworld.common.utils.PropertyUtil;
 54
 55
 56
 57
 58
 59 /**
 60
 61  * 全文检索工具类
 62
 63  * @author limingcheng
 64
 65  *
 66
 67  */
 68
 69 public class LuceneUtils {
 70
 71     // 打印日志
 72
 73 private static final Logger LOGGER = LoggerFactory.getLogger(LuceneUtils.class);
 74
 75
 76
 77     private static Directory directory; // 索引文件存放目录对象
 78
 79     private static IndexWriter indexWriter; // 索引写对象,线程安全
 80
 81     private static IndexReader indexReader; // 索引读对象，线程安全
 82
 83     private static IndexSearcher indexSearcher; // 索引搜索对象，线程安全
 84
 85     private static Analyzer analyzer; // 分词器对象
 86
 87     public static IndexWriterConfig indexWriterConfig; // 索引配置
 88
 89 //    public static Version matchVersion; // 索引版本(Lucene4.0之前需要用到，4.0之后被取消)
 90
 91
 92
 93 static{
 94
 95 try {
 96
 97      //初始化索引文件存放目录对象
 98
 99 // directory =
100
101 // FSDirectory.open(Paths.get((String)PropertyUtil.getParamFromConfig("lucene.index.directory")));
102
103 directory = FSDirectory.open(Paths.get("E://index"));
104
105 // 虚拟机退出时关闭
106
107 Runtime.getRuntime().addShutdownHook(new Thread(){
108
109 @Override
110
111 public void run() {
112
113 LOGGER.info("--------Lucene释放关闭资源中....");
114
115 try{
116
117 //释放关闭资源
118
119 if(null!=indexWriter){
120
121 indexWriter.close();
122
123 }
124
125 if(null!=indexReader){
126
127 indexReader.close();
128
129 }
130
131 if(null!=directory){
132
133 directory.close();
134
135 }
136
137 if(null!=analyzer){
138
139 analyzer.close();
140
141 }
142
143 } catch (IOException e) {
144
145 e.printStackTrace();
146
147 }
148
149 LOGGER.info("--------Lucene释放关闭资源成功....");
150
151 }
152
153 });
154
155
156
157 } catch (Exception e) {
158
159        e.printStackTrace();
160
161     }
162
163 }
164
165
166
167 /**
168
169      *
170
171      * @return 返回用于操作索引的对象
172
173      * @throws IOException
174
175      */
176
177     public static IndexWriter getIndexWriter() throws IOException{
178
179      if(null==indexWriter){
180
181             // 初始化IK分词器
182
183             Analyzer analyzer = getAnalyzer();
184
185             // 初始化索引的写配置对象
186
187             indexWriterConfig = new IndexWriterConfig(analyzer);
188
189             // 初始化索引的写对象
190
191             indexWriter=new IndexWriter(directory, indexWriterConfig);
192
193          }
194
195          return indexWriter;
196
197     }
198
199
200
201     /**
202
203      *
204
205      * @return 返回用于操作索引的对象
206
207      * @throws IOException
208
209      */
210
211     public static IndexReader getIndexReader() throws IOException{
212
213      indexReader = DirectoryReader.open(directory);
214
215         return indexReader;
216
217     }
218
219
220
221     /**
222
223      *
224
225      * @return 返回用于读取索引的对象
226
227      * @throws IOException
228
229      */
230
231     public static IndexSearcher getIndexSearcher() throws IOException{
232
233         indexReader = DirectoryReader.open(directory);
234
235         indexSearcher = new IndexSearcher(indexReader);
236
237         return indexSearcher;
238
239     }
240
241
242
243     /**
244
245      *
246
247      * @return 返回用于读取索引的对象
248
249      * @throws IOException
250
251      */
252
253     public static IndexSearcher getIndexSearcher(Directory directory) throws IOException{
254
255      indexReader = DirectoryReader.open(directory);
256
257         indexSearcher = new IndexSearcher(indexReader);
258
259         return indexSearcher;
260
261     }
262
263
264
265     /**
266
267      *
268
269      * @return 返回版本信息
270
271      */
272
273 //    public static Version getMatchVersion() {
274
275 //        return matchVersion;
276
277 //    }
278
279
280
281     /**
282
283      *
284
285      * @return 返回分词器
286
287      */
288
289     public static Analyzer getAnalyzer() {
290
291      // Lucene4以前的版本需要用到版本配置
292
293      // matchVersion = Version.LUCENE_44;
294
295      // 分词器
296
297      // analyzer = new StandardAnalyzer(); // 标准分词
298
299      if(analyzer == null) {
300
301      System.out.println("创建新的分析器");
302
303      analyzer = new IKAnalyzer();
304
305      }
306
307         return analyzer;
308
309     }
310
311
312
313     /**
314
315      * 打印一个文档的所有字段的内容
316
317      * @param
318
319      */
320
321     public static void printDocument(Document document){
322
323      //打印具体字段
324
325      List<IndexableField> fieldList = document.getFields();
326
327      //遍历列表
328
329      for (IndexableField field : fieldList){
330
331      //打印出所有的字段的名字和值（必须存储了的）
332
333      LOGGER.info(field.name()+":"+field.stringValue());
334
335      }
336
337      //文档详情
338
339      LOGGER.info(document.toString());
340
341     }
342
343
344
345     /**
346
347      * 打印ScoreDoc
348
349      * @param scoreDoc
350
351      * @throws IOException
352
353      */
354
355     public static void printScoreDoc(ScoreDoc scoreDoc) throws IOException{
356
357      //获取文档的编号（类似索引主键）
358
359      int docId = scoreDoc.doc;
360
361      LOGGER.info("======文档编号："+docId);
362
363      // 取出文档得分
364
365      LOGGER.info("得分： " + scoreDoc.score);
366
367      //获取具体文档
368
369      Document document = indexSearcher.doc(docId);
370
371      //打印具体字段
372
373      printDocument(document);
374
375     }
376
377
378
379     /**
380
381      * 打印命中的文档（带得分）的详情
382
383      * @param topDocs
384
385      */
386
387     public static void printTopDocs(TopDocs topDocs) throws IOException {
388
389      // 1)打印总记录数（命中数）：类似于百度为您找到相关结果约100,000,000个
390
391      long totalHits = topDocs.totalHits.value;
392
393      LOGGER.info("查询（命中）总的文档条数："+totalHits);
394
395 //      LOGGER.info("查询（命中）文档最大分数："+topDocs.getMaxScore());
396
397      //2)获取指定的最大条数的、命中的查询结果的文档对象集合
398
399      ScoreDoc[] scoreDocs = topDocs.scoreDocs;
400
401      //打印具体文档
402
403      for (ScoreDoc scoreDoc : scoreDocs) {
404
405      printScoreDoc(scoreDoc);
406
407      }
408
409     }
410
411
412
413     public static void printTopDocsByQueryForHighlighter(Query query, int n) throws Exception{
414
415
416
417        //=========1.创建一个高亮工具对象
418
419        // 格式化器：参数1：前置标签，参数2：后置标签
420
421        Formatter formatter = new SimpleHTMLFormatter("<em>", "</em>");
422
423        //打分对象，参数：query里面的条件，条件里面有搜索关键词
424
425        Scorer fragmentScorer = new QueryScorer(query);
426
427        //高亮工具
428
429        //参数1.需要高亮什么颜色, 参数2.将哪些关键词进行高亮
430
431        Highlighter highlighter = new Highlighter(formatter, fragmentScorer);
432
433        //=======搜索相关
434
435        IndexSearcher indexSearcher = getIndexSearcher();
436
437        // 搜索数据,两个参数：查询条件对象要查询的最大结果条数
438
439        // 返回的结果是 按照匹配度排名得分前N名的文档信息（包含查询到的总条数信息、所有符合条件的文档的编号信息）
440
441        TopDocs topDocs = indexSearcher.search(query, n);
442
443        // 打印命中的总条数
444
445 //     LOGGER.info("本次搜索共" + topDocs.totalHits + "条数据,最高分："+topDocs.getMaxScore());
446
447
448
449        // 获取得分文档对象（ScoreDoc）数组.SocreDoc中包含：文档的编号、文档的得分
450
451        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
452
453
454
455        //循环
456
457        for (ScoreDoc scoreDoc : scoreDocs) {
458
459         // 取出文档编号
460
461         int docID = scoreDoc.doc;
462
463         System.out.println("=========文档的编号是："+docID);
464
465         // 取出文档得分
466
467         System.out.println("当前文档得分： " + scoreDoc.score);
468
469         // 根据编号去找文档
470
471         Document document = indexSearcher.doc(docID);
472
473         //获取文档的所有字段对象
474
475         List<IndexableField> fieldList= document.getFields();
476
477         //遍历列表
478
479         for (IndexableField field : fieldList) {
480
481         String highlighterValue = highlighter.getBestFragment(getAnalyzer(), field.name(), field.stringValue());
482
483         //如果没有得到高亮的值
484
485         if (null==highlighterValue) {
486
487         //则让高亮结果等不高亮的值
488
489         highlighterValue = field.stringValue();
490
491         }
492
493         //打印出所有的字段的名字和值（必须存储了的）
494
495         LOGGER.info(field.name()+":"+highlighterValue);
496
497         }
498
499
500
501         }
502
503     }
504
505
506
507 }

原文地址：https://www.cnblogs.com/bestlmc/p/11865680.html

时间： 2024-10-05 04:56:14

Lucene学习：工具类的相关文章

一步一步跟我学习lucene（8）---lucene搜索之索引的查询原理和查询工具类示例

昨天我们了解了lucene搜索之IndexSearcher构建过程(http://blog.csdn.net/wuyinggui10000/article/details/45698667),对lucene的IndexSearcher有一个大体的了解,知道了怎么创建IndexSearcher,就要开始学会使用IndexSearcher进行索引的搜索,本节我们学习索引的查询原理和根据其相关原理写索引查询的工具类的编写: IndexSearcher提供了几个常用的方法: IndexSearcher.

【Unity 3D】学习笔记二十八：unity工具类

unity为开发者提供了很多方便开发的工具,他们都是由系统封装的一些功能和方法.比如说:实现时间的time类,获取随机数的Random.Range( )方法等等. 时间类 time类,主要用来获取当前的系统时间. using UnityEngine; using System.Collections; public class Script_04_13 : MonoBehaviour { void OnGUI() { GUILayout.Label("当前游戏时间:" + Time.t

Apache commons lang工具类学习笔记(2)--StringUtils

StringUtils工具类具有对String具有简单而强大的处理能力,从检查空串到分割字符串,到生成格式化的字符串,使用都很方便简洁,能减少很多代码量; 详细的使用方法可以参考下面的例子或者官方的API(http://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/StringUtils.html#isAlpha(java.lang.CharSequence)) packa

观察者模式学习--使用jdk的工具类简单实现

观察者模式学习之二:使用jdk的自带的工具类实现,与自己实现相比,两者有以下的区别: 1,自己实现,需要定义观察者的接口类和目标对象的接口类.使用java util的工具类,则不需要自己定义观察者和目标对象的接口类了,jdk已经定义好了. 2,自己实现,具体的目标对象类中,实现了接口方法后,还必须要自己实现维护观察者的注册删除信息.但是使用jdk,则不需要了,在 jdk的util下的observable类里面已经帮忙维护好了. 3,目标对象触发观察者的update的通知方式有了变化,自己的实现,

MySQL数据库学习笔记（十）----JDBC事务处理、封装JDBC工具类

首先需要回顾一下上一篇文章中的内容:MySQL数据库学习笔记(九)----JDBC的PreparedStatement接口重构增删改查 一.JDBC事务处理: 我们已经知道,事务的概念即:所有的操作要么同时成功,要么同时失败.在MySQL中提供了Commit.Rollback命令进行事务的提交与回滚.实际上在JDBC中也存在事务处理,如果要想进行事务处理的话,则必须按照以下的步骤完成. JDBC中事务处理的步骤: 1.要取消掉JDBC的自动提交:void setAutoCommit(boolea

非专业码农 JAVA学习笔记 6java工具类和算法-string

续<非专业码农 JAVA学习笔记 5 java工具类和算法> 五.字符串string 字符串和字符的差别:字符串双引号括起来”n”,字符用单引号括起来,表示一种符号’\n’ 1.string的主要方法和属性 类 方法或者属性 备注 定义string Stirng s=new string(“值”),string s=”值” 属性 string.length:string的长度为字节 方法startswith,endswith s.startwith(“值”)-以值为开头,s.endswith(

Java学习-049-正则工具类

自去年九月份决定再次入学和职业资格进阶,开始备战二者考试至今,以及当下进行中的职称申请,犹如孤独的狼,不断前行在路上,而今凡凡总总的已历8月... 不感慨了,如下为一园友需要的正则工具类,直接上码: 1 public class RegUtils { 2 private static Logger logger = Logger.getLogger(RegUtils.class.getName()); 3 private static String msg = ""; 4 privat

Guava库学习：Guava中Obejects实用工具类的学习

链接地址:http://www.xx566.com/detail/128.html Java中的Object类是所有Java类的超类(也就是祖先),所有对象都实现Object类中的方法,在日常的工作中,我们经常需要重写其中的几个 方法, 如:equals.toString.hashCode等方法,而在工作中,我们实现这些方法有时候也比较痛苦,如equals方法判断非空. toString调试信息不完整等等,在Guava中,其提供了Objects类帮助我们简化了这些常用方法的实现,接下来,我们一起

Lucene5学习之LuceneUtils工具类简单封装

花了整整一天时间,将Lucene5中有关索引的常见操作进行了简单封装,废话不多说,上代码: package com.yida.framework.lucene5.util; import java.io.IOException; import java.util.concurrent.ExecutorService; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; i