最详细的Lucene实现全文检索

最新推荐文章于 2023-05-29 02:03:01 发布
最新推荐文章于 2023-05-29 02:03:01 发布
阅读量2.5k 收藏 13
点赞数 2
分类专栏： Lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxc1207/article/details/104968781
版权

文章目录

1. 全文检索

1.1 为什么需要全文检索

数据可分为结构化数据和非结构化数据，对数据查询时，结构化数据可以通过 SQL 语句等方式查询，而非结构化数据（如PPT，word等）无法用此方式查询，我们利用 将非结构化数据转化为结构化数据 （即 先将文件中单词按空格拆分，把单词创建创建一个索引表，然后查询索引，根据单词和文档的关系找到文档列表，即全文检索），进行快速查询。

1.2 什么是全文检索

先创建索引，然后查询索引的过程是全文检索。
具有一次创建，多次使用的特点（创建的速度有点慢）。

1.3 应用的场景

1.搜索引擎
百度 360 google bing
2.站内搜索
论坛 CSDN文章搜索
3.电商搜索
淘宝 京东 软件内的搜索

2. Lucene介绍

2.1 定义

Lucene是一个开放源代码的全文检索引擎工具包。

2.2 Lucene 实现全文检索的流程

在这里插入图片描述

主要是 创建索引 和 查询索引两个步骤。

2.3 创建索引

2.3.1 获得文档

你可以利用你的技术从数据库、互联网、爬虫、word等方式获取原始文档，即 采集信息。

2.3.2 构建索引文档

对应每个原始文档创建一个 Document 对象（拥有唯一的ID）
每个 Document 中包含多个 Field
不同的Document可以有不同的Field
同一个Document可以有相同的Field
域中以键值对保存 域的 名称和值

2.3.1 分析文档（分词）

对原始文档提取单词、将字母转为小写、去除标点符号、去除停用词等过程生成最终的语汇单元，可以将语汇单元理解为一个一个的单词。
每个单词都是一个Term

The Spring Framework provides a comprehensive programming and configuration model.。

Spring 、Framework 、programming 、model 是一个个Term。
不同的域中拆分出来的相同的单词是不同的term。
term中包含两部分一部分是文档的域名，另一部分是单词的内容。

2.3.1 创建索引

基于关键词创建一个索引，保存到索引库中
在这里插入图片描述
通过词语找文档，这种索引的结构叫倒排索引结构。

2.4 查询索引

2.4.1 用户查询接口

在这里插入图片描述

2.4.2 创建查询

创建 查询对象Query，将需要查询的内容Term输入 进去，进行查询。

2.4.3 执行查询

根据对应搜索词的索引，从而找到索引所链接的文档链表。

2.4.4 渲染结果

搜索词如上图进行高亮显示。

3. Lucene使用

3.1 下载Lucene

点击下载Lucene

我的版本是7.4
jdk为1.8

3.2 导包

下面分别是使用 jar 和 maven

3.2.1 jar包

在这里插入图片描述

3.2.2 pom.xml

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

        <!-- 读取文件的IO -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <!-- lucene核心库 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-core</artifactId>
            <version>7.4.0</version>
        </dependency>
        <!-- Lucene的查询解析器 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-queryparser</artifactId>
            <version>7.4.0</version>
        </dependency>
        <!-- lucene的默认分词器库 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-analyzers-common</artifactId>
            <version>7.4.0</version>
        </dependency>
        <!-- lucene的高亮显示 -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-highlighter</artifactId>
            <version>7.4.0</version>
        </dependency>
    </dependencies>

3.3 创建索引

3.3.1 步骤：

1.创建一个indexwriter对象
2. 创建document对象

指定索引库的存放位置Directory对象
指定一个IndexWriterConfig对象

3.创建field对象，将field添加到document对象中
4.使用indexwriter对象将document对象写入索引库，此过程进行索引创建。并将索引和document对象写入索引库。
5.关闭IndexWriter对象

3.3.2 代码实现

@Test
    public void createIndex() throws Exception {
        //1.创建一个Directory对象，指定索引库保存的位置
        //1.1把索引库保存在内存中
        //Directory directory = new RAMDirectory();
        //1.2把做因结构保存在磁盘
        Directory directory = FSDirectory.open(new File("D:\\Lucene\\index").toPath());
        //2.基于Directory 对象创建一个IndexWriter对象
        IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig());
        //3.读取磁盘上的文件，对应每个文件创建一个文档对象
        File dir = new File("D:\\Lucene\\searchsource");
        File[] files = dir.listFiles();
        for (File f :
                files) {
            //取文件名
            String fileName = f.getName();
            //文件的路径
            String filePath = f.getPath();
            //文件的内容
            String fileContent = FileUtils.readFileToString(f, "utf-8");
            //文件的大小
            long fileSize = FileUtils.sizeOf(f);
            
            //创建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);
            
            //创建文档对象
            Document document = new Document();
            //4.向文档对象中添加域
            document.add(fieldName);
            document.add(fieldPath);
            document.add(fieldContent);
            document.add(fieldSize);
            
            //5.把文档对象写进索引库
            indexWriter.addDocument(document);
        }
        //6.关闭indexWriter对象
        indexWriter.close();
    }

3.3.2 结果显示

在这里插入图片描述

这就是人看不懂的索引库，但计算机看的很明白【无奈】

3.3 查询索引

3.3.1 步骤

3.3.2 代码实现

@Test
    public void searchIndex() throws Exception {
        //1.创建一个Directory对象，指向索引库位置
        Directory directory = FSDirectory.open(new File("D:\\Lucene\\index").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对象
        //参数1：查询对象；参数2：查询结果返回最大的记录数
        TopDocs topDocs = indexSearcher.search(query, 10);
        //6.取查询结果的总记录数
        System.out.println("查询总记录数：" + topDocs.totalHits);
        //7.取文档列表
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        //8.打印文档中的内容
        for (ScoreDoc scoredoc :
                scoreDocs) {
            //取文档id
            int docId = scoredoc.doc;
            //根据Id取文档对象
                //与创建的document是一个对象
            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("-----------------------------孤独的分割线");
        }
        //9.关闭indexReader对象
        indexReader.close();
        
    }

3.3.3 结果显示

在这里插入图片描述

3.4 分析器

在这里插入图片描述
在这里插入图片描述

它默认使用的是 标准分析器
但是使用 标准分析器 分析英文得到的是 单词
分析中文的话 得到的是 单个字（无意义）
因此 不可以使用 标准分析器 分析中文

3.5 中文分析器

3.5.1 pom.xml

    <properties>
        <lucene.version>7.4.0</lucene.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
            <groupId> org.apache.lucene</groupId>
            <artifactId> lucene-core</artifactId>
            <version> ${lucene.version}</version>
        </dependency>
        <dependency>
            <groupId> org.apache.lucene</groupId>
            <artifactId> lucene-analyzers-common</artifactId>
            <version> ${lucene.version}</version>
        </dependency>
        <dependency>
            <groupId> org.apache.lucene</groupId>
            <artifactId> lucene-queryparser</artifactId>
            <version> ${lucene.version}</version>
        </dependency>
        <dependency>
            <groupId> org.apache.lucene</groupId>
            <artifactId> lucene-highlighter</artifactId>
            <version> ${lucene.version}</version>
        </dependency>

        <!--  中文分析器  -->

        <dependency>
            <groupId>com.chenlb.mmseg4j</groupId>
            <artifactId>mmseg4j-core</artifactId>
            <version>1.10.0</version>
        </dependency>
        <dependency>
            <groupId>org.htmlparser</groupId>
            <artifactId>htmlparser</artifactId>
            <version>2.1</version>
            <exclusions>
                <exclusion>
                    <groupId>com.sun</groupId>
                    <artifactId>tools</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 如下可以编译最新的mmseg4j-analysis替换，不然加载报错 -->
        <dependency>
            <groupId>com.chenlb.mmseg4j</groupId>
            <artifactId>mmseg4j-solr</artifactId>
            <version>2.3.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.solr</groupId>
                    <artifactId>solr-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

3.5.2 代码实现

在这里插入图片描述

@Test
    public void createIndex() throws Exception {
        //1.创建一个Directory对象，指定索引库保存的位置
        //1.1把索引库保存在内存中
        //Directory directory = new RAMDirectory();
        //1.2把做因结构保存在磁盘
        Directory directory = FSDirectory.open(new File("D:\\Lucene\\index").toPath());
        //2.基于Directory 对象创建一个IndexWriter对象
        IndexWriterConfig config = new IndexWriterConfig(new ComplexAnalyzer());
        IndexWriter indexWriter = new IndexWriter(directory, config);
        //3.读取磁盘上的文件，对应每个文件创建一个文档对象
        File dir = new File("D:\\Lucene\\searchsource");
        File[] files = dir.listFiles();
        for (File f :
                files) {
            //取文件名
            String fileName = f.getName();
            //文件的路径
            String filePath = f.getPath();
            //文件的内容
            String fileContent = FileUtils.readFileToString(f, "utf-8");
            //文件的大小
            long fileSize = FileUtils.sizeOf(f);
            
            //创建Field
            //参数1：域的名称；参数2：域的值；参数3：是否进行存储
            Field fieldName = new TextField("name", fileName, Field.Store.YES);
            //就采不分词，不保存，只存储的方式
            Field fieldPath = new StoredField("path", filePath);
            Field fieldContent = new TextField("content", fileContent, Field.Store.YES);
            //采用分析索引，不存储，但是可以进行数值运算
            Field fieldSizeValue = new LongPoint("size", fileSize);
            //就采不分词，不保存，只存储的方式
            Field fieldSize = new StoredField("size", fileSize);
            
            //创建文档对象
            Document document = new Document();
            //4.向文档对象中添加域
            document.add(fieldName);
            document.add(fieldPath);
            document.add(fieldContent);
            document.add(fieldSizeValue);
            document.add(fieldSize);
            
            //5.把文档对象写进索引库
            indexWriter.addDocument(document);
        }
        //6.关闭indexWriter对象
        indexWriter.close();
    }

3.5.3 查看结果

在这里插入图片描述

3.6 Luck

点击获取Luck
提取码：jrb3
复制这段内容后打开百度网盘手机App，操作更方便哦

打开 指定位置为索引库的位置
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.7 Field域的属性

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

是否存储的标准：是否要将内容展示给用户

在这里插入图片描述

在这里插入图片描述
上文中的代码 ，都是用TextField 存储的，不太合适，我们可以进行以下修改
在这里插入图片描述
Luck查看
在这里插入图片描述

4. Lucene维护索引库

4.1 添加文档

4.1.1 代码实现

@Test
    public void addDocument() throws Exception {
        //1.创建一个IndexWriter对象，需要使用ComplexAnalyzer作为分析器
        IndexWriter indexWriter = new IndexWriter(FSDirectory.open(
                new File("D:\\Lucene\\index").toPath()),
                new IndexWriterConfig(new ComplexAnalyzer()));
        //2.创建一个Document 对象
        Document document = new Document();
        //3.向document 中添加域
        document.add(new TextField("name","新添加的文件", Field.Store.YES));
        document.add(new TextField("content","新添加的文件", Field.Store.NO));
        document.add(new StoredField("name","f:/temp/hello"));
        //4.把文档写进索引库
        indexWriter.addDocument(document);
        //5.关闭索引库
        indexWriter.close();
    }

4.1.2 查看结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.2 删除文档

4.2.1 删除所有文档

4.2.1.1 代码实现
 IndexWriter indexWriter =null;
    @Before
    public void init() throws IOException {
        indexWriter = new IndexWriter(FSDirectory.open(
                new File("D:\\Lucene\\index").toPath()),
                new IndexWriterConfig(new ComplexAnalyzer()));
    }
    @Test
    public void deleteDocument() throws Exception {
        indexWriter.deleteAll();
        indexWriter.close();
    }
4.2.1.2 查看结果

在这里插入图片描述

4.2.2 针对性删除

4.2.2.1 信息介绍

索引库共有15个document，
在这里插入图片描述

4.2.2.2 代码实现

在这里插入图片描述

 IndexWriter indexWriter =null;
    @Before
    public void init() throws IOException {
        indexWriter = new IndexWriter(FSDirectory.open(
                new File("D:\\Lucene\\index").toPath()),
                new IndexWriterConfig(new ComplexAnalyzer()));
    }
    @Test
    public void deleteDoumentByCondition() throws IOException {
        indexWriter.deleteDocuments(new Term("name","apache"));
        indexWriter.close();
    }
4.2.2.3 查看结果

在这里插入图片描述
在这里插入图片描述

4.3 修改文档

4.3.1 信息介绍

在这里插入图片描述

4.3.2 代码实现

@Test
    public void updateDocument() throws IOException {
    
        Document document = new Document();
        document.add(new TextField("name","update 之后的文档",Field.Store.YES));
        document.add(new TextField("name1","update 之后的文档1",Field.Store.YES));
        document.add(new TextField("name2","update 之后的文档2",Field.Store.YES));
        indexWriter.updateDocument(new Term("name","spring"),document);
        indexWriter.close();
    }

4.3.3 查询结果

在这里插入图片描述

4.4 查询文档

4.4.1 提取公用代码

package com.chao.lucene;

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;
import java.io.IOException;

/**
 * ClassName:SearchIndex
 * Package:com.chao.lucene
 * Description:
 *
 * @Date:2020/3/19 21:34
 * @Author: wxc
 */
public class SearchIndex {
    
    private IndexReader indexReader;
    private IndexSearcher indexSearcher;
    @Before
    public void init() throws IOException {
        indexReader = DirectoryReader.open(
                FSDirectory.open(new File("D:\\Lucene\\index").toPath()));
        indexSearcher = new IndexSearcher(indexReader);
    }
    
    public void printResult(Query query) throws IOException {
        TopDocs topDocs = indexSearcher.search(query, 10);
        System.out.println("总记录数："+topDocs.totalHits);
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc scoredoc :
                scoreDocs) {
            //取文档id
            int docId = scoredoc.doc;
            //根据Id取文档对象
            //与创建的document是一个对象
            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("-----------------------------孤独的分割线");
        }
        //9.关闭indexReader对象
        indexReader.close();
    }
}

4.4.2 TermQuery

4.4.2.1 适用范围

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

4.4.2.2 代码实现
 @Test
    public void testTermQuery() throws IOException {
        Query query = new TermQuery(new Term("content", "lucene"));
        printResult(query);
    }
4.2.2.3 查看结果

在这里插入图片描述

4.4.3 RangeQuery

4.4.3.1 适用范围

数值范围内的查询

4.4.3.2 代码实现
@Test
    public void testRangeQuery() throws IOException {
        //创建一个query对象
        Query query = LongPoint.newRangeQuery("size", 0L, 100L);
        printResult(query);
    }
4.4.3.3 查看结果

在这里插入图片描述

4.4.3 queryparser

4.4.3.1 适用范围

我查询的是一句话，它是带分析的查询，首先通过分词后，再根据分词后的结果在进行查询。
在这里插入图片描述
需要的依赖

		<dependency>
            <groupId> org.apache.lucene</groupId>
            <artifactId> lucene-queryparser</artifactId>
            <version> ${lucene.version}</version>
        </dependency>
4.4.3.2 代码实现
 @Test
    public void testQueryParser() throws IOException, ParseException {
        //创建QueryParser
        //参数1：默认域
        //参数2：分析器对象
        QueryParser queryParser = new QueryParser("name",new ComplexAnalyzer());
        //使用 QueryParser ，创建 QueryParser对象 ，
        Query query = queryParser.parse("lucene是一个Java开发的全文检索工具包");
        printResult(query);
    }
4.4.3.3 查看结果

在这里插入图片描述

CLAY超
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SpringBoot整合Lucene实现全文检索【详细步骤】【附源码】
笑小枫
12-14 3377
SpringBoot集成Lucene，一步步介绍集成使用步骤，解决和IK分词器冲突的问题。实现多字段检索，高亮返回结果，分页查询等功能。
Lucene—全文检索工具包
许久
01-15 1151
一、Lucene简介 Lucene是Apache Jakarta家族中的⼀个开源项目，是⼀个开放源代码的全文检索引擎工具包，但它不是⼀个 完整的 全文检索引擎，而是⼀个全文检索引擎的架构，提供了完整的查询引擎、索引引擎和部分文本分析引擎。 Lucene提供了⼀个简单却强大的应用程式接口，能够做全文索引和搜寻。在Java开发环境⾥Lucene是⼀个成熟的免费开源工具，是⽬前最为流行的基于 Java 开源全文检索工具包。 数据总体分为两种： 结构化数据：指具有固定格式或有限长度的数据，如数据库、元数据等
全文检索Lucene
YXZL的博客
06-21 877
全文检索Lucene lucene入门 ​ 什么是lucene ​ Lucene的作用 ​ 使用场景 ​ 优点和缺点 lucene应用 ​ 索引流程 ​ 搜索流程 ​ field域的使用 ​ 索引库维护 ​ 分词器 ​ 高级搜索实战案例 Lucene高级 ​ Lucene底层存储结构 ​ 词典排序算法 ​ Lucene优化 ​ Lucene使用的一些注意事项 1. 搜索技术理论基础 1.1. 为什么要学习Lucene 原
深度解析 Lucene 轻量级全文索引实现原理
qq_39652397的博客
04-15 791
一、Lucene简介 1.1 Lucene是什么？ Lucene是Apache基金会jakarta项目组的一个子项目； Lucene是一个开放源码的全文检索引擎工具包，提供了完整的查询引擎和索引引擎，部分语种文本分析引擎； Lucene并不是一个完整的全文检索引擎，仅提供了全文检索引擎架构，但仍可以作为一个工具包结合各类插件为项目提供部分高性能的全文检索功能； 现在常用的ElasticSearch、Solr等全文搜索引擎均是基于Lucene实现的。 1.2 Lucene的使用场景 适用于需要数据
Lucene（全文检索技术）教程
huzecom的博客
10-08 1252
1.什么是全文检索 1.1数据分类 我们生活中的数据总体分为两种：结构化数据和非结构化数据。 结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。 非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等磁盘上的文件 1.2结构化数据搜索 常见的结构化数据也就是数据库中的数据。在数据库中搜索很容易实现，通常都是使用sql语句进行查询，而且能很快的得到查询...
Java轻量级全文检索引擎Lucene使用及优化
BXA
05-29 4134
Lucene是一个开源的全文检索引擎工具包由Doug Cutting编写。它被设计用于实现全文搜索功能，即读入一堆文本文件并将其转换为易于搜索的数据结构。Lucene提供了一组简单而强大的API，使得索引和搜索过程变得非常方便。
使用Lucene实现全文检索的前提准备
07-05
mysql中一个表的大量数据
Lucene.Net 实现全文检索
03-10
总的来说，Lucene.Net 在 .Net MVC4 上实现全文检索是一个涉及数据库交互、索引构建、查询处理和结果展示的综合过程。通过熟练掌握 Lucene.Net 的使用，可以为用户提供高效、准确的全文搜索体验。
Lucene实现全文检索
04-19
**标题：“Lucene实现全文检索”** 在信息技术领域，全文检索是一种从大量文本数据中查找相关信息的关键技术。Apache Lucene是Java开发的一款开源全文搜索引擎库，它为开发者提供了构建高效、可扩展的搜索功能的...
基于Lucene的全文检索实践
08-29 236
数据可以分为结构化数据和非结构化数据，对数据查询时，结构化数据可以通过SQL语句等方式查询，而非结构化数据（如txt，word等）无法用此方式查询。我们利用将非结构化数据转化为非结构化数据（即先将文件中单词按空格拆分，把单词创建一个索引，然后查询索引，根据单词和文档的关系找到文档列表，即全文检索），进行快速查询。先创建索引，然后查询索引的过程是全文检索具有一次创建，多次使用的特点（创建的速度有点慢）。...
基于Lucene的全文检索框架
08-21
OSChina开源社区做的基于Lucene的全文检索的框架，相当于一个全文检索工具，包括索引的创建、更新、搜索，及其他工具类。
lucene实现的一个简单的搜索引擎
03-31
NULL 博文链接：https://aqbbsxiao.iteye.com/blog/1364894
Lucene全文检索
qq_1595986877
08-09 217
文章目录一、什么是全文检索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
安卓高级编程之实现类似三星系统的设置界面，并用lucene建立搜索系统
sinat_27171121的博客
09-14 809
安卓的默认设置实现略显杂乱无章，且无法搜索。需要亿点美化与扩展。
Lucene全文检索框架+Solr+ElasticSearch搜索引擎(Java高级必备.ES)
09-30
课程提供所有代码笔记素材以及答疑 1、Lucene框架的熟练应用实现类似百度、京东商城等应用的全文检索效果; 1、Solr简介 2、Solr下载安装以及目录结构介绍 3、Solr应用部署至Tomcat服务器 4、Solr后台管理界面介绍 5、通过managed-schema配置Field以及中文分词器 6、将数据库中的数据导入至Solr索引库 7、通过Solr后台管理界面对索引进行CRUD高亮过滤排序分页 8、通过Solrj实现索引的添加更新 9、通过Solrj实现索引的删除 10、索引的检索_过滤_高亮等操作 11、项目实战应用 12、Solr知识点总结 1、熟练掌握Lucene框架的使用，实现类似百度、京东商城等应用的全文检索效果; 2、ElasticSearch下载安装(window以及linux下安装) 3、集群环境搭建 4、客户端Kibana安装与使用 5、集群管理插件head安装使用 6、java api 操作 ES 7、电商项目实战应用等等 .....
Lucene（2）：Lucene全文检索的流程
u013938578的博客
05-13 511
获取原始内容的目的是为了索引，在索引前需要将原始内容创建成文档（Document），文档中包括一个一个的域（Field），域中存储内容。根据关键字搜索索引，根据索引找到对应的文档，从而找到要搜索的内容。倒排索引结构也叫反向索引结构，包括索引和文档两部分，索引即词汇表，它的规模较小，而文档集合较大。对所有文档分析得出的语汇单元进行索引，索引的目的是为了搜索，最终要实现只搜索被索引的语汇单。对文档索引的过程，将用户要搜索的文档内容进行索引，索引存储在索引库（index）中。
lucene全文检索操作实例
菜菜的博客
11-21 237
Lucene是apache下的一个开放源代码的全文检索引擎工具包。提供了完整的查询引擎和索引引擎，部分文本分析引擎。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能。 全文检索 将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。 例如：字典。字典的拼音表和部首检字表就相当于字典的索引，对每一个字的解释是非结构化的，如
3、Lucene实现全文检索的流程
u013115157的博客
12-13 3534
1.1 案例描述我们以一个案例来研究全文检索系统架构：实现一个文件的搜索功能，通过关键字搜索文件，凡是文件名或文件内容包括关键字的文件都需要找出来。 1.2索引和搜索流程图1、绿色表示索引过程，对要搜索的原始内容进行索引构建一个索引库，索引过程包括：确定原始内容即要搜索的内容à采集文档à创建文档à分析文档à索引文档        2、红色表示搜索过程，从索引库中搜索内容，搜索过程包括：用户通过搜索...
lucene mysql全文检索
最新发布
08-16
使用Lucene实现对MySQL数据表的全文检索是一种可行的方案。Lucene是一套开源的全文检索和搜寻的程式库，它提供了一个简单但强大的应用程式接口，能够实现全文索引和搜寻的功能。在Java开发环境中，Lucene是一个成熟的免费开源工具，被广泛应用于信息检索领域。 全文检索是一种针对非结构化数据的检索方法，对于像磁盘上的文件、网站资源等非结构化数据，无法使用SQL语句进行查询，因此需要使用全文检索法。全文检索法将非结构化数据中的一部分信息提取出来进行组织，形成索引，然后根据索引快速定位到要查找的信息。Lucene可以实现全文检索的功能，它是Apache软件基金会支持和提供的工具包。 使用Lucene实现全文检索的流程如下： 1. 创建索引：首先获取要进行检索的文档，可以是磁盘文件或网站资源等，然后构建文档对象，包括多个域，如文件名称、文件路径、文件大小、文件内容等。接下来对文档进行分词，将分词结果创建为索引并添加到索引库中。 2. 索引搜索：创建查询对象，执行查询并渲染结果。在倒排索引词典表中查找对应搜索词的索引，然后找到索引所链接的文档。例如，搜索语法为"fileName:lucene"表示搜索文件名中包含Lucene的文档。 要使用Lucene实现全文检索，首先需要下载和配置Lucene。你可以从官方网站或其他可信的资源下载Lucene的安装包，并按照相应的指南进行配置。然后，你可以使用Lucene提供的API来实现全文检索功能，根据具体需求进行代码编写和调用。 总之，Lucene是一种强大的全文检索工具，可以帮助你在MySQL数据表中实现全文检索功能。你可以通过学习和使用Lucene的API来了解更多关于Lucene的功能和用法，并根据具体需求进行相应的实现。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [【springboot微服务】Lucence实现Mysql全文检索](https://blog.csdn.net/zhangcongyi420/article/details/129940816)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *3* [【Lucene&Solr】Lucene实现全文检索](https://blog.csdn.net/qq_43705275/article/details/107229299)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值