Lucene全文检索

最新推荐文章于 2022-08-29 19:56:57 发布

strongsix

最新推荐文章于 2022-08-29 19:56:57 发布

阅读量217

点赞数

本文链接：https://blog.csdn.net/qq_42390340/article/details/107894790

版权

一、什么是全文检索

1、数据的分类

（1）结构化数据
格式固定、长度固定、数据类型固定。
例如：数据库中的数据

（2）非结构化数据

word文档、pdf文档、邮件、html、 txt
格式不固定、长度不固定、数据类型不固定。

2、数据的查询

（1）结构化数据的查询
SQL语句，查询结构化数据的方法。简单、速度快。

（2）非结构化数据的查询

从文本文件中找出包含spring单词的文件。
1、目测
2、使用程序吧文档读取到内存中，然后匹配宇符串。顺序扫描。
3、把非结构化数据变成结构化数据

先根据空格进行字符串拆分，得到一个单词列表，基于单词列表创建一个索引。然后查询索引，根据单词和文档的对应关系找到文档列表。这个过程叫做全文检索。
索引: 一个为了提高查询速度，创建某种数据结构的集合。

3、全文检索

先创建索引然后查询索引的过程叫做全文检索。索引一次创建可以多次使用。表现为每次查询速度很快。

二、全文检索的应用场景

1、搜索引擎

百度、360搜索、谷歌、搜狗
在这里插入图片描述

2、站内搜索

论坛搜索、微博、文章搜索
在这里插入图片描述

3、电商搜索

淘宝搜索、京东搜索
在这里插入图片描述

4、场景：

只要是有搜索的地方就可以使用全文检索技术。

三、什么是Lucene

Lucene是一个基于Java开发全文检索工具包。.

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

在这里插入图片描述

1、创建索引

（1）获得文档

（2）构建文档对象

（3）分析文档

（4）创建索引

2、查询索引

（1）用户查询接口
用户输入查询条件的位置。例如：百度的搜索框
（2）把关键词封装成一个查询对象
要查询的域、要搜索的关键词
（3）执行查询
根据要查询的关键词到对应的城上进行搜索。找到关键词，根据关键词找到对应的文档
（4）渲染结果
根据文档的id找到文档对象，对关键词进行高亮显示，分页处理，最终展示给用户看。

五、入门程序

1、创建索引

环境准备：

需要下载Luence
http://lucene.apache.org/
最低要求jdk1.8

工程搭建：
创建一个java工程添加jar：
在这里插入图片描述
步骤：

 /*
        1、创建一个Director对象，指定索引库的位置source
        2、基于Directory对象创建一个IndexWriter对象
        3、读取磁盘上的文件，对应每个文件创建一个文档document对象
        4、新建文档对象，向文档对象中添加域
        5、把文档对象写入索引库
        6、关闭IndexWriter对象
     */
    @Test
    public void createIndex() throws IOException {
        //1、创建一个Director对象，指定索引库的位置source
        //把索引库保存内存当中
        //Directory directory = new RAMDirectory();
        //把索引库保存到磁盘上
        Directory directory = FSDirectory.open(
                new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath());
        //2、基于Directory对象创建一个IndexWriter对象
        IndexWriter indexWriter = new IndexWriter(directory,new IndexWriterConfig(new IKAnalyzer()));

        //3、读取磁盘上的文件，对应每个文件创建一个文档document对象
        File dir = new File(
                "E:\\Javaweb\\00.讲义+笔记+资料\\流行框架\\61.会员版(2.0)-就业课(2.0)-Lucene\\02.参考资料\\searchsource");
        File[] files = dir.listFiles();
        for (File file : files) {
            //取文件名
            String fileName = file.getName();
            //取文件路径
            String filePath = file.getPath();
            //取文件内容
            String fileContent = FileUtils.readFileToString(file,"utf-8");
            //文件大小
            long fileSize = FileUtils.sizeOf(file);

            //创建Field
            //参数1：域的名称，参数2：域的内容，参数3：是否存储
            Field fieldName = new TextField("name",fileName,Field.Store.YES);
            Field fieldPath = new TextField("path",filePath,Field.Store.YES);
            Field fieldContent = new TextField("content",fileContent,Field.Store.YES);
            Field fieldSize = new TextField("size",fileSize+"",Field.Store.YES);

            // 4、新建文档对象，向文档对象中添加域
            Document document = new Document();
            document.add(fieldName);
            document.add(fieldPath);
            document.add(fieldContent);
            document.add(fieldSize);
            System.out.println(fieldContent);
            //5、把文档对象写入索引库
            indexWriter.addDocument(document);
        }
        //6、关闭IndexWriter对象
        indexWriter.close();
    }

2、使用luke查看索引库的内容

在这里插入图片描述

3、查看索引库

  /**
     * 1、创建一个Director对象，指定索引库的位置
     * 2、创建一个IndexReader对象
     * 3、创建一个IndexSearcher对象，构造方法中的参数indexReader
     * 4、创建一个Query对象，TermQuery
     * 5、执行查询，得到一个TopDocs对象
     * 6、取查询结果的总记录数
     * 7、取文档列表
     * 8、打印文档中的内容
     * 9、关闭IndexWriter对象
     * @throws Exception
     */
    @Test
    public void searchIndex() throws Exception{
        // 1、创建一个Director对象，指定索引库的位置
        Directory directory = FSDirectory.open(new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath());
        // 2、创建一个IndexReader对象
        IndexReader indexReader = DirectoryReader.open(directory);
        // 3、创建一个IndexSearcher对象，构造方法中的参数indexReader
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        // 4、创建一个Query对象，TermQuery
        Query query = new TermQuery(new Term("content","spring"));
        // 5、执行查询，得到一个TopDocs对象,表示返回几条数据
        TopDocs topDocs = indexSearcher.search(query,10);
        // 6、取查询结果的总记录数
        System.out.println("查询的总记录数："+topDocs.totalHits);
        // 7、取文档列表
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        // 8、打印文档中的内容
        for (ScoreDoc doc : scoreDocs) {
            //去文档id
            int docId = doc.doc;
            //根据id获取文档对象
            Document document = indexSearcher.doc(docId);
            System.out.println("FILENAME:"+document.get("name"));
            System.out.println("PATH"+document.get("path"));
            System.out.println("SIZE:"+document.get("size"));
            //System.out.println(document.get("content"));
            System.out.println("+++++++++一条寂寞而独立的分割线++++++++++++++");
        }
        // 9、关闭IndexWriter对象
        indexReader.close();
        System.out.println("over");
    }

六、分析器

默认使用的是标准分析器StandardAnalyzer

1、标准分析器

//1、创建一个Director对象，指定索引库的位置source
        //把索引库保存内存当中
        //Directory directory = new RAMDirectory();
        //把索引库保存到磁盘上
        Directory directory = FSDirectory.open(
                new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath());
        //2、基于Directory对象创建一个IndexWriter对象
        IndexWriter indexWriter = new IndexWriter(directory,new IndexWriterConfig(/*new IKAnalyzer()*/));

        //3、读取磁盘上的文件，对应每个文件创建一个文档document对象


源码：
	    public IndexWriterConfig() {
	        this(new StandardAnalyzer());
	    }
	
	    public IndexWriterConfig(Analyzer analyzer) {
	        super(analyzer);
	        this.writer = new SetOnce();
	    }

2、默认分析器中文问题演示

标准分析器

    /**
     * 问题：
     *      分析英文没问题
     *      分析中文是单个字(问题)
     * @throws IOException
     */
    @Test
    public void testTokenStream() throws IOException {
        //1）创建一个Analyzer对象，StandardAnalyzer对象
        Analyzer analyzer = new StandardAnalyzer();
        //2）使用分析器对象的tokenStream方法获得一个TokenStream对象
        TokenStream tokenStream = analyzer.tokenStream("",
                "?? wo 翠峰没得事百事可乐我是冰淇淋水果王八蛋 public void testTokenStream() throws IOException");
        //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();
    }

演示结果
在这里插入图片描述

3、问题解决：使用IKAnalyzer中文分析器

IKAnalyzer使用方法：
（1）把IKAnalyzer的jar包添加到工程中
（2）配置文件和扩展词典添加到工程的classpath下。
在这里插入图片描述

注意： 扩展词典严禁使用Windows记事本编辑保证扩展词典的编码格式是utf-8
扩展词典： 添加的一些新词。
停用词典： 无意义的词或者敏感词汇。

/**
 * 问题：
 *    分析英文没问题
 *    分析中文是单个字(问题)
 *
 * 解决：
 *     使用中文分析器IKAnalyzer，需要导入相关的jar
 *     Analyzer analyzer = new IKAnalyzer();
 *
 * 添加配置文件：
 *     hotword.dic/stopword.dic/IKAnalyzer.cfg.xml
 *     hotword.dic:添加扩展词  stopword.dic:添加停用词
 *     当有多个dic文件需要在IKAnalyzer.cfg.xml中配置，用分号分隔。
 * @throws IOException
 */
public class Lucene01 {

    @Test
    public void testTokenStream() throws IOException {
        //1）创建一个Analyzer对象，StandardAnalyzer对象
        //Analyzer analyzer = new StandardAnalyzer();
        Analyzer analyzer = new IKAnalyzer();
        //2）使用分析器对象的tokenStream方法获得一个TokenStream对象
        TokenStream tokenStream = analyzer.tokenStream("","?? wo 翠峰没得事百事可乐我是冰淇淋水果王八蛋 public void testTokenStream() throws IOException");
        //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();
    }
}

演示结果：
在这里插入图片描述

4、案例中使用IK分析器

6.3	使用自定义分析器
@Test
public void addDocument() 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);
//...
}

七、索引库的维护

1、Field域的属性

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

是否索引： 将Field分析后的词或整个Field值进行索引，只有索引方可搜索到。
比如：商品名称、商品简介分析后进行索引，订单号、身份证号不用分析但也要索引，这些将来都要作为查询条件。

是否存储： 将Field值存储在文档中，存储在文档中的Field才可以从Document中获取。
比如：商品名称、订单号，凡是将来要从Document中获取的Field都要存储。

是否存储的标准： 是否要将内容展示给用户
在这里插入图片描述
代码演示：

public class LuceneFirst {
    /*
        1、创建一个Director对象，指定索引库的位置source
        2、基于Directory对象创建一个IndexWriter对象
        3、读取磁盘上的文件，对应每个文件创建一个文档document对象
        4、新建文档对象，向文档对象中添加域
        5、把文档对象写入索引库
        6、关闭IndexWriter对象
     */
    @Test
    public void createIndex() throws IOException {
        //1、创建一个Director对象，指定索引库的位置source
        //把索引库保存到磁盘上
        Directory directory = FSDirectory.open(new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath());
        //2、基于Directory对象创建一个IndexWriter对象
        IndexWriter indexWriter = new IndexWriter(directory,new IndexWriterConfig(new IKAnalyzer()));
        //3、读取磁盘上的文件，对应每个文件创建一个文档document对象
        File dir = new File("E:\\Javaweb\\00.讲义+笔记+资料\\流行框架\\61.会员版(2.0)-就业课(2.0)-Lucene\\02.参考资料\\searchsource");
        File[] files = dir.listFiles();
        for (File file : files) {
            //取文件名
            String fileName = file.getName();
            //取文件路径
            String filePath = file.getPath();
            //取文件内容
            String fileContent = FileUtils.readFileToString(file,"utf-8");
            //文件大小
            long fileSize = FileUtils.sizeOf(file);

            //创建Field
            //参数1：域的名称，参数2：域的内容，参数3：是否存储

            /**
             * StoredField:不分析(是否打乱)，不索引(Query处索引)，但要Field存储在文档
             * TextField:分析，索引，存储。
             * StringField：字符串，不分析，索引，(不)存储
             * LongPoint、IntPoint：分析，索引，不存储
             *      可以使用LongPoint、IntPoint等类型存储数值类型的数据。
             *      让数值类型可以进行索引。但是不能存储数据，
             *      如果想存储数据还需要使用StoredField。
             */
            //Field fieldName = new StoredField("name",fileName);
            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);

            // 4、新建文档对象，向文档对象中添加域
            Document document = new Document();
            document.add(fieldName);
            document.add(fieldPath);
            document.add(fieldContent);
            // document.add(fieldSize);
            document.add(fieldSizeValue);
            document.add(fieldSizeStore);
            System.out.println(fieldContent);
            //5、把文档对象写入索引库
            indexWriter.addDocument(document);
        }
        //6、关闭IndexWriter对象
        indexWriter.close();
    }

    /**
     * 1、创建一个Director对象，指定索引库的位置
     * 2、创建一个IndexReader对象
     * 3、创建一个IndexSearcher对象，构造方法中的参数indexReader
     * 4、创建一个Query对象，TermQuery
     * 5、执行查询，得到一个TopDocs对象
     * 6、取查询结果的总记录数
     * 7、取文档列表
     * 8、打印文档中的内容
     * 9、关闭IndexWriter对象
     * @throws Exception
     */
    @Test
    public void searchIndex() throws Exception{
        // 1、创建一个Director对象，指定索引库的位置
        Directory directory = FSDirectory.open(new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath());
        // 2、创建一个IndexReader对象
        IndexReader indexReader = DirectoryReader.open(directory);
        // 3、创建一个IndexSearcher对象，构造方法中的参数indexReader
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        // 4、创建一个Query对象，TermQuery
        Query query = new TermQuery(new Term("name","文档"));
        // 5、执行查询，得到一个TopDocs对象,表示返回几条数据
        TopDocs topDocs = indexSearcher.search(query,10);
        // 6、取查询结果的总记录数
        System.out.println("查询的总记录数："+topDocs.totalHits);
        // 7、取文档列表
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        // 8、打印文档中的内容
        for (ScoreDoc doc : scoreDocs) {
            //去文档id
            int docId = doc.doc;
            //根据id获取文档对象
            Document document = indexSearcher.doc(docId);
            System.out.println("FILENAME:"+document.get("name"));
            System.out.println("PATH"+document.get("path"));
            System.out.println("SIZE:"+document.get("size"));
            //System.out.println(document.get("content"));
            System.out.println("+++++++++一条寂寞而独立的分割线++++++++++++++");
        }
        // 9、关闭IndexWriter对象
        indexReader.close();
        System.out.println("over");
    }
}

2、添加文档

@Test
    public void addDocument() throws Exception{
        //创建一个IndexWriter对象，需要使用IKAnalyzer作为分析器
        IndexWriter indexWriter = new IndexWriter(FSDirectory.open(
                new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath()),
                new IndexWriterConfig(new IKAnalyzer()));
        //创建一个Document对象
        Document document = new Document();
        //向document对象中添加域
        document.add(new TextField("content","问问问问问", Field.Store.NO));
        document.add(new TextField("name","踢踢踢踢踢踢踢踢", Field.Store.YES));
        document.add(new StoredField("path","D:\\桌面"));
        //把文档对象写入索引库
        indexWriter.addDocument(document);
        //关闭索引库
        indexWriter.close();
    }

3、删除文档

@Test
    public void deleteAllDocument() throws Exception {
        //创建一个IndexWriter对象，需要使用IKAnalyzer作为分析器
        IndexWriter indexWriter = new IndexWriter(FSDirectory.open(
                new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath()),
                new IndexWriterConfig(new IKAnalyzer()));
        //删除全部文档
        indexWriter.deleteAll();
        //关闭索引库
        indexWriter.close();
    }//说明：将索引目录的索引信息全部删除，直接彻底删除，无法恢复

    @Test
    public void deleteDocumentByQuery() throws Exception {
        //创建一个IndexWriter对象，需要使用IKAnalyzer作为分析器
        IndexWriter indexWriter = new IndexWriter(FSDirectory.open(
                new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath()),
                new IndexWriterConfig(new IKAnalyzer()));
        indexWriter.deleteDocuments(new Term("name", "linux.txt"));
        indexWriter.close();
    }

4、修改文档

  @Test
    public void updateDocument() throws Exception {
        //创建一个IndexWriter对象，需要使用IKAnalyzer作为分析器
        IndexWriter indexWriter = new IndexWriter(FSDirectory.open(
                new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath()),
                new IndexWriterConfig(new IKAnalyzer()));
        //创建一个新的文档对象
        Document document = new Document();
        //向文档对象中添加域
        document.add(new TextField("name", "更新之后的文档", Field.Store.YES));
        document.add(new TextField("path", "Q://sogn", Field.Store.YES));

        //更新操作：原理就是先删除后添加。
        indexWriter.updateDocument(new Term("name", "spring"), document);
        //关闭索引库
        indexWriter.close();
    }

八、索引库查询

对要搜索的信息创建Query查询对象，Lucene会根据Query查询对象生成最终的查询语法，类似关系数据库Sql语法一样Lucene也有自己的查询语法，比如：“name:lucene”表示查询Field的name为“lucene”的文档信息。
可通过两种方法创建查询对象：

1）使用Lucene提供Query子类
2）使用QueryParse解析查询表达式

1、TermQuery查找

TermQuery，通过项查询，TermQuery不使用分析器所以建议匹配不分词的Field域查询，比如订单号、分类ID号等。
指定要查询的域和要查询的关键词。

查询name域为spring的记录（document）

/**
     * 1、创建一个Director对象，指定索引库的位置
     * 2、创建一个IndexReader对象
     * 3、创建一个IndexSearcher对象，构造方法中的参数indexReader
     * 4、创建一个Query对象，TermQuery
     * 5、执行查询，得到一个TopDocs对象
     * 6、取查询结果的总记录数
     * 7、取文档列表
     * 8、打印文档中的内容
     * 9、关闭IndexWriter对象
     * @throws Exception
     */
    @Test
    public void searchIndex() throws Exception{
        // 1、创建一个Director对象，指定索引库的位置
        Directory directory = FSDirectory.open(new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath());
        // 2、创建一个IndexReader对象
        IndexReader indexReader = DirectoryReader.open(directory);
        // 3、创建一个IndexSearcher对象，构造方法中的参数indexReader
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        // 4、创建一个Query对象，TermQuery
        Query query = new TermQuery(new Term("name","spring"));
        // 5、执行查询，得到一个TopDocs对象,表示返回几条数据
        TopDocs topDocs = indexSearcher.search(query,10);
        // 6、取查询结果的总记录数
        System.out.println("查询的总记录数："+topDocs.totalHits);
        // 7、取文档列表
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        // 8、打印文档中的内容
        for (ScoreDoc doc : scoreDocs) {
            //去文档id
            int docId = doc.doc;
            //根据id获取文档对象
            Document document = indexSearcher.doc(docId);
            System.out.println("FILENAME:"+document.get("name"));
            System.out.println("PATH"+document.get("path"));
            System.out.println("SIZE:"+document.get("size"));
            //System.out.println(document.get("content"));
            System.out.println("+++++++++一条寂寞而独立的分割线++++++++++++++");
        }
        // 9、关闭IndexWriter对象
        indexReader.close();
        System.out.println("over");
    }

2、数值范围查询

文件大小查询：文件size必须有索引

 @Test
    public void testRangeQuery() throws Exception {
        indexReader = DirectoryReader.open(FSDirectory.open(new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath()));
        indexSearcher = new IndexSearcher(indexReader);
        //创建一个Query对象
        Query query = LongPoint.newRangeQuery("size", 0l, 400l);
        //执行查询
        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();
    }

3、使用queryparser查询

通过QueryParser也可以创建Query，QueryParser提供一个Parse方法，此方法可以直接根据查询语法来查询。Query对象执行的查询语法可通过System.out.println(query);查询。
需要使用到分析器。建议创建索引时使用的分析器和查询索引时使用的分析器要一致。
需要加入queryParser依赖的jar包。
在这里插入图片描述

//不用指定在哪个域上查询
    @Test
    public void testQueryParser() throws Exception {
        indexReader = DirectoryReader.open(FSDirectory.open(new File("D:\\Java_IDEA\\JAVAData\\Lucenes\\Lucene入门\\resources\\outone").toPath()));
        indexSearcher = new IndexSearcher(indexReader);
        //创建一个QueryPaser对象，两个参数
        QueryParser queryParser = new QueryParser("name", new IKAnalyzer());
        //参数1：默认搜索域，参数2：分析器对象
        //使用QueryPaser对象创建一个Query对象
        Query query = queryParser.parse("java spring mybatis哈哈哈");
        //执行查询
        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();
    }

strongsix

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Lucene全文检索

文章目录一、什么是全文检索1、数据的分类2、数据的查询3、全文检索二、全文检索的应用场景1、搜索引擎2、站内搜索3、电商搜索4、场景：三、什么是Lucene四、Lucene实现全文检索的流程1、创建索引2、查询索引五、入门程序1、创建索引2、使用luke查看索引库的内容3、查看索引库六、分析器1、标准分析器2、默认分析器中文问题演示3、问题解决：使用IKAnalyzer中文分析器4、案例中使用IK分析器七、索引库的维护1、Field域的属性2、添加文档3、删除文档4、修改文档八、索引库查询1、TermQue
复制链接

扫一扫