Lucene全文检索技术

一、概览
1、什么是全文检索，如何实现全文检索
2、Lucene实现全文检索的流程
　　a) 创建索引
　　b) 查询索引
3、配置开发环境
4、入门程序
5、分析器的分析过程
　　a) 测试分析器的分词效果
　　b) 第三方中文分析器
6、索引库维护
　　a) 添加文档
　　b) 删除文档
　　c) 修改文档
7、索引库查询
　　a) 使用Query子类查询
　　b) 使用QueryParser查询

二、什么是全文索引
2.1、数据分类
　　数据分为两种：结构化数据和非结构化数据
结构化数据：
　　指具有固定格式或有限长度的数据，如数据库，元数据等
非结构化数据：
　　指不定长或无固定格式的数据，如邮件，word文档等磁盘上的文件

2.2、结构化数据搜索
　　常见的结构化数据也就是数据库中的数据。在数据库中搜索很容易实现，通常都是使用sql语句进行查询，而且能很快的得到查询结果。

2.3、非结构话数据查询方法
（1）顺序扫描法(Serial Scanning)
所谓顺序扫描，比如要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每一个文档，从头看到尾，如果此文档包含此字符串，则此文档为我们要找的文件，接着看下一个文件，直到扫描完所有的文件。如利用windows的搜索也可以搜索文件内容，只是相当的慢。
（1）全文检索(Full-text Search)
将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。
　　这种先建立索引，再对索引进行搜索的过程就叫全文检索(Full-text Search)。
　　虽然创建索引的过程也是非常耗时的，但是索引一旦创建就可以多次使用，全文检索主要处理的是查询，所以耗时间创建索引是值得的。

2.4、如何实现全文检索
可以使用Lucene实现全文检索。Lucene是apache下的一个开放源代码的全文检索引擎工具包。提供了完整的查询引擎和索引引擎，部分文本分析引擎。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能。

2.5、全文检索的应用场景
对于数据量大、数据结构不固定的数据可采用全文检索方式搜索，比如百度、Google等搜索引擎、论坛站内搜索、电商网站站内搜索等。

三、Lucene实现全文检索的流程
3.1、索引和搜索流程图

1、绿色表示索引过程，对要搜索的原始内容进行索引构建一个索引库，索引过程包括：
　　确定原始内容即要搜索的内容-->采集文档-->创建文档-->分析文档-->索引文档
2、红色表示搜索过程，从索引库中搜索内容，搜索过程包括：
　　用户通过搜索界面-->创建查询-->执行搜索，从索引库搜索-->渲染搜索结果

3.2、创建索引
对文档索引的过程，将用户要搜索的文档内容进行索引，索引存储在索引库（index）中。
这里要搜索的文档是磁盘上的文本文件：凡是文件名或文件内容包括关键字的文件都要找出来，这里要对文件名和文件内容创建索引。

3.2.1、获得原始文档
　　原始文档是指要索引和搜索的内容。原始内容包括互联网上的网页、数据库中的数据、磁盘上的文件等。

3.2.2、创建文档对象
　　获取原始内容的目的是为了索引，在索引前需要将原始内容创建成文档（Document），文档中包括一个一个的域（Field），域中存储内容。
　　这里我们可以将磁盘上的一个文件当成一个document，Document中包括一些Field（file_name文件名称、file_path文件路径、file_size文件大小、file_content文件内容），如下图：

注意：
　　每个Document可以有多个Field，不同的Document可以有不同的Field，同一个Document可以有相同的Field（域名和域值都相同）
　　每个文档都有一个唯一的编号，就是文档id。

3.2.3、分析文档
　　将原始内容创建为包含域（Field）的文档（document），需要再对域中的内容进行分析，分析的过程是经过对原始文档提取单词、将字母转为小写、去除标点符号、去除停用词等过程生成最终的语汇单元，可以将语汇单元理解为一个一个的单词。
　　每个单词叫做一个Term，不同的域中拆分出来的相同的单词是不同的term。term中包含两部分：一部分是文档的域名，另一部分是单词的内容。

3.2.4、创建索引
对所有文档分析得出的语汇单元进行索引，索引的目的是为了搜索，最终要实现只搜索被索引的语汇单元从而找到Document（文档）。

　　-->注意：创建索引是对语汇单元索引，通过词语找文档，这种索引的结构叫倒排索引结构
传统方法是根据文件找到该文件的内容，在文件内容中匹配搜索关键字，这种方法是顺序扫描方法，数据量大、搜索慢。
倒排索引结构是根据内容（词语）找文档，如下图：

倒排索引结构也叫反向索引结构，包括索引和文档两部分，索引即词汇表，它的规模较小，而文档集合较大。

3.3、查询索引
查询索引也是搜索的过程。搜索就是用户输入关键字，从索引（index）中进行搜索的过程。根据关键字搜索索引，根据索引找到对应的文档，从而找到要搜索的内容（这里指磁盘上的文件）。

3.3.1、用户查询接口
全文检索系统提供用户搜索的界面供用户提交搜索的关键字，搜索完成展示搜索结果。
Lucene不提供制作用户搜索界面的功能，需要根据自己的需求开发搜索界面。

3.3.2、创建查询
用户输入查询关键字执行搜索之前需要先构建一个查询对象，查询对象中可以指定查询要搜索的Field文档域、查询关键字等，查询对象会生成具体的查询语法，
例如：
　　语法 “fileName:lucene”表示要搜索Field域的内容为“lucene”的文档

3.3.3、查询结果
搜索索引过程：
　　根据查询语法在倒排索引词典表中分别找出对应搜索词的索引，从而找到索引所链接的文档链表。
　　比如搜索语法为“fileName:lucene”表示搜索出fileName域中包含Lucene的文档。
　　搜索过程就是在索引上查找域为fileName，并且关键字为Lucene的term，并根据term找到文档id列表。

3.3.4、渲染结果
以一个友好的界面将查询结果展示给用户，用户根据搜索结果找自己想要的信息，为了帮助用户很快找到自己的结果，提供了很多展示的效果，比如搜索结果中将关键字高亮显示，百度提供的快照等。

四、配置开发环境
4.1、Lucene下载
Lucene是开发全文检索功能的工具包，从官方网站下载lucene-7.4.0。

官方网站：http://lucene.apache.org/
版本：lucene-7.4.0
Jdk要求：1.8以上

4.2、使用的jar包
lucene-core-7.4.0.jar
lucene-analyzers-common-7.4.0.jar

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

5.2、创建索引
5.2.1、实现步骤
第一步：创建一个java工程，并导入jar包。
第二步：创建一个indexwriter对象。
　　1）指定索引库的存放位置Directory对象
　　2）指定一个IndexWriterConfig对象。
第二步：创建document对象。
第三步：创建field对象，将field添加到document对象中。
第四步：使用indexwriter对象将document对象写入索引库，此过程进行索引创建。并将索引和document对象写入索引库。
第五步：关闭IndexWriter对象。

5.2.2、代码实现

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

public class LuceneFirst {
    
    @Test
    public void create() throws IOException {
        //1.创建一个Director对象，指定索引库保存的位置。
        //把索引保存在内存中
//        Directory directory = new RAMDirectory();
        //包索引保存在磁盘
        Directory directory = FSDirectory.open(new File("F:\\SOFTWARE\\Lucene\\temp\\index").toPath());
        
        //2.基于Directory对象创建一个IndexWriter对象
        IndexWriterConfig config = new IndexWriterConfig(new IKAnalyzer());  //--------使用IKAnalyzer分析器
//        IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig());  //使用默认分析器
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //3.读取磁盘上的文件，对应每个文件创建一个文档对象
        File dir = new File("E:\\HEIMA\\第三阶段\\lucene\\02.参考资料\\searchsource");
        File[] files = dir.listFiles();
        
        for (File f:files){
            //取文件名
            String fileName = f.getName();
            //文件的路径
            String filePath = f.getPath();
            //文件的内容
            String fileContent = FileUtils.readFileToString(f, "UTF-8");
            //文件的大小
            long fileSize = FileUtils.sizeOf(f);
            
            //创建filed  ---》也可以都用textField进行设置，不建议
            Field fieldName = new TextField("name",fileName,Field.Store.YES);
//            Field fieldPath = new TextField("path",filePath,Field.Store.YES);
            Field fieldPath = new StoredField("path",filePath);
            TextField fieldContent = new TextField("content", fileContent, Field.Store.YES);
            Field fieldSizeValue = new LongPoint("size", fileSize);
            Field fieldSizeStore = new StoredField("size", fileSize);
            
            //创建文档对象
            Document document = new Document();
            //向文档对象中添加域
            document.add(fieldName);
            document.add(fieldPath);
            document.add(fieldContent);
            //document.add(fieldSize);
            document.add(fieldSizeValue);
            document.add(fieldSizeStore);
            
            //5.把文档对象写入到索引库
            indexWriter.addDocument(document);
        }
        
        //6.关闭indexWriter对象
        indexWriter.close();
    }
    
    @Test
    public void searchIndex() throws IOException {
        //1.创建igeDirctor对象，索引库的位置
        Directory directory = FSDirectory.open(new File("F:\\SOFTWARE\\Lucene\\temp\\index").toPath());
        //2.创建一个IndexReader对象
        IndexReader indexReader = DirectoryReader.open(directory);
        //3.创建仪的IndexSearcher对象，构造方法中的参数indexReader对象
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //4.创建一个Query对象，termQuery
        Query query = new TermQuery(new Term("name","spring"));
        //5.执行查询，得到TopDocs对象
        //参数1：查询对象  参数2：查询结果返回的最大记录数
        TopDocs topDocs = indexSearcher.search(query, 10);
        //6.查询结果的总记录数
        System.out.println("查询的总记录数："+topDocs.totalHits);
        //7.获取文档列表
        ScoreDoc[] scoreDocs= topDocs.scoreDocs;
        //8.打印文档中的内容
        for(ScoreDoc doc:scoreDocs){
            //取文档id
            int docId = doc.doc;
            //根据id取文档对象
            Document document = indexSearcher.doc(docId);
            System.out.println(document.get("name"));
            System.out.println(document.get("path"));
            System.out.println(document.get("size"));
            //System.out.println(document.get("content"));
            System.out.println("-----------------寂寞的分割线");
        }
        //9.关闭IndexReader
        indexReader.close();
    }
    
    
    @Test
    public void testTokenStream() throws IOException {
        //1.创建一个Analyzer对象  ----------
//        Analyzer analyzer= new StandardAnalyzer();
        Analyzer analyzer = new IKAnalyzer();
        
        //2.使用分析器对象的tokenStrean方法获得一个tokenStrean对象
        TokenStream tokenStream = analyzer.tokenStream("", "2017年12月14日 -  传智播客Lucene概述公安局Lucene是一款高性能的、可扩展的信息检索(IR)工具库。信息检索是指文档搜索、文档内信息搜索或者文档相关的元数据搜索等操作。");
        //3.想TokenStrean大对象中设置一个引用相当于一个指针
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        //4.调用TokenStream对象的reset方法，如果不调用抛异常
        tokenStream.reset();
        //5.使用while循环遍历TokenStrean对象
        while(tokenStream.incrementToken()){
            System.out.println(charTermAttribute.toString());
        }
        //6.关闭TokenStrean对象
        tokenStream.close();
    }
    
}

5.2.3、使用Luke工具查看索引文件
索引库：



5.3、查询索引
5.3.1、实现步骤
第一步：创建一个Directory对象，也就是索引库存放的位置。
第二步：创建一个indexReader对象，需要指定Directory对象。
第三步：创建一个indexsearcher对象，需要指定IndexReader对象
第四步：创建一个TermQuery对象，指定查询的域和查询的关键词。
第五步：执行查询。
第六步：返回查询结果。遍历查询结果并输出。
第七步：关闭IndexReader对象

5.3.2、代码实现

六、分析器
6.1、分析器的分词效果

6.2、中文分析器
6.2.1、Lucene自带中文分词器
1）StandardAnalyzer：
　　单字分词：就是按照中文一个字一个字地进行分词。如：“我爱中国”，
　　效果：“我”、“爱”、“中”、“国”。
2）SmartChineseAnalyzer
　　对中文支持较好，但扩展性差，扩展词库，禁用词库和同义词库等不好处理

6.2.2、IKAnalyzer

　　hotword.dic -->扩展词典
　　stopword.dic-->停用词典
使用方法：
第一步：把jar包添加到工程中
第二步：把配置文件和扩展词典和停用词词典添加到classpath下

注意：hotword.dic和ext_stopword.dic文件的格式为UTF-8，注意是无BOM 的UTF-8 编码。
　　也就是说禁止使用windows记事本编辑扩展词典文件
　　使用EditPlus.exe保存为无BOM 的UTF-8 编码格式，如下图：

6.3、使用自定义分析器

七、索引库的维护
7.1、索引库的添加
7.1.1、Field域的属性
是否分析：
　　是否对域的内容进行分词处理。前提是我们要对域的内容进行查询。
是否索引：
　　将Field分析后的词或整个Field值进行索引，只有索引方可搜索到。
　　比如：商品名称、商品简介分析后进行索引，订单号、身份证号不用分析但也要索引，这些将来都要作为查询条件。
是否存储：
　　将Field值存储在文档中，存储在文档中的Field才可以从Document中获取
　　比如：商品名称、订单号，凡是将来要从Document中获取的Field都要存储。
是否存储的标准：是否要将内容展示给用户。

7.1.2、代码实现

@Test
public void addDocument() throws IOException {
    //创建一个Document对象
    Document document = new Document();
    //向document中添加域
    document.add(new TextField("name","新添加的文件222", Field.Store.YES));
    document.add(new TextField("content","新添加的文件内容",Field.Store.YES));
    document.add(new StoredField("path", "111"));
    //把文档写入到索引库
    indexWriter.addDocument(document);
    //关闭索引库
    indexWriter.close();
}

7.2、索引库删除
7.2.1、删除全部

7.2.2、指定查询条件删除

7.3、索引库的修改
原理就是先删除后添加。--->并不是在原有的项上进行修改，而是删除后，将新的添加在最后。

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

public class IndexManager {
    private IndexWriter indexWriter;
    
    @Before
    public void init() throws IOException {
        //创建一个indexWriter，需要使用IKAnalyzer作为分析器
        indexWriter = new IndexWriter(
                FSDirectory.open(new File("F:\\SOFTWARE\\Lucene\\temp\\index").toPath()),
                new IndexWriterConfig(new IKAnalyzer()));
    }

    @Test
    public void addDocument() throws IOException {
        //创建一个Document对象
        Document document = new Document();
        //向document中添加域
        document.add(new TextField("name","新添加的文件222", Field.Store.YES));
        document.add(new TextField("content","新添加的文件内容",Field.Store.YES));
        document.add(new StoredField("path", "111"));
        //把文档写入到索引库
        indexWriter.addDocument(document);
        //关闭索引库
        indexWriter.close();
    }
    
    @Test
    public void deleteAllDocument() throws IOException {
        //创建一个新的文档对象
        indexWriter.deleteAll();
        //关闭索引库
        indexWriter.close();
    }
    
    @Test
    public void deleteDocumentByQuery() throws IOException {
        indexWriter.deleteDocuments(new Term("name","apache"));
        indexWriter.close();
    }

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

八、Lucene索引库查询
对要搜索的信息创建Query查询对象，Lucene会根据Query查询对象生成最终的查询语法，类似关系数据库Sql语法一样Lucene也有自己的查询语法，比如：“name:lucene”表示查询Field的name为“lucene”的文档信息。
可通过两种方法创建查询对象：
　　1）使用Lucene提供Query子类
　　2）使用QueryParse解析查询表达式

8.1、TermQuery
TermQuery，通过项查询，TermQuery不使用分析器所以建议匹配不分词的Field域查询，比如订单号、分类ID号等。
指定要查询的域和要查询的关键词

8.2、数值范围查询

public class SearchIndex {
    private IndexReader indexReader;
    private IndexSearcher indexSearcher;
    @Before
    public void init() throws Exception {
        indexReader = DirectoryReader.open(FSDirectory.open(new File("F:\\SOFTWARE\\Lucene\\temp\\index").toPath()));
        indexSearcher = new IndexSearcher(indexReader);
    }
    
    @Test
    public void testRangeQuery() throws Exception {
        //创建一个query对象
        Query query = LongPoint.newRangeQuery("size", 01, 100);
        printResult(query);
    }

    @Test
    public void testRangeQuery02() throws Exception {
        //创建一个Query对象
        Query query = new TermQuery(new Term("name","spring"));
        printResult(query);
    }
    
    private void printResult(Query query) throws Exception {
        //执行查询
        TopDocs topDocs = indexSearcher.search(query, 10);
        System.out.println("总记录数：" + topDocs.totalHits);
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc doc:scoreDocs){
            //取文档id
            int docId = doc.doc;
            //根据id取文档对象
            Document document = indexSearcher.doc(docId);
            System.out.println(document.get("name"));
            System.out.println(document.get("path"));
            System.out.println(document.get("size"+"-----"));
            System.out.println(document.get("content")+"====内容");
            //System.out.println(document.get("content"));
            System.out.println("-----------------寂寞的分割线");
        }
        indexReader.close();
    }

    @Test
    public void testQueryParser() throws Exception {
        //创建一个QueryPaser对象，两个参数
        QueryParser queryParser = new QueryParser("name", new IKAnalyzer());
        //参数1：默认搜索域，参数2：分析器对象
        //使用QueryPaser对象创建一个Query对象
        Query query = queryParser.parse("lucene是一个Java开发的全文检索工具包");
        //执行查询
        printResult(query);
    }
    
}

8.3、使用queryparser查询
通过QueryParser也可以创建Query，QueryParser提供一个Parse方法，此方法可以直接根据查询语法来查询。Query对象执行的查询语法可通过System.out.println(query);查询。
需要使用到分析器。建议创建索引时使用的分析器和查询索引时使用的分析器要一致。
需要加入queryParser依赖的jar包。