【Lucene】Apache Lucene全文检索引擎架构之构建索引

　　上一篇博文中已经对全文检索有了一定的了解，这篇文章主要来总结一下全文检索的第一步：构建索引。其实上一篇博文中的示例程序已经对构建索引写了一段程序了，而且那个程序还是挺完善的。不过从知识点的完整性来考虑，我想从Lucene的添加文档、删除文档、修改文档以及文档域加权四个部分来展开对构建索引的总结，也便于我后期的查看。会重点分析一下删除文档（因为有两中方式）和文档域加权这（实际中会用到比较多）两个部分。

1. 准备阶段

新建一个maven工程，pom.xml如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>demo.lucene</groupId>
  <artifactId>Lucene02</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <build/>

  <dependencies>
    <!-- lucene核心包 -->
    <dependency>
        <groupId>org.apache.lucene</groupId>
        <artifactId>lucene-core</artifactId>
        <version>6.1.0</version>
    </dependency>
    <!-- lucene查询解析包 -->
    <dependency>
        <groupId>org.apache.lucene</groupId>
        <artifactId>lucene-queryparser</artifactId>
        <version>6.1.0</version>
    </dependency>
    <!-- lucene解析器包 -->
    <dependency>
        <groupId>org.apache.lucene</groupId>
        <artifactId>lucene-analyzers-common</artifactId>
        <version>6.1.0</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
  </dependencies>
</project>

　　因为要测试的比较多，直接在工程中新建一个junit测试类IndexingTest1.java，然后在类中准备一下用来测试的数据，如下：

public class IndexingTest1 {

    private Directory dir; //存放索引的位置

    //准备一下用来测试的数据
    private String ids[] = {"1", "2", "3"}; //用来标识文档
    private String citys[] = {"shanghai", "nanjing", "qingdao"};
    private String descs[] = {
        "Shanghai is a bustling city.",
        "Nanjing is a city of culture.",
        "Qingdao is a beautiful city"
    };

    //等会写
    //……
}

　　这个数据就好比是数据库中存的三张表，文档标识表，城市表，城市描述表，那么每个文件中的内容实际上可以理解为包含id，城市和城市描述这样子。也就是说相当于有三个文件，每个文件中的内容描述了一个一个城市。下面开始每一部分的测试与分析了。

2. 添加文档

　　添加文档其实就是建立索引，那么首先得获取写索引的对象，然后通过这个对象去添加文档，每个文档就是一个Lucene的Document，先来看下程序，继续在IndexingTest.java中添加：

public class IndexingTest1 {

    private Directory dir; //存放索引的位置

    //准备一下用来测试的数据
    private String ids[] = {"1", "2", "3"}; //用来标识文档
    private String citys[] = {"shanghai", "nanjing", "qingdao"};
    private String descs[] = {
        "Shanghai is a bustling city.",
        "Nanjing is a city of culture.",
        "Qingdao is a beautiful city"
    };

    //生成索引
    @Test
    public void index() throws Exception {      
        IndexWriter writer = getWriter(); //获取写索引的实例
        for(int i = 0; i < ids.length; i++) {
            Document doc = new Document();
            doc.add(new StringField("id", ids[i], Field.Store.YES));
            doc.add(new StringField("city", citys[i], Field.Store.YES));
            doc.add(new TextField("descs", descs[i], Field.Store.NO));
            writer.addDocument(doc); //添加文档
        }
        writer.close(); //close了才真正写到文档中
    }

    //获取IndexWriter实例
    private IndexWriter getWriter() throws Exception {
        dir = FSDirectory.open(Paths.get("D:\\lucene2"));
        Analyzer analyzer = new StandardAnalyzer(); //标准分词器，会自动去掉空格啊，is a the等单词
        IndexWriterConfig config = new IndexWriterConfig(analyzer); //将标准分词器配到写索引的配置中
        IndexWriter writer = new IndexWriter(dir, config); //实例化写索引对象
        return writer;
    }

    //待会写
    //……
}

　　可以看出，其实相当于id、城市名和城市描述是一个文档中的不同的部分，然后用这三个作为了一个Field，便于后面去查询。每个文档添加好了域之后，就添加到写索引的实例writer中写入。实际中是先获取一个文件，然后根据这个文件的信息去设定一些Field， 然后将这些Field封装到Document对象中传给写索引的实例，类似于上一篇博文中的那些代码。
　　然后运行一下index方法，即可在D:\lucene2\目录下看到生成的索引文件。我们也可以写一个测试方法，测试一下生成了几个文档：

public class IndexingTest1 {

    //省略上面的代码

    /***********  下面来测试了  ****************/
    //测试写入了几个文档
    @Test
    public void testIndexWriter() throws Exception {
        IndexWriter writer = getWriter();
        System.out.println("总共写入了" + writer.numDocs() + "个文档");
        writer.close();
    }
}

3. 读取文档

　　读取文档的话需要IndexReader对象，初始化的时候要传入读取文档所在的路径，也就是刚刚上面生成文档的路径D:\lucene2\，然后即可读取文档数量，测试一下：

public class IndexingTest1 {

    //省略上面的代码

    //测试读取文档
    @Test
    public void testIndexReader() throws Exception {
        dir = FSDirectory.open(Paths.get("D:\\lucene2"));
        IndexReader reader = DirectoryReader.open(dir);
        System.out.println("最大文档数：" + reader.maxDoc());
        System.out.println("实际文档数：" + reader.numDocs());
        reader.close();
    }   
}

因为从测试数据中看，只有三个文档，测试结果如下：

最大文档数：3
实际文档数：3

4. 删除文档

　　这里我要着重说一下，删除文档有两种方式，这两种方式各有特点。一种是在合并前删除，另一种是在合并后删除，什么意思呢？合并前删除指的是并没有真正删除这个文档，只是在这个文档上做一个标记而已；而合并后删除指的是真正删掉了这个文档了。
　　这两个各有什么用呢？比如一个项目比较大的话，访问量也很多，那么在并发访问的情况下，频繁的删除操作会给系统的性能造成一定的影响，那么这个时候就可以用合并前删除，先不删，只是标记一下该文档属于已删除的文档，等到访问量比较小的时候（比如检测CPU比较闲的时候），我再调用删除程序统一删除标记过的文档，这样可以提升系统的性能。相反，如果数据量不大，删除操作也影响不了多大性能的话，那就直接删除好了，即使用合并后删除。下面针对这两个删除，各写一个测试程序测试一下：

public class IndexingTest1 {

    //省略上面的代码

    //测试删除文档，在合并前
    @Test
    public void testDeleteBeforeMerge() throws Exception {
        IndexWriter writer = getWriter();
        System.out.println("删除前有" + writer.numDocs() + "个文档");
        writer.deleteDocuments(new Term("id", "1")); //删除id=1对应的文档
        writer.commit(); //提交删除,并没有真正删除
        System.out.println("删除后最大文档数：" + writer.maxDoc());
        System.out.println("删除后实际文档数：" + writer.numDocs());
        writer.close();
    }

    //测试删除文档，在合并后
    @Test
    public void testDeleteAfterMerge() throws Exception {
        IndexWriter writer = getWriter();
        System.out.println("删除前有" + writer.numDocs() + "个文档");
        writer.deleteDocuments(new Term("id", "1")); //删除id=1对应的文档
        writer.forceMergeDeletes(); //强制合并（强制删除），没有索引了
        writer.commit(); //提交删除，真的删除了
        System.out.println("删除后最大文档数：" + writer.maxDoc());
        System.out.println("删除后实际文档数：" + writer.numDocs());
        writer.close();
    }   

}

　　在测试的时候要注意的是，测试完合并前删除后，要删掉索引路径中的所有索引，重新调用上面的index方法重新生成一下，再去测试合并后删除，因为之前删掉一个了，会影响后面的测试。看一下测试结果：

合并前删除：
　删除前有3个文档
　删除后最大文档数：3
　删除后实际文档数：2
合并后删除：
　删除前有3个文档
　删除后最大文档数：2
　删除后实际文档数：2

5. 修改文档

　　修改文档也就是更新文档，思路是先新建一个Document对象，然后按照前面设置的字段自己再设置个新的，然后更新原来的文档，看一下测试程序：

public class IndexingTest1 {

    //省略上面的代码

    //测试更新
    @Test
    public void testUpdate() throws Exception {
        IndexWriter writer = getWriter();
        //新建一个Document
        Document doc = new Document();
        doc.add(new StringField("id", ids[1], Field.Store.YES));
        doc.add(new StringField("city", "shanghai22", Field.Store.YES));
        doc.add(new TextField("descs", "shanghai update", Field.Store.NO));

        //将原来id为1对应的文档，用新建的文档替换
        writer.updateDocument(new Term("id", "1"), doc);
        writer.close();
        System.out.println(doc.getField("descs"));
    }       
}

　　看一下执行结果，会打印出indexed,tokenized<descs:shanghai update>，从decs描述中可以看出，这个描述是我们新建的那个文档的描述，说明我们已经修改成功了。

6. 文档域加权

　　这部分要着重说明一下，比如说我们在查询的时候，如果查询的字段在多个文档中都会存在，则会根据Lucene自己的排序规则给我们列出，但是如果我想优先看查询出来的某个文档呢？或者说我如何设定让Lucene按照自己的意愿的顺序给我列出查询出的文档呢？
　　这么说可能有点难以理解，举个通俗易懂的例子，有ABCD四个人都写了一篇关于java的文章，即文章标题都有java，现在我要查询有“java”这个字符串的文章，但是D是老板，我想如果查出来的文章中有老板写的，我要优先看老板的文章，也就是说要把老板的文章放在最前面，这个时候我就可以在程序中设定权重了。
　　要模拟这个场景，新建一个测试类IndexingTest2.java。我再造一下模拟的数据，如下：

public class IndexingTest2 {

    private Directory dir; //存放索引的位置

    //准备一下数据，四个人写了四篇文章，Json是boss
    private String ids[]={"1","2","3","4"};
    private String authors[]={"Jack","Marry","John","Json"};
    private String positions[]={"accounting","technician","salesperson","boss"};
    private String titles[]={"Java is a good language.","Java is a cross platform language","Java powerful","You should learn java"};
    private String contents[]={
            "If possible, use the same JRE major version at both index and search time.",
            "When upgrading to a different JRE major version, consider re-indexing. ",
            "Different JRE major versions may implement different versions of Unicode.",
            "For example: with Java 1.4, `LetterTokenizer` will split around the character U+02C6."
    };

}

　　按照惯例，我们得先对这些数据生成索引，这个和上面添加文档的过程的是一样的，唯一区别的是，在生成索引的时候加了一下权重操作。如下：

public class IndexingTest2 {

    //省略上面代码

    @Test
    public void index() throws Exception { //生成索引
        dir = FSDirectory.open(Paths.get("D:\\lucene2"));
        IndexWriter writer = getWriter();
        for(int i = 0; i < ids.length; i++) {
            Document doc = new Document();
            doc.add(new StringField("id", ids[i], Field.Store.YES));
            doc.add(new StringField("author", authors[i], Field.Store.YES));
            doc.add(new StringField("position", positions[i], Field.Store.YES));

            //这部分就是加权操作了，对title这个Field进行加权，因为等会我要查这个Field
            TextField field = new TextField("title", titles[i], Field.Store.YES);
            //先判断之个人对应的职位是不是boss，如果是就加权
            if("boss".equals(positions[i])) {
                field.setBoost(1.5f); //加权操作，默认为1，1.5表示加权了，小于1就降权了
            }

            doc.add(field);
            doc.add(new TextField("content", contents[i], Field.Store.NO));
            writer.addDocument(doc); //添加文档
        }
        writer.close(); //close了才真正写到文档中
    }

    //获取IndexWriter实例
    private IndexWriter getWriter() throws Exception {
        Analyzer analyzer = new StandardAnalyzer(); //标准分词器，会自动去掉空格啊，is a the等单词
        IndexWriterConfig config = new IndexWriterConfig(analyzer); //将标准分词器配到写索引的配置中
        IndexWriter writer = new IndexWriter(dir, config); //实例化写索引对象
        return writer;
    }
}

　　从代码中看出，如果想对那个field进行加权，就直接用该field去调用setBoost()方法即可，在调用之前，根据自己设定的条件进行判断就行了。先运行一下上面的index方法生成索引，然后我们写一个测试类来测试一下：

public class IndexingTest2 {

    //省略上面代码

    //文档域加权测试
    @Test
    public void search() throws Exception {
        dir = FSDirectory.open(Paths.get("D:\\lucene2"));
        IndexReader reader = DirectoryReader.open(dir);
        IndexSearcher search = new IndexSearcher(reader);
        String searchField = "title"; //要查询的Field
        String q = "java"; //要查询的字符串
        Term term = new Term(searchField, q);
        Query query = new TermQuery(term);

        TopDocs hits = search.search(query, 10);
        System.out.println("匹配" + q + "总共查询到" + hits.totalHits + "个文档");
        for(ScoreDoc score : hits.scoreDocs) {
            Document doc = search.doc(score.doc);
            System.out.println(doc.get("author")); //打印一下查出来记录对应的作者
        }
        reader.close();
    }
}

看一下执行结果：

匹配java总共查询到4个文档
Json
John
Jack
Marry

　　所以Json排在了第一位，因为他是Boss！~如果没有上面的那段加权代码，那么匹配出来的顺序是Lucene中自己的一个算法，可以认为是Lucene默认的顺序，这个底层的算法我就不去研究了，但是我们可以自己根据需求自己设定一下权重，这是实际中用的比较多的。　　

—–乐于分享，共同进步！
—–我的博客主页：http://blog.csdn.net/eson_15