全文检索Lucene

Posted jianer

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了全文检索Lucene相关的知识,希望对你有一定的参考价值。

------------恢复内容开始------------

一,什么是全文检索

  1. 概念:先创建索引然后查询索引的过程就做全文索引。索引一次创建可以多次使用,表现为每次查询速度都很快。

二,数据的分类

  1. 结构化数据:格式固定,长度固定,数据类型固定   比如数据库的数据
  2. 非结构化数据:格式不固定,长度不固定,数据类型不固定word文档,pdf文档,邮件,html,txt

三,数据的查询

  1. 结构化数据的查询:SQL语句,查询简单,速度快
  2. 非结构化数据的查询:
    1. 从文本文件中查找出包含spring单词的文件
      1. 目测
      2. 使用程序把文档读取到内存中,然后匹配字符串
      3. 把非结构化数据进行字符串拆分,得到一个单词的列表,基于单词列表创建一个索引,然后查询索引,根据单词和文档的对应关系找到文档列表,这个过程就叫做全文索引
    2. 索引:一个为了提高查询速度,创建某种数据结构的集合

四,全文检索的应用场景

  1. 搜索引擎:百度,360,谷歌,搜狗
  2. 站内搜索:论坛搜索,微博,文章搜索
  3. 电商搜索:淘宝,京东  
  4. 只要是搜索的地方就可以使用全文搜索技术

五,什么是Lucene

  Lucene,是基于Java开发的全文检索工具包

  1. Lucene实现全文检索的流程
    1. 创建索引
      1. 获得文档
        1. 原始文档:要基于哪些数据来进行搜索,那么这些数据就是原始文档
        2. 搜索引擎:使用爬虫获得原始文档
        3. 站内搜索:数据库中的数据
        4. 案例:直接使用io流读取磁盘上的文件
      2. 构建文档对象
        1. 对应每个原始文档创建一个Document对象
        2. 每个Document对象中包含多个域(field)
        3. 域中保存的就是原始文档数据:域的名称 和 域的值
        4. 每个文档都有一个唯一的编号,就是文档id
      3. 分析文档:就是分词的过程
        1. 根据空格进行字符串拆分,得到一个单词列表
        2. 把单词统一转换成小写
        3. 去除标点符号
        4. 去除停用词:无意义的词
        5. 每个关键词都封装成一个Term对象中
          1. Term中包含两部分内容:关键词所在的域,关键词本身
          2. 不同的域中拆分出来的相同关键词是不同的term
      4. 创建索引:
        1. 基于关键词列表创建一个索引,保存在索引库中,索引库中包含:索引,document对象,关键词和文档的对应关系
        2. 通过词语找文档,这种索引的结构叫倒排索引结构
    2. 查询索引
      1. 用户查询接口:用户输入查询的条件的地方 例如百度的搜索框
      2. 把关键词封装成一个查询对象:要查询的域,要查询的关键词
      3. 执行查询
        1. 根据要查询的关键词到对应的域上进行搜索
        2. 找到关键词,根据关键词找到对应的文档
      4. 渲染结果
        1. 根据文档的id找到文档对象
        2. 对关键词进行高亮显示
        3. 分页处理
        4. ...
        5. 最终展示给用户看

 六,Lucene快速入门

  入门需求:

    实现一个文件的搜索功能,通过关键字搜索文件,凡是文件名或者文件内容包括关键字的文件都需要找出来。还可以根据中文词语进行查询,并且需要支持多个条件查询。本案例的原始内容就是磁盘上的文件

  1.创建索引

    工程搭建:

      创建一个空的Java工程

      添加jar依赖:lucene-analyzers-common-7.4.0.jar,lucene-core-7.4.0.jar,commons-io.jar

    步骤:

      1.创建一个Directory对象,指定索引库保存的位置

      2.基于Directory对象创建一个IndexWriter对象

      3.读取磁盘上的文件,对应每个文件创建一个文档对象

      4.向文档对象中添加域

      5.把文档对象写入索引库

      6.关闭IndexWriter对象

  2.代码

 1 public class LuceneFirst {
 2     @Test
 3     public void createIndex() throws Exception{
 4 //       1.创建一个Director对象,指定索引库保存的位置
 5 //        Directory directory = new RAMDirectory();    //索引库保存在内存中
 6         Directory directory = FSDirectory.open(new File("E:\\temp\\index").toPath());
 7 //    2.基于Director对象创建一个IndexWriter对象
 8         IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig());
 9 //    3.读取磁盘上的文件,对应每个文件创建一个文档对象
10         File dir = new File("D:\\java(新课程)\\00 讲义+笔记+资料\\流行框架\\61.会员版(2.0)-就业课(2.0)-Lucene\\lucene\\02.参考资料\\searchsource");
11         File[] files = dir.listFiles();
12         for (File file : files) {
13             String fileName = file.getName();   //获取文件名
14             String filePath = file.getPath();   //获取文件路径
15             String fileContext = FileUtils.readFileToString(file, "utf-8"); //获取文件内容
16             long fileSize = FileUtils.sizeOf(file); //获取文件大小
17 
18             //创建Field
19             //参数:域的名称,域的内容,是否存储
20             Field fieldName = new TextField("name", fileName, Field.Store.YES);
21             Field fieldPath = new TextField("filePath", filePath, Field.Store.YES);
22             Field fieldContext = new TextField("fileContext", fileContext, Field.Store.YES);
23             Field fieldSize = new TextField("fileSize", fileSize+"", Field.Store.YES);
24 
25             //创建文档对象
26             Document document = new Document();
27 //    4.向文档对象中添加域
28             document.add(fieldName);
29             document.add(fieldPath);
30             document.add(fieldContext);
31             document.add(fieldSize);
32 //    5.把文档对象写入索引库
33             indexWriter.addDocument(document);
34         }
35 //    6.关闭IndexWriter对象
36         indexWriter.close();
37     }
38 }

  2.查询索引库

    步骤:

      1.创建一个Directory对象,指定索引库的位置

      2.创建一个IndexReader对象

      3.创建一个IndexSearcher对象,构造方法中的参数IndexReader 对象

      4.创建一个Query对象,TermQuery

      5.执行查询,得到一个TomDocs对象

      6.取查询结果的总记录数

      7.取文档列表

      8.打印文档的内容

      9.关闭IndexReader对象

  代码实现

 1 @Test
 2     public void searchIndex() throws Exception {
 3 //       1.创建一个Directory对象,指定索引库的位置
 4         Directory directory = FSDirectory.open(new File("E:\\temp\\index").toPath());
 5 //    2.创建一个IndexReader对象
 6         IndexReader indexReader = DirectoryReader.open(directory);
 7 //    3.创建一个IndexSearcher对象,构造方法中的参数IndexReader 对象
 8         IndexSearcher indexSearcher = new IndexSearcher(indexReader);
 9 //    4.创建一个Query对象,TermQuery
10         Query query = new TermQuery(new Term("fileContext", "spring"));
11 //    5.执行查询,得到一个TomDocs对象
12         TopDocs topDocs = indexSearcher.search(query, 10);
13 //    6.取查询结果的总记录数
14         System.out.println("查询总记录数:" + topDocs.totalHits);
15 //    7.取文档列表
16         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
17 //    8.打印文档的内容
18         for (ScoreDoc scoreDoc : scoreDocs) {
19             //获取文档id
20             int docId = scoreDoc.doc;
21             //根据id取文档对象
22             Document document = indexSearcher.doc(docId);
23             System.out.println(document.get("name"));
24             System.out.println(document.get("filePath"));
25 //            System.out.println(document.get("fileContext"));
26             System.out.println(document.get("fileSize"));
27         }
28 //    9.关闭IndexReader对象
29         indexReader.close();
30     }

  3.分析器

    默认使用的是标准分析器:StandarAnalyzer

    1.查看分析器的分析效果

      使用Analyzer对象的tokenStream方法返回一个TokenStream对象。词对象中包含了最终分词结果

    实现步骤:

      1.创建要给Analyzer对象,StandardAnalyzer对象

      2.使用分析器对象的tokenStream方法获得一个TokenStream对象

      3.向TokenStream对象中设置一个引用,相当于是一个指针

      4.调用TokenStream对象的reset方法。如果不调用抛异常

      5.使用while循环遍历TokenStream对象

      6.关闭TokenStream对象

    代码实现

 1 @Test
 2     public void testTokenStream() throws Exception {
 3 //       1.创建要给Analyzer对象,StandardAnalyzer对象
 4         Analyzer analyzer = new StandardAnalyzer();
 5 //    2.使用分析器对象的tokenStream方法获得一个TokenStream对象
 6         TokenStream tokenStream = analyzer.tokenStream(null, "The Spring Framework provides a comprehensive programming and configuration model.");
 7 //    3.向TokenStream对象中设置一个引用,相当于是一个指针
 8         CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
 9 //    4.调用TokenStream对象的reset方法。如果不调用抛异常
10         tokenStream.reset();
11 //    5.使用while循环遍历TokenStream对象
12         while (tokenStream.incrementToken()){
13             System.out.println(charTermAttribute.toString());
14         }
15 //    6.关闭TokenStream对象
16         tokenStream.close();
17     }

     2.IKAnalyzer的使用方法

      1.把IKAnalyzer的jar包添加到工程中

      2.把配置文件和扩展词典添加到工程的classpath下

        注意:扩展词典严禁使用window记事本编辑,因为有保证扩展词典的编码是utf-8

        扩展词典:添加一些新词

        停用词词典:无意义的词或者是敏感的词

      3.代码实现

 1 @Test
 2     public void testIkAnalyzer() throws Exception {
 3 //       1.创建要给Analyzer对象,StandardAnalyzer对象
 4         Analyzer analyzer = new IKAnalyzer();
 5 //    2.使用分析器对象的tokenStream方法获得一个TokenStream对象
 6         TokenStream tokenStream = analyzer.tokenStream("", "全文检索是将整本书java、整篇文章中的任意内容信息查找出来的检索,java。它可以根据需要获得全文中有关章、节、段、句、词等信息,计算机程序通过扫描文章中的每一个");
 7 //    3.向TokenStream对象中设置一个引用,相当于是一个指针
 8         CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
 9 //    4.调用TokenStream对象的reset方法。如果不调用抛异常
10         tokenStream.reset();
11 //    5.使用while循环遍历TokenStream对象
12         while (tokenStream.incrementToken()){
13             System.out.println(charTermAttribute.toString());
14         }
15 //    6.关闭TokenStream对象
16         tokenStream.close();
17     }

      3.IkAnalyzer,在代码中使用

    

 1 @Test
 2     public void createIndex() throws Exception{
 3 //       1.创建一个Director对象,指定索引库保存的位置
 4 //        Directory directory = new RAMDirectory();    //索引库保存在内存中
 5         Directory directory = FSDirectory.open(new File("E:\\temp\\index").toPath());
 6 //    2.基于Director对象创建一个IndexWriter对象
 7         IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig(new IKAnalyzer()));
 8 //    3.读取磁盘上的文件,对应每个文件创建一个文档对象
 9         File dir = new File("D:\\java(新课程)\\00 讲义+笔记+资料\\流行框架\\61.会员版(2.0)-就业课(2.0)-Lucene\\lucene\\02.参考资料\\searchsource");
10         File[] files = dir.listFiles();
11         for (File file : files) {
12             String fileName = file.getName();   //获取文件名
13             String filePath = file.getPath();   //获取文件路径
14             String fileContext = FileUtils.readFileToString(file, "utf-8"); //获取文件内容
15             long fileSize = FileUtils.sizeOf(file); //获取文件大小
16 
17             //创建Field
18             //参数:域的名称,域的内容,是否存储
19             Field fieldName = new TextField("name", fileName, Field.Store.YES);
20             Field fieldPath = new TextField("filePath", filePath, Field.Store.YES);
21             Field fieldContext = new TextField("fileContext", fileContext, Field.Store.YES);
22             Field fieldSize = new TextField("fileSize", fileSize+"", Field.Store.YES);
23 
24             //创建文档对象
25             Document document = new Document();
26 //    4.向文档对象中添加域
27             document.add(fieldName);
28             document.add(fieldPath);
29             document.add(fieldContext);
30             document.add(fieldSize);
31 //    5.把文档对象写入索引库
32             indexWriter.addDocument(document);
33         }
34 //    6.关闭IndexWriter对象
35         indexWriter.close();
36     }

 

七,索引库的维护

  1.索引库的添加

    1.field域的属性

      是否分析:是否对域的内容进行分词处理。前提是我们要对域的内容进行查询。

      是否索引:将field分析后的词或整个field值进行索引,只有索引方可搜索到。

        比如:商品名称,商品简介分析后进行索引,订单号,身份证不用分析但也是要索引的,这些将来都要作为查询的条件

      是否存储:将field值存储在文档中,存储在文档中的field才可以从Document中获取

        比如:商品名称,订单号,凡是将来要从Document中获取的field都要存储。

技术图片

   2.添加文档

    步骤:

      1.创建一个IndexWriter 对象,需要使用IKAnalyzer作为分析器

      2.创建一个Document对象

      3.向Document对象中添加域

      4.把文档写入索引库

      5.关闭索引库

    代码实现

 1 @Test
 2     public void addDocument() throws Exception {
 3 //    1.创建一个IndexWriter 对象,需要使用IKAnalyzer作为分析器
 4         IndexWriter indexWriter = new IndexWriter(FSDirectory.open(new File("E:/temp/index").toPath()), new IndexWriterConfig(new IKAnalyzer()));
 5 //  2.创建一个Document对象
 6         Document document = new Document();
 7 //  3.向Document对象中添加域
 8         document.add(new TextField("name","新添加的文件", Field.Store.YES));
 9         document.add(new TextField("content","新添加的文件内容", Field.Store.NO));
10         document.add(new StoredField("path","c:/temp/hello"));
11 //  4.把文档写入索引库
12         indexWriter.addDocument(document);
13 //  5.关闭索引库
14         indexWriter.close();
15 
16     }

  2.删除索引库

    1.根据查询关键词删除

      代码实现

 1 private IndexWriter indexWriter;
 2     @Before
 3     public void init() throws Exception {
 4         indexWriter = new IndexWriter(FSDirectory.open(new File("E:/temp/index").toPath()), new IndexWriterConfig(new IKAnalyzer()));
 5     }
 6     @Test
 7     public void deleteDocumentByQuery() throws Exception{
 8         indexWriter.deleteDocuments(new Term("name","apache"));
 9         indexWriter.close();
10     }

    2.删除整个索引库

      代码实现

1 @Test
2     public void deleteAllDocument() throws Exception {
3         indexWriter.deleteAll();
4         indexWriter.close();
5     }

  3.更新索引库

    原理是先删除再添加

    步骤:

      1.创建新的文档对象

      2.向文档对象中添加域

      3.更新操作

      4.关闭索引库

     代码实现

@Test
    public void updateIndex() throws Exception{
//       1.创建新的文档对象
        Document document = new Document();
//    2.向文档对象中添加域
        document.add(new TextField("name1","更新之后的文档1", Field.Store.YES));
        document.add(new TextField("name2","更新之后的文档2", Field.Store.YES));
        document.add(new TextField("name3","更新之后的文档3", Field.Store.YES));
//    3.更新操作
        indexWriter.updateDocument(new Term("name","spring"),document);
//    4.关闭索引库
        indexWriter.close();

以上是关于全文检索Lucene的主要内容,如果未能解决你的问题,请参考以下文章

Lucene的全文检索学习

Lucene学习总结

Lucene就是这么简单

Lucene就是这么简单

Lucene原理与代码分析解读笔记

[Lucene]-Lucene基本概述以及简单实例