Lucene的使用

[TOC]

Lucene是一种全文检索的工具，其原理和介绍参考[《Lucene简介》](https://www.datalearner.com/blog/1051542078586936)。本文介绍Lucene的使用。

Lucene的索引和查询过程是分开的，我们分别介绍。

#### 一、索引过程
Lucene的索引的对象是文档的集合，一条记录理解成一个文档，文档中可以包含多个字段，每个字段可以包含一种类别的数据。和关系型数据库的概念对应就是一个文档就是一行数据，一个列就是一个字段，列中的数据对应文档中字段的内容。Lucene中，文档是一个字段的序列，一个字段是一个term序列，一个term可以理解为一个单词或者是索引的对象，它是一个字节的序列。

一个简单的Lucene的索引写法如下：

```java
package dufei.lucene.main;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

/**
 * 基于Lucene 6.1.0的建立索引实例
 * Created by Du Fei on 2018/11/14.
 */
public class ASimpleLucene {

public static void main(String[] args) throws IOException {

// 定义索引存放的位置
    String indexDir = "c:/temp/lucene6index";

// step1: 创建索引写入类
    IndexWriter writer = createWriter(indexDir);

// step2: 创建待索引数据
    List<Document> documents = new ArrayList<>();

Document document1 = createDocument(1, "Lokesh", "Gupta", "howtodoinjava.com");
    documents.add(document1);

Document document2 = createDocument(2, "Brian", "Schultz", "brainschultz.com");
    documents.add(document2);

Document document3 = createDocument(7, "Jack", "Brown", "jackbrown.com");
    documents.add(document3);

// step2：添加待索引数据
    writer.addDocuments(documents);

// step3：提交索引
    writer.commit();

// step4: 关闭写入流
    writer.close();
    
  }

// 创建写入索引的对象
  private static IndexWriter createWriter(String indexDir) throws IOException {
    
    // 建立索引的文件夹，创建方式有很多，这里只用最基本的
    FSDirectory dir = FSDirectory.open(Paths.get(indexDir));
    
    // IndexWriterConfig保存了所有建立索引的配置信息，在这里设置索引配置，每索引的处理需要配一个分析器，
    // 这里只用最简单的标准的分析器，StandardAnalyzer
    IndexWriterConfig config = new IndexWriterConfig(new StandardAnalyzer());
    config.setOpenMode(IndexWriterConfig.OpenMode.CREATE);    // 索引打开的模式，可以是新建也可以追加
    config.setUseCompoundFile(false);                         // 是否使用压缩模式来保存索引文件
    return new IndexWriter(dir, config);
  }

// 创建文档的工具类
  private static Document createDocument(Integer id, String firstName, String lastName, String website) {
    Document document = new Document();
    document.add(new StringField("id", id.toString(), Field.Store.YES));
    document.add(new TextField("firstName", firstName, Field.Store.YES));
    document.add(new TextField("lastName", lastName, Field.Store.YES));
    document.add(new TextField("website", website, Field.Store.YES));
    return document;
  }

}

```

其主要的步骤如下：
1. 创建索引写入对象
2. 创建数据对象
3. 添加待索引数据
4. 提交索引
5. 关闭索引写入的流

有几点注意一下，每次创建IndexWriter的时候都会产生一个锁文件`writer.lock`，这时候其他的写入类就不能对当前索引进行写入或者修改操作，索引修改完毕删除了锁文件之后可以修改。

上述代码执行完毕之后在c:/temp/lucene6index路径下可以看到一系列文件。

下面详细介绍每个类的使用。

##### 1、首先是创建索引文件夹

```java
FSDirectory dir = FSDirectory.open(Paths.get(indexDir));
```
Lucene本身实现了一些底层存储的功能，因此，索引的读写都是基于自身的读写API进行的，上述代码是在现有的文件系统中创建写入索引的文件夹`FSDirectory`。`FSDirectory`这是一个基础的抽象类，它有三个子类，分别是```SimpleFSDirectory```、```NIOFSDirectory```和```MMapDirectory```。

这三种文件夹作用如下：

1. SimpleFSDirectory：这是用Files.newByteChannel直接实现的，但是性能比较差，多线程同事访问一个文件的时候会出现性能问题。
2. NIOFSDirectory：这是用java.nio包中的FileChannel实现的。但是这个类在Windows上有个bug，所以在windows平台上使用需要谨慎。但是其他平台都可以使用。
3. MMapDirectory：这是基于内存映射的IO操作。如果内存足够大，就选用这个方式创建索引即可。

在上述代码中（FSDirectory.open()），Lucene会检测系统环境，自动选择一个存储方案。

##### 2、接下来是创建数据的解析方式并加入到索引配置中
```java
// IndexWriterConfig保存了所有建立索引的配置信息，在这里设置索引配置，每索引的处理需要配一个分析器，
// 这里只用最简单的标准的分析器，StandardAnalyzer
IndexWriterConfig config = new IndexWriterConfig(new StandardAnalyzer());

// 索引打开的模式，可以是新建也可以追加
config.setOpenMode(IndexWriterConfig.OpenMode.CREATE);

// 是否使用压缩模式来保存索引文件
config.setUseCompoundFile(false);

IndexWriter writer = new IndexWriter(dir, config);
```

注意，Lucene是针对全文检索的程序，全文检索中一个重要的功能是针对文本数据进行分析后建立索引。对数据的分析就是Analyzer，Analyzer的目标是建立字符流，也就是将文本数据变成一系列单词的集合，或者是TokensStreams。不同的输入文本可以选择不同的分析器，这里使用的是StandardAnalyzer，它使用Unicode Text Segmentation algorithm来切分单词。对于飞文本数据，这个不重要。

接下来是创建IndexWriterConfig对象，这个对象保存了的索引操作的所有配置。包括缓存的大小、缓存文档的数量、索引打开的模式、索引文件是否压缩等。这里设置了两个量。

setOpenMode是索引的打开模式，索引的打开模式有三种：
1. CREATE：创建一个新的索引，如果已经存在则删除已存在的索引内容，但是索引版本继续往上。
2. APPEND：打开一个已存在的索引，追加内容
3. CREATE_OR_APPEND：如果不存在创建索引，如果存在，就打开已存在的，追加索引

setUseCompoundFile是指定索引文件是否压缩，在建立索引的时候，Lucene会产生很多不同的文件，包括索引、数据、词向量等。对于数据不大的情况，可以设置压缩模式，那么最终索引文件会产生两个：cfs文件和cfe文件。

配置写完之后，可以利用上述两个参数创建IndexWriter。

##### 3、创建数据
Lucene的存储对象是一系列的文档（Document）集合，每个文档包含了多个字段（Field），每个字段都包含多个单词（Term），每个单词都时一系列的字节（Bytes）。因此，在创建待索引的数据，就是创建Document对象。并将每个Document对象的字段设置好。

注意，Lucene的字段有几种不同的状态：

indexed：字段被索引，这个时候字段的内容一定也被保存了（注意，这可能是旧版本，新版本被索引不保存的状态貌似也存在，见后续测试）。

stored：字段被保存，但是不一定被索引，如果只是保存了没有被索引，那么是搜索不出来的，这种状态的字段通常是数据中的ID或者标识符等，不需要被搜索，但是在结果中需要展示。

既没有被索引也没有被保存的字段，是无法搜索和展示的。下面针对不同的字段会有不同的说明。

我们先看一个实例：

```java

private static Document createDocument(Integer id, String firstName, String lastName, String website) {
    Document document = new Document();
    document.add(new StringField("id", id.toString(), Field.Store.YES));
    document.add(new TextField("firstName", firstName, Field.Store.YES));
    document.add(new TextField("lastName", lastName, Field.Store.YES));
    document.add(new TextField("website", website, Field.Store.YES));
    return document;
  }
```

Lucene的字段包含了几种情况，首先按照大的类别看有两种，一种是字符型的，另一种是非字符型的。字符型的字段有两种，分别是StringField和TextField。两者区别如下：

StringField：这是指一个字符类型的字段，且不需要经过分词或者是其他的语言处理，相当于url/identifier等内容，不切分。

TextField：这是文本字符的字段，里面的内容需要切词，例如上面的StandardAnalyzer处理。

非字符型的字段包含整型、浮点型等常见的类型：
BinaryPoint
IntPoint
LongPoint
FloatPoint

注意，这几种字段的处理方式有所差别，首先，对于字符型字段，其构造的方式如下：

```java
new TextField("lastName", lastName, Field.Store.YES)；
new StringField("firstName", firstName, Field.Store.YES)
```

上述代码表明这个字段的名字是lastname，内容是传来的参数lastname，Field.Store.YES表明这个字段是否需要被存储。在实际中测试可以发现，如果不存储这个字段，这条记录依然可以搜索出来，但是无法展示，如果存储了这个字段，那么这个内容就可以展示了。使用StringField或者TextField构造的字段一定是被索引了。

下面我们看整型字段的添加：
```java
document.add(new IntPoint("age", age));
document.add(new StoredField("age", age));
```

注意，整型字段的创建方式和字符型有差别，最主要的是Lucene默认不会保存整型的数据，也没有在IntPoint中给出保存的接口，而是需要构造一个额外的StoredField来保存。上述代码如果只有第一行，那么age这个是可以检索的，但是无法展示，只有添加了第二行代码之后才能展示。

最后，如果我们只想保存某个字段，但是不检索的话，可以用如下的方式：

```java
document.add(new StoredField("otherName", otherName));
```

这个方式添加的字段可以展示，但是无法被搜索。

##### 4、创建索引，关闭索引写入流
```java

writer.addDocuments(documents);
writer.commit();
writer.close();

```

数据创建完毕后，可以提交并创建索引了。上述代码执行的时候会生成`writer.lock`文件，此时其他程序无法修改索引，但是可以查询。close之后才能修改。注意，每次修改索引文件，都会在索引位置产生新的索引文件，其差别就是在文件名后追加数字。如`segment_x.si`，其中x表示第几次修改。

#### 二、检索过程
Lucene的检索涉及到了四个API：

IndexSearcher：这是搜索索引的网关，所有的搜索都必须通过一个IndexSearcher实例进行。

Query：包含一些子类，与特定查询类型有关，Query的实例会被传递给IndexSearcher。

QueryParser：这个是解析自然搜索接口的，就是比如我们在搜索引擎搜索中那些and or语法

Hits：这个是搜索结果的接口，所有的结果都从这里取出。

##### 2.1、一般检索过程

Lucene中提供了两种查询的方式，一种是QueryParser，另一种是TermQuery。前者是针对TextField类型进行查询的，需要配合分析器使用（如前面的StandardAnalzyer，KeywordAnalzyer等）。而TermQuery就是针对某个字段进行搜索的，不需要分析器，是精确查询。二者的创建方法如下：

```java

// 读取索引所在的文件夹
Directory dir = FSDirectory.open(Paths.get(INDEX_DIR));
IndexReader reader = DirectoryReader.open(dir);

// 读取索引
IndexSearcher searcher = IndexSearcher(reader);

// 使用StandardAnalyzer创建QueryParser，这里的field是指定查询的字段名称，如id等
QueryParser query = new QueryParser("firstName", new StandardAnalyzer());

// 解析查询内容，brain是用户输入的查询词
Query qr = query.parse("brain");

// ---------如果使用TermQuery，则使用如下方式
Query qr = new TermQuery(new Term("firstName", "brain"));

// 获取查询结果，第二个10表示返回前多少条记录
TopDocs foundDocs =  searcher.search(qr, 10);

// 输出命中记录
System.out.println(foundDocs.totalHits);

// 输出每一条结果
for (ScoreDoc doc : foundDocs.scoreDocs) {
  Document result = searcher.doc(doc.doc);
  System.out.println(result.get("id") + "\t" + result.get("firstName"));
}
```

##### 2.2、StringField和TextField字段检索的差别

前面说过，在索引的时候需要提供分析器，最常用的分析器是StandardAnalyzer，这个分析器包含了去除常用的英文停用词，将所有的字母转换成小写等，它也会切词。分析器只会针对TextField进行转换，在查询的时候，如果针对TextField进行查询，可以使用QueryParser，这种查询会对用户的查询词做一些处理，因此需要配合一个分析器，注意，这个分析器需要和索引的分析器一样，才能查询出结果。否则会出现问题。例如，索引使用StandardAnalyzer，那么会转换大小写，并去除提用词，如果查询的时候使用KeywordAnalyzer，那么就不会转换大写字母，那么如果搜索词包含大写字母，是查询不到任何结果的。同样的，如果使用TermQuery查询，查询TextField字段中的停用词如a,the，或者是查询包含大写字母的内容，都是无法查询到结果的。我们看下面的例子：

```java
package dufei.lucene.main;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.core.KeywordAnalyzer;
import org.apache.lucene.analysis.core.SimpleAnalyzer;
import org.apache.lucene.analysis.core.StopAnalyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.index.*;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.index.TermsEnum;

import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

/**
 * a simple example of lucene
 * Created by Du Fei on 2018/11/5.
 */
public class FirstTest {

private static final String INDEX_DIR = "c:/temp/lucene6index";

public static void main(String[] args) throws Exception {
    IndexWriter writer = createWriter();
    List<Document> documents = new ArrayList<>();

Document document1 = createDocument(1, "Lokesh", "Gupta", "Hi, I am from Anhui province", 10);
    documents.add(document1);

Document document4 = createDocument(2, "Lokesh2", "Gupta2", "nice to meet you! I come from Jiangsu province", 10);
    documents.add(document4);

Document document2 = createDocument(3, "Brian", "Schultz", "I am glad to be here, I am from Hefei University of Technology", 20);
    documents.add(document2);

Document document3 = createDocument(4, "Brian2", "Schultz2", "I come from Nanjing, I graduate from Nanjing University", 30);
    documents.add(document3);
	
	Document document5 = createDocument(4, "Brown", "Jack", "I come from Nanjing, I am very glad to be here. I graduate from Nanjing University", 30);
    documents.add(document5);

//Let's clean everything first
    writer.deleteAll();

writer.addDocuments(documents);
    writer.commit();
    writer.close();

IndexSearcher searcher = createSearcher();

// 字段索引和保存的情况
    // id：保存，string字段不索引
    // firstName: string字段保存且索引
    // lastName：string字段保存且索引
    // introduction：text字段保存且索引
    // age：整型字段保存且索引
    System.out.println("--------------正常查询firstName，使用StandardAnalyzer分析器---------------------");
    TopDocs foundDocs = queryFieldWithStandardAnalyzer("firstName", "Brian", searcher);
    System.out.println(foundDocs.totalHits);