Lucene实现全文检索

一、什么是全文检索

1.数据的分类

我们生活中的数据总体分为两种：结构化数据和非结构化数据。
结构化数据：指具有固定格式或有限长度的数据，是由二维表结构来逻辑表达和实现的数据，简单来说就是数据库
非结构化数据：指不定长或无固定格式的数据，不方便用数据库二维逻辑表来表现的数据，如邮件，word,pdf,html,txt文档等磁盘上的文件

2.结构化数据搜索(通常使用sql语句查询)

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

3.为什么数据库搜索很容易？

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

但是如果我要查询非结构化的数据呢?(比如找出内容中包含spring的文档)

4.非结构化数据搜索：顺序扫描法和全文检索

(1) 顺序扫描法(Serial Scanning)
	所谓顺序扫描，比如要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每一个文档，从头看到尾，如果此文档包含此字符串，则此文档为我们要找的文件，接着看下一个文件，直到扫描完所有的文件。如利用windows的搜索也可以搜索文件内容，只是相当的慢。

(2) 全文检索(Full-text Search)
	将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。
	这种先建立索引，再对索引进行搜索的过程就叫全文检索(Full-text Search)。
	虽然创建索引的过程也是非常耗时的，但是索引一旦创建就可以多次使用，全文检索主要处理的是查询，所以耗时间创建索引是值得的。

5.如何实现全文检索：可以使用Lucene实现全文检索

Lucene是apache下的一个开放源代码的全文检索引擎工具包。提供了完整的查询引擎和索引引擎，部分文本分析引擎。
Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能。
对于数据量大、数据结构不固定的数据可采用全文检索方式搜索，比如百度、Google等搜索引擎、论坛站内搜索、电商网站站内搜索等。

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

1.创建索引

(1) 获得文档
	原始文档:要基于哪些数据进行搜索，那么这些数据就是原始文档
	搜索引擎:使用爬虫技术获取原始文档
	站内搜索:数据库中的数据
(2) 构建文档对象---每个文档都有一个唯一的编号，就是文档id。
	对应每个原始文档创建一个文档(Document)对象
	注意：每个Document可以有多个Field(相当于一条记录有多个字段)，不同的Document可以有不同的Field，同一个Document可以有相同的Field（域名和域值都相同）
(3) 分析文档---分词的过程
	1.根据空格进行字符串拆分,得到一个单词列表
	2.把单词统一转换成小写或者大写
	3.去除标点符号
	4.去除停用词(没有意义的词)。
	每个关键词都封装到一个term对象中，Term中包含两部分内容，一部分是关键词所在的域，一部分是关键词本身。不同的域中拆分出来的相同的关键词是不同的term对象。
	new TextField("content",fileContent,Field.Store.YES);//将所有的内容生成关键词，保存在content域中
	new Term("content", "spring") //直接通过域名+需要搜索的关键字得到term对象
(4) 创建索引
	基于关键词列表来创建一个索引，保存在索引库中(磁盘上)。索引库中包含3部分内容：1.索引、2.Document对象、3.关键词和文档的对应关系

2.查询索引

(1) 用户查询接口
	用户输入查询条件的地方  例如百度搜索框、京东商品搜索框
(2) 把关键词封装成一个查询对象
   	要查询的域---field(域)：name-file_Content：value:具体的关键词列表
   	要搜索的关键词---springmvc
(3) 执行查询
    根据要查询的关键词到对应的域上进行搜索
(4) 渲染结果
	根据文档的id找到文档对象，对关键词进行高亮显示；分页处理；最终展示给用户看

三、Lucene入门案例

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

1.1 创建索引

创建一个java工程，并引入相关jar包

步骤: 
(1)创建一个Directory对象，指定索引库保存的位置
(2)基于Directory对象创建一个IndexWriter对象
(3)读取磁盘上的文件，对应每个文件创建一个文档对象
(4)向文档对象中添加域
(5)把文档对象写入索引库
(6)关闭IndexWriter对象

1.2 代码实现

package com.bianyiit.test;

import org.apache.commons.io.FileUtils;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
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.File;

public class testLuncene {
    public static void main(String[] args) throws Exception {
        //1.创建一个Directory对象，指定索引库保存的位置（原始文档提取的索引库所在的磁盘位置）
        FSDirectory direcotory= FSDirectory.open(new File("D:\\suoyin\\syml").toPath());
        //2.创建IndexWriter对象  作用：负责将document写入索引库 IndexWriterConfig:负责引用分词器（关键词的获取都是使用分词器完成的），底层默认使用的是标准分词器
        IndexWriter indexWriter=new IndexWriter(direcotory,new IndexWriterConfig());
        //3.读取磁盘上的文件(原始文件所在的位置)，对应每一个文件创建一个文档对象
        File file=new File("D:\\suoyin\\searchsource");
        File[] files = file.listFiles();//获取指定目录下面的文件对象的集合
        for (File f : files) {
            Document document= new Document();
            //获取文件名称
            String fileName = f.getName();
            //获取文件大小
            long fileSize= FileUtils.sizeOf(f);
            //获取文件路径
            String path = f.getPath();
            //获取文件内容
            String fileContent=FileUtils.readFileToString(f,"utf-8");
            //创建Filed域对象
            TextField fieldName=new TextField("name",fileName, Field.Store.YES);
            TextField fieldSize=new TextField("size",fileSize+"",Field.Store.YES);
            TextField fieldPath=new TextField("path",path,Field.Store.YES);
            TextField fieldContent=new TextField("content",fileContent,Field.Store.YES);
            //将域添加到Document对象中去
            document.add(fieldName);
            document.add(fieldSize);
            document.add(fieldPath);
            document.add(fieldContent);
            //将document对象写入索引库中
            indexWriter.addDocument(document);
        }
        //6.关闭IndexWriter对象
        indexWriter.close();
    }
}

2.1 查询索引库

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

package com.bianyiit.test;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.FSDirectory;

import java.io.File;

/*查询索引库的步骤*/
public class searchLuncene {
    public static void main(String[] args) throws Exception {
        //1.创建一个Directory对象，指定索引库保存的位置
        FSDirectory direcotory= FSDirectory.open(new File("D:\\suoyin\\syml").toPath());
        //2.创建IndexReader对象
        IndexReader indexReader= DirectoryReader.open(direcotory);
        //3.创建IndexSearch对象
        IndexSearcher indexSearcher=new IndexSearcher(indexReader);
        //4.封装一个查询对象
        TermQuery query=new TermQuery(new Term("content","spring"));
        //5.执行查询的操作:封装了查询出来的所有的document对象的集合
        TopDocs topDocs=indexSearcher.search(query,10);
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;//获取文档编号id的集合
        //6.根据文档编号获取对应的文档对象
        for (ScoreDoc scoreDoc : scoreDocs) {
            Document document=indexSearcher.doc(scoreDoc.doc);
            System.out.println("文件名称："+document.get("name"));
        }
        indexReader.close();
    }
}

3.1 使用luke查看索引库中的内容

四、分词器

1.标准分词器 StandardAnalyzer

Lucene默认使用的是标准分析器: StandardAnalyzer.这种分析器分析英文内容是没有问题的

package com.bianyiit.test;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;

public class TestTokenStream {
    public static void main(String[] args) throws Exception {
        //创建一个标准分析器对象
        Analyzer analyzer = new StandardAnalyzer();
        //获得tokenStream对象
        //第一个参数：域名，可以随便给一个
        //第二个参数：要分析的文本内容
        TokenStream tokenStream = analyzer.tokenStream("test", "The Spring Framework provides a comprehensive programming and configuration model.");
        //添加一个引用，可以获得每个关键词(相当于一根指针，指向每个关键词)
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        //添加一个偏移量的引用，记录了关键词的开始位置以及结束位置
        // OffsetAttribute offsetAttribute = tokenStream.addAttribute(OffsetAttribute.class);
        //将指针调整到列表的头部
        tokenStream.reset();
        //遍历关键词列表，通过incrementToken方法判断列表是否结束
        while (tokenStream.incrementToken()) {
            //关键词的起始位置
            // System.out.println("start->" + offsetAttribute.startOffset());
            //取关键词
            System.out.println(charTermAttribute.toString());
            //结束位置
            // System.out.println("end->" + offsetAttribute.endOffset());
        }
        tokenStream.close();
    }
}

1.1 原始文档

1.2 分词结果

2.中文分词器 IKAnalyzer

链接：https://pan.baidu.com/s/19b6F7N_y41IsVr_Pqr07Og 
提取码：i9b6

使用IKAnalyzer的步骤：
1.将IKAnalyzer的jar包添加到工程中---IK-Analyzer-1.0-SNAPSHOT.jar
2.把配置文件和扩展词典添加到工程的classpath下，也就是普通Java项目的src下面
注意：扩展词典严禁使用windows记事本编辑，保证扩展词典的编码格式是utf-8

扩展词典:添加一些新词进来
停用词词典:没有意义的词汇

package com.bianyiit.test;

import org.apache.commons.io.FileUtils;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.junit.Test;
import org.wltea.analyzer.lucene.IKAnalyzer;

import java.io.File;
import java.io.IOException;

public class IKTokenStream {
    public static void main(String[] args) throws Exception {
        //创建一个标准分析器对象
        Analyzer analyzer = new IKAnalyzer();
        //获得tokenStream对象
        //第一个参数：域名，可以随便给一个
        //第二个参数：要分析的文本内容
        TokenStream tokenStream = analyzer.tokenStream("test", "今天天气很好，适合户外运动，汤姆");
        //添加一个引用，可以获得每个关键词(相当于一根指针，指向每个关键词)
        CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
        //添加一个偏移量的引用，记录了关键词的开始位置以及结束位置
        // OffsetAttribute offsetAttribute = tokenStream.addAttribute(OffsetAttribute.class);
        //将指针调整到列表的头部
        tokenStream.reset();
        //遍历关键词列表，通过incrementToken方法判断列表是否结束
        while (tokenStream.incrementToken()) {
            //关键词的起始位置
            // System.out.println("start->" + offsetAttribute.startOffset());
            //取关键词
            System.out.println(charTermAttribute.toString());
            //结束位置
            // System.out.println("end->" + offsetAttribute.endOffset());
        }
        tokenStream.close();
    }
}

2.1 原始中文文档

2.2 中文分词结果

五、建立中文索引库，并查询中文关键词

1.使用中文分词器建立索引库

@Test
public void testMyIKTokenStream() throws IOException {
    //创建Directory对象，将索引库保存在磁盘
    Directory directory = FSDirectory.open(new File("D:\\suoyin\\syml").toPath());
    //基于Directory对象创建一个IndexWriter对象
    IndexWriterConfig config = new IndexWriterConfig(new IKAnalyzer());
    //创建一个indexwriter对象
    IndexWriter indexWriter = new IndexWriter(directory, config);
    //3.读取磁盘上的文件，对应每一个文件创建一个文档对象
    File file=new File("D:\\suoyin\\searchsource");
    File[] files = file.listFiles();//获取指定目录下面的文件对象的集合
    for (File f : files) {
        Document document= new Document();
        //获取文件名称
        String fileName = f.getName();
        //获取文件大小
        long fileSize= FileUtils.sizeOf(f);
        //获取文件路径
        String path = f.getPath();
        //获取文件内容
        String fileContent=FileUtils.readFileToString(f,"utf-8");
        //创建Filed域对象
        TextField fieldName=new TextField("name",fileName, Field.Store.YES);
        TextField fieldSize=new TextField("size",fileSize+"",Field.Store.YES);
        TextField fieldPath=new TextField("path",path,Field.Store.YES);
        TextField fieldContent=new TextField("content",fileContent,Field.Store.YES);
        //将域添加到Document对象中去
        document.add(fieldName);
        document.add(fieldSize);
        document.add(fieldPath);
        document.add(fieldContent);
        //将document对象写入索引库中
        indexWriter.addDocument(document);
    }
    //6.关闭IndexWriter对象
    indexWriter.close();
}

2.根据中文关键词去索引库中查询索引

package com.bianyiit.test;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.FSDirectory;

import java.io.File;

/*查询索引库的步骤*/
public class searchLuncene {
    public static void main(String[] args) throws Exception {
        //1.创建一个Directory对象，指定索引库保存的位置
        FSDirectory direcotory= FSDirectory.open(new File("D:\\suoyin\\syml").toPath());
        //2.创建IndexReader对象
        IndexReader indexReader= DirectoryReader.open(direcotory);
        //3.创建IndexSearch对象
        IndexSearcher indexSearcher=new IndexSearcher(indexReader);
        //4.封装一个查询对象
        TermQuery query=new TermQuery(new Term("content","索引"));
        //5.执行查询的操作:封装了查询出来的所有的document对象的集合
        TopDocs topDocs=indexSearcher.search(query,10);
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;//获取文档编号id的集合
        //6.根据文档编号获取对应的文档对象
        for (ScoreDoc scoreDoc : scoreDocs) {
            Document document=indexSearcher.doc(scoreDoc.doc);
            System.out.println("文件名称："+document.get("name"));
        }
        indexReader.close();
    }
}

六、索引库的维护

1. Field域的属性

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

2.添加索引

public class AddIndex {
	public static void main(String[] args) throws Exception{
        //索引库存放路径
        Directory directory = FSDirectory.open(new File("D:\\temp\\index").toPath());
        IndexWriterConfig config = new IndexWriterConfig(new IKAnalyzer());
        //创建一个indexwriter对象
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //创建一个Document对象
        Document document = new Document();
        //向document对象中添加域。
        //不同的document可以有不同的域，同一个document可以有相同的域。
        document.add(new TextField("filename", "新添加的文档", Field.Store.YES));
        document.add(new TextField("content", "新添加的文档的内容", Field.Store.NO));
        //LongPoint创建索引
        document.add(new LongPoint("size", 1000l));
        //StoreField存储数据
        document.add(new StoredField("size", 1000l));
        //不需要创建索引的就使用StoreField存储
        document.add(new StoredField("path", "d:/temp/1.txt"));
        //添加文档到索引库
        indexWriter.addDocument(document);
        //关闭indexwriter
        indexWriter.close();
    }
}

3.删除索引

private IndexWriter getIndexWriter() throws IOException {
    //创建Directory对象，将索引库保存在磁盘
    Directory directory = FSDirectory.open(new File("D:\\甲骨文视频2\\suoyin\\syml").toPath());
    //基于Directory对象创建一个IndexWriter对象
    IndexWriterConfig config = new IndexWriterConfig(new IKAnalyzer());
    IndexWriter indexWriter = new IndexWriter(directory, config);
    return indexWriter;
}

//删除全部索引
@Test
publicvoid deleteAllIndex() throws Exception {
	IndexWriter indexWriter = getIndexWriter();
	//删除全部索引
	indexWriter.deleteAll();
	//关闭indexwriter
	indexWriter.close();
}

4.根据查询条件删除索引

//根据查询条件删除索引
@Test
public void deleteIndexByQuery() throws Exception {
    IndexWriter indexWriter = getIndexWriter();
    //创建一个查询条件
    TermQuery query = new TermQuery(new Term("name", "apache"));
    //根据查询条件删除
    indexWriter.deleteDocuments(query);
    //关闭indexwriter
    indexWriter.close();
}

5.修改索引库

//修改索引库
@Test
public void updateIndex() throws Exception {
    IndexWriter indexWriter = getIndexWriter();
    //创建一个Document对象
    Document document = new Document();
    //向document对象中添加域。
    //不同的document可以有不同的域，同一个document可以有相同的域。
    document.add(new TextField("filename", "要更新的文档", Field.Store.YES));
    document.add(new TextField("content", " Lucene 简介 Lucene 是一个基于 Java 的全文信息检索工具包,"+
            "它不是一个完整的搜索应用程序,而是为你的应用程序提供索引和搜索功能。",
            Field.Store.YES));
    indexWriter.updateDocument(new Term("content", "java"), document);
    //关闭indexWriter
    indexWriter.close();
}

6.根据数值范围进行索引查询

package com.bianyiit.test;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.LongPoint;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.FSDirectory;
import org.junit.Before;
import org.junit.Test;

import java.io.File;

public class SearchIndex {
    private IndexReader indexReader;
    private IndexSearcher indexSearcher;
    @Before
    public void init() throws Exception{
        indexReader = DirectoryReader.open(FSDirectory.open(new File("D:\\suoyin\\syml").toPath()));
        indexSearcher = new IndexSearcher(indexReader);
    }
    @Test
    public void searchIndex() throws Exception{
        //创建一个Query对象
        Query query = LongPoint.newRangeQuery("size", 0, 100);
        TopDocs topDocs = indexSearcher.search(query, 10);
        System.out.println("总记录数:"+topDocs.totalHits);
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for(ScoreDoc scoreDoc:scoreDocs){
            int doc = scoreDoc.doc;
            Document document = indexSearcher.doc(doc);
            System.out.println(document.get("name"));
            System.out.println(document.get("path"));
            System.out.println(document.get("size"));
        }
        indexReader.close();
    }
}

7.使用queryparser查询:对查询的内容先分词，然后基于分词的结果进行查询

此时需要添加一个名为lucene-queryparser-7.4.0.jar的jar包。
注意：创建索引的时候，使用IK分词器

@Test
public void testQueryPaser()  throws Exception {
    QueryParser queryParser = new QueryParser("name",new IKAnalyzer());
    Query query = queryParser.parse("lucene是一个Java开发的全文检索工具包");
    printResult(query);

}
public void printResult(Query query) throws Exception{
    //1.创建一个Directory对象，指定索引库保存的位置
    FSDirectory direcotory= FSDirectory.open(new File("D:\\suoyin\\syml").toPath());
    //2.创建IndexReader对象
    IndexReader indexReader= DirectoryReader.open(direcotory);
    //3.创建IndexSearch对象
    IndexSearcher indexSearcher=new IndexSearcher(indexReader);
    TopDocs topDocs = indexSearcher.search(query, 10);
    System.out.println("总记录数:"+topDocs.totalHits);
    ScoreDoc[] scoreDocs = topDocs.scoreDocs;
    for(ScoreDoc scoreDoc:scoreDocs){
        int doc = scoreDoc.doc;
        Document document = indexSearcher.doc(doc);
        System.out.println(document.get("name"));
        System.out.println(document.get("path"));
        System.out.println(document.get("size"));
    }
    indexReader.close();
}