基础

全文检索引擎工具包

  1. 1.数据源 dataSouce
  2. 2.分词器 analyzer  将完整的语句 分割成不同的词条
  3. 3.词条   term      分词后的最小单元 通过词条做查询数据
  4. 4.文档   Document  lucene操作的对象
  5. 5.域字段 Field    可以看做 一个表中的column   比如文章标题 起域字段为title  文章内容可以域为 content
  6. 6.索引库 index     创建的索引文件存储在磁盘的目录

可视化工具

luke下载，注意对应的版本。

配置

resources/ext.dic

  1. 不明觉厉
  2. 高富帅
  3. 白富美

resources/stopword.dic

  1. 也
  2. 了
  3. 仍
  4. 从
  5. 以
  6. 使

resources/IKAnalyzer.cfg.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">  
  3. <properties>  
  4.     <comment>IK Analyzer 扩展配置</comment>
  5.     <!--用户可以在这里配置自己的扩展字典 -->
  6.     <entry key="ext_dict">ext.dic;</entry> 
  8.     <!--用户可以在这里配置自己的扩展停止词字典-->
  9.     <entry key="ext_stopwords">stopword.dic;</entry> 
  11. </properties>

引用

  1. <!--lucene核心包-->
  2. <dependency>
  3.     <groupId>org.apache.lucene</groupId>
  4.     <artifactId>lucene-queryparser</artifactId>
  5.     <version>4.10.3</version>
  6. </dependency>
  7. <!--第三方ik分词器使用的依赖坐标-->
  8. <dependency>
  9.     <groupId>com.janeluo</groupId>
  10.     <artifactId>ikanalyzer</artifactId>
  11.     <version>2012_u6</version>
  12. </dependency>

创建index

  • 索引的存储对象：IndexWriter
  1. //创建索引的存储对象，使用IK分词器
  2. Directory directory = FSDirectory.open(new File("D:\\luceneIndex"));
  3. IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3,new IKAnalyzer());
  4. IndexWriter writer = new IndexWriter(directory,config);
  • 给IndexWriter添加document
  1. //1.读取本地d盘下的文件内容
  2. File fileDir = new File("D:\\searchsource");
  3. //获取当前磁盘下的所有文件
  4. File [] files = fileDir.listFiles();
  5. //循环打印files文件内容
  6. for (File file : files) {
  7.     System.out.println("文件的名称为：===="+file.getName());
  8.     System.out.println("文件的路径为：==="+file.getPath());
  9.     System.out.println("文件的大小为：====="+ FileUtils.sizeOf(file));
  10.     System.out.println("文件的内容为：====="+FileUtils.readFileToString(file));
  11.     //创建索引库写入的document文档对象
  12.     Document document = new Document();
  13.     /*
  14.      * StringField 特点是：不分词存储  productNum
  15.      * TextField   特点：分词存储
  16.      * LongField   存储数值的域字段
  17.      *  Field.Store.YES  表示数据在索引库会被存储
  18.      *             .NO   表示数据不存储
  19.      *   查询需要展示 设置为YES 不需要展示可以为NO
  20.      * */
  21.     document.add(new TextField("fileName",file.getName(), Field.Store.YES));
  22.     document.add(new StringField("filePath",file.getPath(), Field.Store.YES));
  23.     document.add(new LongField("fileSize",FileUtils.sizeOf(file), Field.Store.YES));
  24.     document.add(new TextField("fileContent",FileUtils.readFileToString(file), Field.Store.YES));
  26.     //2.writer对象添加当前的文档
  27.     writer.addDocument(document);
  28. }
  • 文档的删除、更新、保存
  1. // 删除所有
  2. //writer.deleteAll();
  4. //更新：先删除匹配的内容，再添加
  5. //Document document = new Document();
  6. //document.add(new TextField("fileName","测试修改的文档2", Field.Store.YES));
  7. //writer.updateDocument(new Term("fileName","spring"),document);
  9. //直接选择close 表示文件默认提交保存
  10. writer.close();

查询

单个字段、多字段、范围、分词、组合查询

  1. import org.apache.lucene.document.Document;
  2. import org.apache.lucene.index.DirectoryReader;
  3. import org.apache.lucene.index.IndexReader;
  4. import org.apache.lucene.index.Term;
  5. import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
  6. import org.apache.lucene.search.*;
  7. import org.apache.lucene.store.Directory;
  8. import org.apache.lucene.store.FSDirectory;
  9. import org.junit.Test;
  10. import org.wltea.analyzer.lucene.IKAnalyzer;
  12. import java.io.File;
  13. import java.io.IOException;
  15. public class QueryIndex {
  16.     /**
  17.      * 查询所有的方法
  18.      */
  19.     @Test
  20.     public void queryIndex(){
  22.         try {
  23.             //创建查询所有的对象
  24.             Query queryAll = new MatchAllDocsQuery();
  25.             doQuery(queryAll);
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         }
  30.     }
  32.     /**
  33.      * 根据词条查询数据
  34.      */
  35.     @Test
  36.     public void queryByTerm(){
  38.         try {
  39.             //创建查询词条
  40.             Query queryAll = new TermQuery(new Term("fileName","传智播客"));
  41.             doQuery(queryAll);
  42.         } catch (Exception e) {
  43.             e.printStackTrace();
  44.         }
  46.     }
  48.     /**
  49.      * 根据数值范围查询数据
  50.      */
  51.     @Test
  52.     public void queryByRang(){
  54.         try {
  55.             //创建查询范围
  56.             Query queryAll = NumericRangeQuery.newLongRange("fileSize",1l,50l,true,true);
  57.             doQuery(queryAll);
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.         }
  62.     }
  64.     /**
  65.      * 组合查询
  66.      * 只有should的时候，should是必须的。有了must之后，should就可有可无了。
  67.      */
  68.     @Test
  69.     public void queryByBoolean(){
  71.         try {
  72.             //创建查询范围
  73.             BooleanQuery query = new BooleanQuery();
  74.             //定义查询对象1
  75.             Query query1 = new TermQuery(new Term("fileName","传智播客"));
  76.             //参数1是组合的对象 参数2是查询的满足要求 MUST 表示必须满足 SHOULD 表示可以满足  MUST_NOT 表示一定不能满足
  77.             // and or not
  78.             query.add(query1, BooleanClause.Occur.MUST_NOT);
  79.             Query query2 = new TermQuery(new Term("fileName","不明觉厉"));
  80.             query.add(query2, BooleanClause.Occur.MUST_NOT);
  81.             //查询所有的查询对象
  82.             Query queryAll = new MatchAllDocsQuery();
  83.             query.add(queryAll, BooleanClause.Occur.MUST);
  84.             doQuery(query);
  85.         } catch (Exception e) {
  86.             e.printStackTrace();
  87.         }
  89.     }
  91.     /**
  92.      * 分词查询方式
  93.      * 多个域字段的查询解析
  94.      */
  95.     @Test
  96.     public void queryByMulityField(){
  98.         try {
  99.             //定义用于查询的关键字字符串
  100.             String searchStr = "传智播客一个优秀";
  101.             //查询解析的对象
  102.             String [] fields = new String [] {"fileName","fileContent"};
  103.             MultiFieldQueryParser parser = new MultiFieldQueryParser(fields,new IKAnalyzer());
  104.             Query query = parser.parse(searchStr);
  105.             doQuery(query);
  106.         } catch (Exception e) {
  107.             e.printStackTrace();
  108.         }
  109.     }
  110.     /**
  111.      * 提取后的通用查询方法
  112.      * @param queryAll
  113.      * @throws IOException
  114.      */
  115.     private void doQuery(Query queryAll) throws IOException {
  116.         //创建索引库需要的查询对象
  117.         //索引的目录
  118.         Directory directory = FSDirectory.open(new File("D:\\luceneIndex"));
  119.         //读取本地索引库的对象
  120.         IndexReader reader = DirectoryReader.open(directory);
  121.         //创建索引的读取查询对象
  122.         IndexSearcher searcher = new IndexSearcher(reader);
  124.         //参数1是查询的对象 参数2是查询的数量
  125.         TopDocs topDocs = searcher.search(queryAll,10);
  126.         //topDocs的两个属性为  totalHist表示总共命中文档数量
  127.         //                    scoreDoc [] 表示每个文档的id和对应的分值
  128.         int totalHits = topDocs.totalHits;
  129.         System.out.println("总共命中的文档数量为：====="+totalHits);
  130.         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  131.         for (ScoreDoc scoreDoc : scoreDocs) {
  132.             System.out.println("当前的文档id为：====="+scoreDoc.doc);
  133.             System.out.println("当前文档得分为：======"+scoreDoc.score);
  134.             //通过文档id获取文档对象的数据
  135.             Document document = searcher.doc(scoreDoc.doc);
  136.             System.out.println("当前文档的名称为：===="+document.get("fileName"));
  137.             System.out.println("当前文档的内容为：===="+document.get("fileContent"));
  138.             System.out.println("当前文档的大小为：===="+document.get("fileSize"));
  139.             System.out.println("当前文档的路径为：===="+document.get("filePath"));
  140.         }
  141.     }
  142. }