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

小咪咪 2022-09-22 14:55 297阅读 0赞

欢迎关注我新搭建的博客：[http://www.itcodai.com/][http_www.itcodai.com]  
　　上一篇博文中已经对全文检索有了一定的了解，这篇文章主要来总结一下全文检索的第一步：构建索引。其实上一篇博文中的示例程序已经对构建索引写了一段程序了，而且那个程序还是挺完善的。不过从知识点的完整性来考虑，我想从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>
        
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-core</artifactId>
            <version>6.1.0</version>
        </dependency>
        
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-queryparser</artifactId>
            <version>6.1.0</version>
        </dependency>
        
        <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，然后在类中准备一下用来测试的数据，如下：

这个数据就好比是数据库中存的三张表，文档标识表，城市表，城市描述表，那么每个文件中的内容实际上可以理解为包含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默认的顺序，这个底层的算法我就不去研究了，但是我们可以自己根据需求自己设定一下权重，这是实际中用的比较多的。

文末福利：“程序员私房菜”，一个有温度的公众号~  
![程序员私房菜][70]

--------------------

—–乐于分享，共同进步！  
—–我的博客主页：[http://blog.csdn.net/eson\_15][http_blog.csdn.net_eson_15]

[http_www.itcodai.com]: http://www.itcodai.com/
[70]: /images/20220721/e0097fa529f849d9951492cd464cdd9a.png
[http_blog.csdn.net_eson_15]: http://blog.csdn.net/eson_15