Lucene

一、什么是全文检索

数据分类

咱们生活中的数据整体分为两种：结构化数据和非结构化数据。

结构化数据：指具备固定格式或有限长度的数据，如数据库，元数据等。

非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等磁盘上的文件

结构化数据搜索

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

为何数据库搜索很容易？

由于数据库中的数据存储是有规律的，有行有列并且数据格式、数据长度都是固定的。

非结构化数据查询方法

    顺序扫描法(Serial Scanning)

所谓顺序扫描，好比要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每个文档，从头看到尾，若是此文档包含此字符串，则此文档为咱们要找的文件，接着看下一个文件，直到扫描完全部的文件。如利用windows的搜索也能够搜索文件内容，只是至关的慢。

    全文检索(Full-text Search)

将非结构化数据中的一部分信息提取出来，从新组织，使其变得有必定结构，而后对此有必定结构的数据进行搜索，从而达到搜索相对较快的目的。这部分从非结构化数据中提取出的而后从新组织的信息，咱们称之索引。

例如：字典。字典的拼音表和部首检字表就至关于字典的索引，对每个字的解释是非结构化的，若是字典没有音节表和部首检字表，在茫茫辞海中找一个字只能顺序扫描。然而字的某些信息能够提取出来进行结构化处理，好比读音，就比较结构化，分声母和韵母，分别只有几种能够一一列举，因而将读音拿出来按必定的顺序排列，每一项读音都指向此字的详细解释的页数。咱们搜索时按结构化的拼音搜到读音，而后按其指向的页数，即可找到咱们的非结构化数据——也即对字的解释。

    这种先创建索引，再对索引进行搜索的过程就叫全文检索(Full-text Search)。

虽然建立索引的过程也是很是耗时的，可是索引一旦建立就能够屡次使用，全文检索主要处理的是查询，因此耗时间建立索引是值得的。

如何实现全文检索

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

全文检索的应用场景

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

二、Lucene实现全文检索的流程

2.1索引和搜索流程图

一、绿色表示索引过程，对要搜索的原始内容进行索引构建一个索引库，索引过程包括：肯定原始内容即要搜索的内容->采集文档->建立文档->分析文档->索引文档        

二、红色表示搜索过程，从索引库中搜索内容，搜索过程包括：

用户经过搜索界面->建立查询->执行搜索，从索引库搜索->渲染搜索结果

2.2建立索引

对文档索引的过程，将用户要搜索的文档内容进行索引，索引存储在索引库（index）中。

这里咱们要搜索的文档是磁盘上的文本文件，根据案例描述：凡是文件名或文件内容包括关键字的文件都要找出来，这里要对文件名和文件内容建立索引。

2.2.1得到原始文档

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

本案例中的原始内容就是磁盘上的文件，以下图：

从互联网上、数据库、文件系统中等获取须要搜索的原始信息，这个过程就是信息采集，信息采集的目的是为了对原始内容进行索引。

在Internet上采集信息的软件一般称为爬虫或蜘蛛，也称为网络机器人，爬虫访问互联网上的每个网页，将获取到的网页内容存储起来。

本案例咱们要获取磁盘上文件的内容，能够经过文件流来读取文本文件的内容，对于pdf、doc、xls等文件可经过第三方提供的解析工具读取文件内容，好比Apache POI读取doc和xls的文件内容。

2.2.2建立文档对象

获取原始内容的目的是为了索引，在索引前须要将原始内容建立成文档（Document），文档中包括一个一个的域（Field），域中存储内容。

这里咱们能够将磁盘上的一个文件当成一个document，Document中包括一些Field（file_name文件名称、file_path文件路径、file_size文件大小、file_content文件内容），以下图：

注意：每一个Document能够有多个Field，不一样的Document能够有不一样的Field，同一个Document能够有相同的Field（域名和域值都相同）

每一个文档都有一个惟一的编号，就是文档id。

2.2.3分析文档

将原始内容建立为包含域（Field）的文档（document），须要再对域中的内容进行分析，分析的过程是通过对原始文档提取单词、将字母转为小写、去除标点符号、去除停用词等过程生成最终的语汇单元，能够将语汇单元理解为一个一个的单词。

好比下边的文档通过分析以下：

原文档内容：

Lucene is a Java full-text search engine.  Lucene is not a complete
application, but rather a code library and API that can easily be used
to add search capabilities to applications.

分析后获得的语汇单元：

lucene、java、full、search、engine。。。。

每一个单词叫作一个Term，不一样的域中拆分出来的相同的单词是不一样的term。term中包含两部分一部分是文档的域名，另外一部分是单词的内容。

例如：文件名中包含apache和文件内容中包含的apache是不一样的term。

2.2.4建立索引

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

注意：建立索引是对语汇单元索引，经过词语找文档，这种索引的结构叫倒排索引结构。

传统方法是根据文件找到该文件的内容，在文件内容中匹配搜索关键字，这种方法是顺序扫描方法，数据量大、搜索慢。

倒排索引结构是根据内容（词语）找文档，以下图：

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

 

2.3查询索引

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

2.3.1用户查询接口

全文检索系统提供用户搜索的界面供用户提交搜索的关键字，搜索完成展现搜索结果。

Lucene不提供制做用户搜索界面的功能，须要根据本身的需求开发搜索界面

2.3.2建立查询

用户输入查询关键字执行搜索以前须要先构建一个查询对象，查询对象中能够指定查询要搜索的Field文档域、查询关键字等，查询对象会生成具体的查询语法，

例如：语法 “fileName:lucene”表示要搜索Field域的内容为“lucene”的文档

2.3.3执行查询

搜索索引过程：

根据查询语法在倒排索引词典表中分别找出对应搜索词的索引，从而找到索引所连接的文档链表。

好比搜索语法为“fileName:lucene”表示搜索出fileName域中包含Lucene的文档。

搜索过程就是在索引上查找域为fileName，而且关键字为Lucene的term，并根据term找到文档id列表。

2.3.4渲染结果

以一个友好的界面将查询结果展现给用户，用户根据搜索结果找本身想要的信息，为了帮助用户很快找到本身的结果，提供了不少展现的效果，好比搜索结果中将关键字高亮显示，百度提供的快照等。

三、配置开发环境

3.1Lucene下载

Lucene是开发全文检索功能的工具包，从官方网站下载lucene-7.4.0，并解压。

官方网站：http://lucene.apache.org/

版本：lucene-7.4.0

Jdk要求：1.8以上

3.2使用的jar包

lucene-core-7.4.0.jar

lucene-analyzers-common-7.4.0.jar

四、入门程序

4.1需求

实现一个文件的搜索功能，经过关键字搜索文件，凡是文件名或文件内容包括关键字的文件都须要找出来。还能够根据中文词语进行查询，而且须要支持多个条件查询。

4.2建立索引

4.2.1实现步骤

第一步：建立一个java工程，并导入jar包。

第二步：建立一个indexwriter对象。

1. 指定索引库的存放位置Directory对象
2. 指定一个IndexWriterConfig对象。

第二步：建立document对象。

第三步：建立field对象，将field添加到document对象中。

第四步：使用indexwriter对象将document对象写入索引库，此过程进行索引建立。并将索引和document对象写入索引库。

第五步：关闭IndexWriter对象。

4.2.2代码实现

public class LuceneFirst {
    @Test
    public void createIndex() throws Exception {
        //一、建立一个Director对象，指定索引库保存的位置。
        //把索引库保存在内存中
        //Directory directory = new RAMDirectory();
        //把索引库保存在磁盘
        Directory directory = FSDirectory.open(new File("C:\\temp\\index").toPath());
        //二、基于Directory对象建立一个IndexWriter对象
        IndexWriterConfig config = new IndexWriterConfig(new IKAnalyzer());
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //三、读取磁盘上的文件，对应每一个文件建立一个文档对象。
        File dir = new File("C:\\A0.lucene2018\\05.参考资料\\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);
            //四、向文档对象中添加域
            //建立Field：TextField文本域。
            //参数1：域的名称，参数2：域的内容，参数3：是否存储
            Field fieldName = new TextField("name", fileName, Field.Store.YES);
            //Field fieldPath = new TextField("path", filePath, Field.Store.YES);
            Field fieldPath = new StoredField("path", filePath);
            Field fieldContent = new TextField("content", fileContent, Field.Store.YES);
            //Field fieldSize = new TextField("size", fileSize + "", 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);
            //五、把文档对象写入索引库
            indexWriter.addDocument(document);
        }
        //六、关闭indexwriter对象
        indexWriter.close();
    }

 4.2.3使用Luke工具查看索引文件

咱们使用的luke的版本是luke-7.4.0，跟lucene的版本对应的。能够打开7.4.0版本的lucene建立的索引库。须要注意的是此版本的Luke是jdk9编译的，因此要想运行此工具还须要jdk9才能够。

4.3查询索引

4.3.1实现步骤

第一步：建立一个Directory对象，也就是索引库存放的位置。

第二步：建立一个indexReader对象，须要指定Directory对象。

第三步：建立一个indexsearcher对象，须要指定IndexReader对象

第四步：建立一个TermQuery对象，指定查询的域和查询的关键词。

第五步：执行查询。

第六步：返回查询结果。遍历查询结果并输出。

第七步：关闭IndexReader对象

public void searchIndex() throws Exception {
        //一、建立一个Director对象，指定索引库的位置
        Directory directory = FSDirectory.open(new File("C:\\temp\\index").toPath());
        //二、建立一个IndexReader对象
        IndexReader indexReader = DirectoryReader.open(directory);
        //三、建立一个IndexSearcher对象，构造方法中的参数indexReader对象。
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        //四、建立一个Query对象，TermQuery
        Query query = new TermQuery(new Term("name", "spring"));
        //五、执行查询，获得一个TopDocs对象
        //参数1：查询对象 参数2：查询结果返回的最大记录数
        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("-----------------寂寞的分割线");
        }
        //九、关闭IndexReader对象
        indexReader.close();
    }

五、分析器

5.1分析器的分词效果

@Test
    public void testTokenStream() throws Exception {
        //1）建立一个Analyzer对象，StandardAnalyzer对象
        Analyzer analyzer = new StandardAnalyzer();
//        Analyzer analyzer = new IKAnalyzer();//使用IK分析器
        //2）使用分析器对象的tokenStream方法得到一个TokenStream对象
        //TokenStream tokenStream = analyzer.tokenStream("", "2017年12月14日 - 传智播客Lucene概述公安局Lucene是一款高性能的、可扩展的信息检索(IR)工具库。信息检索是指文档搜索、文档内信息搜索或者文档相关的元数据搜索等操做。");
        TokenStream tokenStream = analyzer.tokenStream("", "The Spring Framework provides a comprehensive programming and configuration model.");
        //3）向TokenStream对象中设置一个引用，至关于数一个指针
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        //4）调用TokenStream对象的rest方法。若是不调用抛异常
        tokenStream.reset();
        //5）使用while循环遍历TokenStream对象
        while(tokenStream.incrementToken()) {
            System.out.println(charTermAttribute.toString());
        }
        //6）关闭TokenStream对象
        tokenStream.close();
    }

运行结果：
spring
framework
provides
comprehensive
programming
configuration
model

 5.2中文分析器

5.2.1Lucene自带中文分词器

1. StandardAnalyzer：

单字分词：就是按照中文一个字一个字地进行分词。如：“我爱中国”，
效果：“我”、“爱”、“中”、“国”。

    2.SmartChineseAnalyzer

对中文支持较好，但扩展性差，扩展词库，禁用词库和同义词库等很差处理

5.2.2 IKAnalyzer

使用方法：

第一步：把jar包添加到工程中

第二步：把配置文件、扩展词典、停用词词典添加到classpath下

注意：hotword.dic和ext_stopword.dic文件的格式为UTF-8，注意是无BOM 的UTF-8 编码。

也就是说禁止使用windows记事本编辑扩展词典文件

5.3使用自定义分析器

@Test
    public void createIndex() throws Exception {
        //一、建立一个Director对象，指定索引库保存的位置。
        //把索引库保存在内存中
        //Directory directory = new RAMDirectory();
        //把索引库保存在磁盘
        Directory directory = FSDirectory.open(new File("C:\\temp\\index").toPath());
        //二、基于Directory对象建立一个IndexWriter对象
        //IndexWriter indexWriter=new IndexWriter(directory,new IndexWriterConfig());默认使用Lucene自带的分词器
        IndexWriterConfig config = new IndexWriterConfig(new IKAnalyzer());//使用IK分词器
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //三、读取磁盘上的文件，对应每一个文件建立一个文档对象。
        File dir = new File("C:\\A0.lucene2018\\05.参考资料\\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);
            //四、向文档对象中添加域。不一样的文本类型使用不一样的域：name、content可使用TextField
            //path也只是路径，不必分词
            //建立Field：TextField文本域。
            //参数1：域的名称，参数2：域的内容，参数3：是否存储
            Field fieldName = new TextField("name", fileName, Field.Store.YES);
            //Field fieldPath = new TextField("path", filePath, Field.Store.YES);
            Field fieldPath = new StoredField("path", filePath);
            Field fieldContent = new TextField("content", fileContent, Field.Store.YES);
            //可能会对fileSize进行一些处理，那么都使用TextField就不太合适，好比文件大小大于多少小于多少的
            //Field fieldSize = new TextField("size", fileSize + "", 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);
            //五、把文档对象写入索引库
            indexWriter.addDocument(document);
        }
        //六、关闭indexwriter对象
        indexWriter.close();
    }

代码演示：使用Lucene自带的分词器

@Test
    public void testTokenStream() throws Exception {
        //1）建立一个Analyzer对象，StandardAnalyzer对象
        Analyzer analyzer = new StandardAnalyzer();
//        Analyzer analyzer = new IKAnalyzer();//使用IK分析器
        //2）使用分析器对象的tokenStream方法得到一个TokenStream对象
        TokenStream tokenStream = analyzer.tokenStream("", "2017年12月14日 - 传智播客Lucene概述公安局Lucene是一款高性能的、可扩展的信息检索(IR)工具库。信息检索是指文档搜索、文档内信息搜索或者文档相关的元数据搜索等操做。");
        //TokenStream tokenStream = analyzer.tokenStream("", "The Spring Framework provides a comprehensive programming and configuration model.");
        //3）向TokenStream对象中设置一个引用，至关于数一个指针
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        //4）调用TokenStream对象的rest方法。若是不调用抛异常
        tokenStream.reset();
        //5）使用while循环遍历TokenStream对象
        while(tokenStream.incrementToken()) {
            System.out.println(charTermAttribute.toString());
        }
        //6）关闭TokenStream对象
        tokenStream.close();
    }

运行结果为：
2017
年
12
月
14
日
传
智
播
客
lucene
概
述
公
安
局
lucene
是
一
款
高
性
能
的
可
扩
展
的
信
息
检
索
ir
工
具
库
信
息
检
索
是
指
文
档
搜
索
文
档
内
信
息
搜
索
或
者
文
档
相
关
的
元
数
据
搜
索
等
操
做

使用IK分词器

运行结果为：
加载扩展词典：hotword.dic
加载扩展中止词典：stopword.dic
2017
12
14
传智播客
lucene
概述
lucene
一款
一
高性能
性能
可
扩展
信息
检索
ir
工具
库
信息
检索
文档
搜索
文档
内
信息
搜索
或者
文档
相关
数据
搜索
操做

六、索引库的维护

6.1索引库的添加

6.1.1Field域的属性

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

是否索引：将Field分析后的词或整个Field值进行索引，只有索引方可搜索到。

好比：商品名称、商品简介分析后进行索引，订单号、身份证号不用分析但也要索引，这些未来都要做为查询条件。

是否存储：将Field值存储在文档中，存储在文档中的Field才能够从Document中获取

好比：商品名称、订单号，凡是未来要从Document中获取的Field都要存储。

是否存储的标准：是否要将内容展现给用户

存不存储不影响查询（不存储，也是能够经过索引查询内容，好比查询content:内容，即使没有存储，可是依旧能够查询出content域中包含内容关键字），只影响能不能取出来

Field类	数据类型	Analyzed是否分析	Indexed是否索引	Stored是否存储	说明
StringField(FieldName, FieldValue,Store.YES))	字符串	N	Y	Y或N	这个Field用来构建一个字符串Field,可是不会进行分析, 会将整个串存储在索引中，好比(订单号,姓名等)是否存储在文档中用Store.YES或Store.NO决定
Long/int/floatPoint(String name, long... point)	Long型	Y	N	N	可使用LongPoint、IntPoint等类型存储数值类型的数据。让数值类型能够进行索引。可是不能存储数据，若是想存储数据还须要使用StoredField。
StoredField(FieldName, FieldValue)	重载方法，支持多种类型	N	N	Y	这个Field用来构建不一样类型Field 不分析，不索引，但要Field存储在文档中
TextField(FieldName, FieldValue, Store.NO) 或 TextField(FieldName, reader)	字符串 或 流	Y	Y	Y或N	若是是一个Reader, lucene猜想内容比较多,会采用Unstored的策略.

我的推论：若是分词那么确定要索引，否则分词没有意义？不分词也能够建立索引（StringField），好比身份证号什么的，不必分词，可是有可能须要查询，那么就须要建立索引

LongPoint(String name, long... point)：这个point仅仅是参与运算的，并不存储。

StoredField不分析不索引只存储，好比path就能够用这个

@Test
    public void createIndex() throws Exception {
        //一、建立一个Director对象，指定索引库保存的位置。
        //把索引库保存在内存中
        //Directory directory = new RAMDirectory();
        //把索引库保存在磁盘
        Directory directory = FSDirectory.open(new File("C:\\temp\\index").toPath());
        //二、基于Directory对象建立一个IndexWriter对象
        //IndexWriter indexWriter=new IndexWriter(directory,new IndexWriterConfig());默认使用Lucene自带的分词器
        IndexWriterConfig config = new IndexWriterConfig(new IKAnalyzer());//使用IK分词器
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //三、读取磁盘上的文件，对应每一个文件建立一个文档对象。
        File dir = new File("C:\\A0.lucene2018\\05.参考资料\\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);
            //四、向文档对象中添加域。不一样的文本类型使用不一样的域：name、content可使用TextField
            //path也只是路径，不必分词
            //建立Field：TextField文本域。
            //参数1：域的名称，参数2：域的内容，参数3：是否存储
            Field fieldName = new TextField("name", fileName, Field.Store.YES);
            //Field fieldPath = new TextField("path", filePath, Field.Store.YES);
            Field fieldPath = new StoredField("path", filePath);//Field.Store.YES默认就是存储
            Field fieldContent = new TextField("content", fileContent, Field.Store.YES);
            //可能会对fileSize进行一些处理，那么都使用TextField就不太合适，好比文件大小大于多少小于多少的
            //好比path域，其实他是不须要分词的，也就不必用TextField
            //Field fieldSize = new TextField("size", fileSize + "", 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);
            //五、把文档对象写入索引库
            indexWriter.addDocument(document);
        }
        //六、关闭indexwriter对象
        indexWriter.close();
    }

6.2索引库的增、删、改

添加文档

删除文档：

    1）删除所有

    2）根据查询(Query... queries)、关键词(Term... terms)删除

修改文档

    修改的原理：先删除、再添加

/**
 * 索引库维护：增、删、更新
 */
public class IndexManager {

    private IndexWriter indexWriter;

    @Before
    public void init() throws Exception {
        //建立一个IndexWriter对象，须要使用IKAnalyzer做为分析器
        indexWriter =
                new IndexWriter(FSDirectory.open(new File("C:\\temp\\index").toPath()),
                        new IndexWriterConfig(new IKAnalyzer()));
    }

    @Test
    public void addDocument() throws Exception {
        //建立一个IndexWriter对象，须要使用IKAnalyzer做为分析器
        indexWriter =
                new IndexWriter(FSDirectory.open(new File("C:\\temp\\index").toPath()),
                new IndexWriterConfig(new IKAnalyzer()));
        //建立一个Document对象
        Document document = new Document();
        //向document对象中添加域
        document.add(new TextField("name", "新添加的文件", Field.Store.YES));
        document.add(new TextField("content", "新添加的文件内容", Field.Store.NO));
        document.add(new StoredField("path", "c:/temp/helo"));
        // 把文档写入索引库。使用Lucene时，不一样的文档能够有不一样的域，同一个文档也不是域都要同样
        indexWriter.addDocument(document);
        //关闭索引库
        indexWriter.close();
    }

    @Test
    public void deleteAllDocument() throws Exception {
        //删除所有文档
        indexWriter.deleteAll();
        //关闭索引库
        indexWriter.close();
    }

    @Test
    public void deleteDocumentByQuery() throws Exception {
        //根据条件删除文档：删除name域中包含Apache关键字的文档
        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子类

        1.TermQuery

            根据关键词进行查询，须要制定要查询的关键词

        2.RangeQuery

            范围查询。计算使用LongPOint，取值用的StoreFiled

 

    2、使用QueryParse解析查询表达式

        能够对要查询的内容先分词，而后基于分词的结果进行查询

7.1 TermQuery

TermQuery，经过项查询，TermQuery不使用分析器因此建议匹配不分词的Field域查询，好比订单号、分类ID号等。

指定要查询的域和要查询的关键词(只能是词，不能是句子)。

//使用Termquery查询
@Test
public void testTermQuery() throws Exception {
    Directory directory = FSDirectory.open(new File("D:\\temp\\index").toPath());
    IndexReader indexReader = DirectoryReader.open(directory);
    IndexSearcher indexSearcher = new IndexSearcher(indexReader);
    
    //建立查询对象
    Query query = new TermQuery(new Term("content", "lucene"));
    //执行查询
    TopDocs topDocs = indexSearcher.search(query, 10);
    //共查询到的document个数
    System.out.println("查询结果总数量：" + topDocs.totalHits);
    //遍历查询结果
    for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
        Document document = indexSearcher.doc(scoreDoc.doc);
        System.out.println(document.get("filename"));
        //System.out.println(document.get("content"));
        System.out.println(document.get("path"));
        System.out.println(document.get("size"));
    }
    //关闭indexreader
    indexSearcher.getIndexReader().close();

 7.2 数值范围查询和queryparser查询

经过QueryParser也能够建立Query，QueryParser提供一个Parse方法，此方法能够直接根据查询语法来查询。Query对象执行的查询语法可经过System.out.println(query);查询。

须要使用到分析器。建议建立索引时使用的分析器和查询索引时使用的分析器要一致。

须要加入queryParser依赖的jar包：lucene-queryparser-7.4.0.jar

public class SearchIndex {
    private IndexReader indexReader;
    private IndexSearcher indexSearcher;
    @Before
    public void init() throws Exception {
        indexReader = DirectoryReader.open(FSDirectory.open(new File("C:\\temp\\index").toPath()));
        indexSearcher = new IndexSearcher(indexReader);
    }

    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("-----------------寂寞的分割线");
        }
        indexReader.close();
    }


    @Test
    public void testRangeQuery() throws Exception {
        //建立一个Query对象:参与运算的是LongPoint，取得值是StoreFiled的值。LongPoint主要能够用于范围查询
        Query query = LongPoint.newRangeQuery("size", 0l, 100l);
        printResult(query);
    }


    /**
     * 咱们使用Term查询的时候，只能是一个词，若是是一段话很明显就不行了。
     * 使用QueryParser，带分词的查询，先分词，再根据分词的结果进行查询
     * @throws Exception
     */
    @Test
    public void testQueryParser() throws Exception {
        //建立一个QueryParser对象，两个参数
        QueryParser queryParser = new QueryParser("name", new IKAnalyzer());
        //参数1：默认搜索域，参数2：分析器对象
        //使用QueryParser对象建立一个Query对象
        Query query = queryParser.parse("lucene是一个Java开发的全文检索工具包");
        //执行查询
        printResult(query);
    }
}