lucene索引文件怎么存放（Lucene全文检索实战）

生活中的数据总体分为两种：结构化数据和非结构化数据，下面我们就来聊聊关于lucene索引文件怎么存放?接下来我们就一起去了解一下吧!

lucene索引文件怎么存放

什么是全文检索数据分类

生活中的数据总体分为两种：结构化数据和非结构化数据。

结构化数据 - 行数据，可以用二维表结构来逻辑表达实现的数据；指具有固定格式或有限长度的数据，如数据库，元数据等。

非结构化数据 - 指不定长或无固定格式的数据，如邮件，word 文档等磁盘上的文件。

结构化数据搜索

常见的结构化数据也就是数据库中的数据。

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

客户端请求 ----> 连接器 连接器 ----> 缓存区 连接器 ----> 分析器 ​ 分析器 ----> 缓存区 分析器 ----> 优化器 ​ 优化器 ----> 执行器 ​ Server 层： - 连接器 - 缓存区 - 分析器 - 优化器 - 执行器 ​ Server 层 ----> 存储引擎（引擎1，引擎2，引擎3）

因为数据库中的数据存储是有规律的，有行有列而且数据格式、数据长度都是固定的，所以数据库搜索很容易。

数据库底层文件存储的物理方式：硬盘是块状存储，其基本单位是 1kb 每块；磁头每次读取数据，至少扫描一个块的大小。

假如表里一个元组，数据加起来一共 100 b，则一个块可以放十个元组，通俗的说是 10 条数据，DBMS 在查询时，就把每一块的数据读取出来，判断其中是否有对应的数据。

常见的关系型数据，其最基本常见的存储方式：

• 堆 - 随着文件的插入，不停地往尾部上堆；它地访问路径就是顺序扫描，扫完了才能查到数据。
• Hash - 文件的 hash 值就是其存储地址。
• 索引 堆 - 对堆文件的某一列，建立 b 树索引。

非结构化数据查询方法

1）顺序扫描法 (Serial Scanning)

用户搜索 --> 文件

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

2）全文检索 (Full-text Search)

用户通过查询索引库 --> 生成索引 --> 文档

全文检索是指计算机索引程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置，当用户查询时，检索程序就根据事先建立的索引进行查找，并将查找的结果反馈给用户的检索方法。这个过程类似于通过字典的目录查字的过程。

将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。

例如：字典。字典的拼音表和部首检字表就相当于字典的索引，对每一个字的解释是非结构化的，如果字典没有音节表和部首检字表，在茫茫辞海中找一个字只能顺序扫描。然而字的某些信息可以提取出来进行结构化处理，比如读音，就比较结构化，分声母和韵母，分别只有几种可以一一列举，于是将读音拿出来按一定的顺序排列，每一项读音都指向此字的详细解释的页数。我们搜索时按结构化的拼音搜到读音，然后按其指向的页数，便可找到我们的非结构化数据——也即对字的解释。

这种先建立索引，再对索引进行搜索的过程就叫全文检索 (Full-Text Search)。虽然创建索引的过程也是非常耗时的，但是索引一旦创建就可以多次使用，全文检索主要处理的是查询，所以耗时间创建索引是值得的。

建立索引 --> 检索索引

如何实现全文检索

可以使用 Lucene 实现全文检索。Lucene 是 apache 下的一个开放源代码的全文检索引擎工具包。提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）。Lucene 的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能。

Lucene 适用场景：

• 在应用中为数据库中的数据提供全文检索实现。
• 开发独立的搜索引擎服务、系统

Lucene 的特性：

1. 稳定、索引性能高。 每小时能够索引 150 GB 以上的数据 对内存的要求小，只需要 1 MB 的堆内存 增量索引和批量索引一样快 索引的大小约为索引文本大小的 20% ~ 30% ​ 2. 高效、准确、高性能的搜索算法。 良好的搜索排序 强大的查询方式支持：短语查询、通配符查询、临近查询、范围查询等 支持字段搜索（如标题、作者、内容） 可根据任意字段排序 支持多个索引查询结果合并 支持更新操作和查询操作同时进行 支持高亮、join、分组结果功能 速度快 可扩展排序模块，内置包含向量空间模型、BM25 模型可选 可配置存储引擎 ​ 3. 跨平台。 纯 java 编写 作为 Apache 开源许可下的开源项目，你可以在商业或开源项目中使用 Lucene 有多种语言实现版（如 C，C 、Python 等），不仅仅是 JAVA

Lucene 架构：

Application: 从文件系统、数据库、Web、手动输入获取数据，然后生成索引。 获取用户的 Query，然后查询索引，返回查询结果给用户。 ​ 用户 --职位搜索--> 应用服务器 --SQL--> 结构化数据库 ​ Lucene： 生成索引需要与索引库交互。 查询索引需要与索引库交互。 ​ 用户 --职位搜索--> 应用服务器 --特定API--> Lucene索引库 ​ 数据源（网络、数据库、文档） ----> Lucene索引库

全文检索的应用场景

对于数据量大、数据结构不固定的数据可采用全文检索方式搜索：

• 单机软件的搜索：word、markdown。
• 站内搜索：京东、淘宝、拉勾，索引源是数据库。
• 搜索引擎：百度、Google，索引源是爬虫程序抓取的数据。

Lucene 实现全文检索的流程说明索引和搜索流程图

查询索引： 1. 用户查询接口 2. 创建查询 3. 执行查询 4. 渲染结果 ​ 用户查询索引 -----> 索引库 ​ 原始文档 ----> 创建索引 --创建索引--> 索引库 --返回结果--> 用户查询索引 ​ 创建索引： 1. 获取文档 2. 构建文档对象 3. 分析文档（分词） 4. 创建索引

对要搜索的原始内容进行索引构建一个索引库，索引过程包括：确定原始内容即要搜索的内容 --> 采集文档 --> 创建文档 --> 分析文档 --> 索引文档。

从索引库中搜索内容，搜索过程包括：用户通过搜索界面 --> 创建查询 --> 执行搜索从索引库搜索 --> 渲染搜索结果。

创建索引

核心概念：

Document：

• 用户提供的源是一条条记录，它们可以是文本文件、字符串或者数据库表的一条记录等等。
• 一条记录经过索引之后，就是以一个 Document 的形式存储在索引文件中的。
• 用户进行搜索，也是以 Document 列表的形式返回。

Field：

• 一个 Document 可以包含多个信息域。例如一篇文章可以包含“标题”、“正文”、“最后修改时间”等信息域，这些信息域就是通过 Field 在 Document 中存储的。
• Field 有两个属性可选：存储和索引。通过存储属性可以控制是否对这个 Field 进行存储；通过索引属性可以控制是否对该 Field 进行索引。
• 如果对标题和正文进行全文搜索，要把索引属性设置为真，同时希望能直接从搜索结果中提取文章标题，把标题域的存储属性设置为真；但是由于正文域太大了，为了缩小索引文件大小，可以将正文域的存储属性设置为假，当需要时再直接读取文件；如果只是希望能从搜索结果中提取最后修改时间，不需要对它进行搜索，可以把最后修改时间域的存储属性设置为真，索引属性设置为假。上面的三个域涵盖了两个属性的三种组合，还有一种全为假的没有用到，事实上 Field 不允许那么设置，因为既不存储又不索引的域是没有意义的。

Term：

• 是搜索的最小单位，它表示文档的一个词语，Term 由两部分组成：它表示的词语和这个词语所出现的 Field 的名称。

以招聘网站的搜索为例，在网站上输入关键字搜索显示的内容不是直接从数据库中来的，而是从索引库中获取的，网站的索引数据需要提前创建的。以下是创建的过程：

• 获得原始文档 - 就是从 MySQL 数据库中通过 SQL 语句查询需要创建索引的数据。
• 创建文档对象（Document）- 把查询的内容构建成 lucene 能识别的 Document 对象，获取原始内容的目的是为了索引，在索引前需要将原始内容创建成文档，文档中包括一个一个的域（Field），这个域对应就是表中的列。
• 注意 - 每个 Document 可以有多个 Field，不同的 Document 可以有不同的 Field，同一个Document 可以有相同的 Field（域名和域值都相同）。每个文档都有一个唯一的编号，就是文档 id。
• 分析文档 - 将原始内容创建为包含域（Field）的文档（document），需要再对域中的内容进行分析，分析的过程是经过对原始文档提取单词、将字母转为小写、去除标点符号、去除停用词等过程生成最终的语汇单元，可以将语汇单元理解为一个一个的单词。分好的词会组成索引库中最小的单元：term，一个 term 由域名和词组成。
• 创建索引 - 对所有文档分析得出的语汇单元进行索引，索引的目的是为了搜索，最终要实现只搜索被索引的语汇单元从而找到 Document（文档）。
• 注意 - 创建索引是对语汇单元索引，通过词语找文档，这种索引的结构叫倒排索引结构。倒排索引结构是根据内容（词语）找文档。倒排索引结构也叫反向索引结构，包括索引和文档两部分，索引即词汇表，它的规模较小，而文档集合较大。

倒排索引

倒排索引 Inverted List 记录每个词条出现在哪些文档，及在文档中的位置，可以根据词条快速定位到包含这个词条的文档及出现的位置。

文档：索引库中的每一条原始数据，例如一个商品信息、一个职位信息。

词条：原始数据按照分词算法进行分词，得到的每一个词。

创建倒排索引，分为以下几步：

1）创建文档列表 - Lucene 首先对原始文档数据进行编号 DocID，形成列表，就是一个文档列表。

2）创建倒排索引列表 - 对文档中数据进行分词，得到词条（分词后的一个又一个词）。对词条进行编号，以词条创建索引。然后记录下包含该词条的所有文档编号（及其它信息）。

搜索的过程：当用户输入任意的词条时，首先对用户输入的数据进行分词，得到用户要搜索的所有词条，然后拿着这些词条去倒排索引列表中进行匹配。找到这些词条就能找到包含这些词条的所有文档的编号。然后根据这些编号去文档列表中找到文档

查询索引

查询索引也是搜索的过程。搜索就是用户输入关键字，从索引（index）中进行搜索的过程。根据关键字搜索索引，根据索引找到对应的文档

第一步：创建用户接口 - 用户输入关键字的地方。

第二步：创建查询 - 指定查询的域名和关键字。

第三步：执行查询。

第四步：渲染结果（结果内容显示到页面上 关键字需要高亮）。

Lucene 实战需求说明

生成职位信息索引库，从索引库检索数据。

创建数据库 es，将 sql 脚本导入数据库执行。

/*!40101 SET NAMES utf8 */; ​ /*!40101 SET SQL_MODE=''*/; ​ /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */; /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */; /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */; /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */; CREATE DATABASE /*!32312 IF NOT EXISTS*/`es` /*!40100 DEFAULT CHARACTER SET latin1 */; ​ USE `es`; ​ /*Table structure for table `job_info` */ ​ DROP TABLE IF EXISTS `job_info`; ​ CREATE TABLE `job_info` ( `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键 id', `company_name` varchar(100) DEFAULT NULL COMMENT '公司名称', `company_addr` varchar(200) DEFAULT NULL COMMENT '公司联系方式', `company_info` mediumtext COMMENT '公司信息', `job_name` varchar(100) DEFAULT NULL COMMENT '职位名称', `job_addr` varchar(50) DEFAULT NULL COMMENT '工作地点', `job_info` mediumtext COMMENT '职位信息', `salary_min` int(10) DEFAULT NULL COMMENT '薪资范围，最小', `salary_max` int(10) DEFAULT NULL COMMENT '薪资范围，最大', `url` varchar(150) DEFAULT NULL COMMENT '招聘信息详情页', `time` varchar(10) DEFAULT NULL COMMENT '职位最近发布时间', PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=7656 DEFAULT CHARSET=utf8 COMMENT='招聘信息';

中文分词器使用 IK。

准备开发环境第一步：创建一个 maven 工程，创建一个 Spring Boot 项目第二步：导入依赖

<?xml version="1.0" encoding="UTF-8"?> <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 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.6.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.renda</groupId> <artifactId>lucene-demo</artifactId> <version>0.0.1-SNAPSHOT</version> <name>lucene-demo</name> <description>Demo project for Spring Boot</description> ​ <properties> <java.version>11</java.version> </properties> ​ <dependencies> <!-- web 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- 测试依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <!-- lombok 工具 --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.4</version> <scope>provided</scope> </dependency> <!-- 热部署 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency> <!-- mybatis-plus --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.3.2</version> </dependency> <!-- pojo 持久化使用 --> <dependency> <groupId>javax.persistence</groupId> <artifactId>javax.persistence-api</artifactId> <version>2.2</version> </dependency> <!-- mysql 驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <!-- 引入 Lucene 核心包及分词器包 --> <dependency> <groupId>org.apache.lucene</groupId> <artifactId>lucene-core</artifactId> <version>4.10.3</version> </dependency> <dependency> <groupId>org.apache.lucene</groupId> <artifactId>lucene-analyzers-common</artifactId> <version>4.10.3</version> </dependency> <dependency> <groupId>org.testng</groupId> <artifactId>testng</artifactId> <version>RELEASE</version> <scope>test</scope> </dependency> <!-- IK 中文分词器 --> <dependency> <groupId>com.janeluo</groupId> <artifactId>ikanalyzer</artifactId> <version>2012_u6</version> </dependency> </dependencies> ​ <build> <plugins> <!-- 编译插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>11</source> <target>11</target> <encoding>utf-8</encoding> </configuration> </plugin> <!-- 打包插件 --> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build> ​ </project>

第三步：创建引导类 com.renda.LuceneDemoApplication

package com.renda; ​ import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; ​ @SpringBootApplication @MapperScan("com.renda.mapper") public class LuceneDemoApplication { ​ public static void main(String[] args) { SpringApplication.run(LuceneDemoApplication.class, args); } ​ }

第四步：配置 application.yml 文件

server: port: 9000 Spring: application: name: lagou-lucene datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/es?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC username: root password: password ​ # 开启驼峰命名匹配映射 mybatis: configuration: map-underscore-to-camel-case: true

第五步：创建实体类、Mapper、Service、Controller 等等

实体类 com.renda.pojo.JobInfo：

package com.renda.pojo; ​ import lombok.Data; import lombok.ToString; ​ import javax.persistence.Id; import javax.persistence.Table; ​ @Data @ToString @Table(name = "job_info") public class JobInfo { ​ @Id private long id; private String companyName; private String companyAddr; private String companyInfo; private String jobName; private String jobAddr; private String jobInfo; private long salaryMin; private long salaryMax; private String url; private String time; ​ }

数据层 com.renda.mapper.JobInfoMapper：

public interface JobInfoMapper extends BaseMapper<JobInfo> { }

服务层

com.renda.service.JobInfoService

public interface JobInfoService { ​ /** * 通过id查询 */ public JobInfo selectById(long id); ​ /** * 查询所有 */ public List<JobInfo> selectAll(); ​ }

com.renda.service.impl.JobInfoServiceImpl

@Service public class JobInfoServiceImpl implements JobInfoService { ​ @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection") @Autowired private JobInfoMapper jobInfoMapper; ​ @Override public JobInfo selectById(long id) { return jobInfoMapper.selectById(id); } ​ @Override public List<JobInfo> selectAll() { return jobInfoMapper.selectList(new QueryWrapper<JobInfo>()); } ​ }

控制层 com.renda.controller.JobInfoController

@RestController @RequestMapping("/jobInfo") public class JobInfoController { ​ @Autowired private JobInfoService jobInfoService; ​ @RequestMapping("/query/{id}") public JobInfo selectById(@PathVariable Long id){ return jobInfoService.selectById(id); } ​ @RequestMapping("/query") public List<JobInfo> select(){ return jobInfoService.selectAll(); } ​ }

测试类 com.renda.LuceneDemoApplicationTests

@RunWith(SpringRunner.class) @SpringBootTest public class LuceneDemoApplicationTests { ... }

整体结构：

src/main/java com.renda.controller JobInfoController com.renda.mapper JobInfoMapper com.renda.pojo JobInfo com.renda.service impl.JobInfoServiceImpl JobInfoService com.renda LuceneDemoApplication src/main/resources static templates application.yml src/test/java com.renda LuceneDemoApplicationTests

创建索引

测试类 com.renda.LuceneDemoApplicationTests

@RunWith(SpringRunner.class) @SpringBootTest public class LuceneDemoApplicationTests { ​ @Autowired private JobInfoService jobInfoService; ​ /** * 创建索引 */ @Test public void createIndex() throws Exception { // 1.指定索引文件的存储位置，索引具体的表现形式就是一组有规则的文件 Directory directory = FSDirectory.open(new File("E:/class/index")); // 2.配置版本及其分词器 Analyzer analyzer = new IKAnalyzer(); IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, analyzer); // 3.创建 IndexWriter 对象，作用就是创建索引 IndexWriter indexWriter = new IndexWriter(directory, config); // 先删除已经存在的索引库 indexWriter.deleteAll(); // 4.获得索引源 / 原始数据 List<JobInfo> jobInfoList = jobInfoService.selectAll(); // 5. 遍历 jobInfoList，每次遍历创建一个 Document 对象 for (JobInfo jobInfo : jobInfoList) { // 创建 Document 对象 Document document = new Document(); // 创建 Field 对象，添加到 document 中 document.add(new LongField("id", jobInfo.getId(), Field.Store.YES)); // 切分词、索引、存储 document.add(new TextField("companyName", jobInfo.getCompanyName(), Field.Store.YES)); document.add(new TextField("companyAddr", jobInfo.getCompanyAddr(), Field.Store.YES)); document.add(new TextField("companyInfo", jobInfo.getCompanyInfo(), Field.Store.YES)); document.add(new TextField("jobName", jobInfo.getJobName(), Field.Store.YES)); document.add(new TextField("jobAddr", jobInfo.getJobAddr(), Field.Store.YES)); document.add(new TextField("jobInfo", jobInfo.getJobInfo(), Field.Store.YES)); document.add(new LongField("salaryMin", jobInfo.getSalaryMin(), Field.Store.YES)); document.add(new LongField("salaryMax", jobInfo.getSalaryMax(), Field.Store.YES)); document.add(new StringField("url", jobInfo.getUrl(), Field.Store.YES)); // 将文档追加到索引库中 indexWriter.addDocument(document); } // 关闭资源 indexWriter.close(); System.out.println("Index was created successfully!"); } }

生成的索引目录：D:\class\index

索引 Index：

• 在 Lucene 中一个索引是放在一个文件夹中的。
• 同一文件夹中的所有的文件构成一个 Lucene 索引。

段 Segment：

• 按层次保存了从索引，一直到词的包含关系：索引 (Index) –-> 段 (segment) –-> 文档 (Document) –-> 域 (Field) –-> 词 (Term)。
• 也即此索引包含了那些段，每个段包含了那些文档，每个文档包含了哪些域，每个域包含了哪些词。
• 一个索引可以包含多个段，段与段之间是独立的，添加新文档可以生成新的段，不同的段可以合并。
• 具有相同前缀文件的属同一个段，如 _0 。
• segments.gen 和 segments_1 是段的元数据文件，也即它们保存了段的属性信息。

D:\class\index ​ _0.cfe _0.cfs _0.si _1.cfe _1.cfs _1.si segments.gen segments_1 write.lock

Field 的特性：Document (文档) 是 Field (域) 的承载体，一个 Document 由多个 Field 组成，Field 由名称和值两部分组成，Field 的值是要索引的内容，是要搜索的内容。

• 是否分词 (tokenized) ：

是: 将 Field 的值进行分词处理，分词的目的是为了索引。如: 商品名称、商品描述。这些内容用户会通过输入关键词进行查询，由于内容多样，需要进行分词处理建立索引。 否: 不做分词处理，如: 订单编号、身份证号, 是一个整体，分词以后就失去了意义，故不需要分词。

• 是否索引 (indexed)

是: 将 Field 内容进行分词处理后得到的词 (或整体 Field 内容) 建立索引，存储到索引域。索引的目的是为了搜索。如: 商品名称, 商品描述需要分词建立索引。订单编号、身份证号作为整体建立索引。只要可能作为用户查询条件的词, 都需要索引。 ​ 否: 不索引。如: 商品图片路径，不会作为查询条件，不需要建立索引。

• 是否存储 (stored)

是: 将 Field 值保存到 Document 中。如: 商品名称, 商品价格。凡是将来在搜索结果页面展现给用户的内容，都需要存储。 ​ 否: 不存储。如: 商品描述。内容多格式大，不需要直接在搜索结果页面展现，不做存储。需要的时候可以从关系数据库取。

常用的 Field 类型：

• StringField(FieldName, FieldValue, Store.YES) - 字符串 - 不可分词 - 默认索引 - 可以开启存储 - 字符串类型 Field，不可分词，作为一个整体进行索引，如身份证号、订单编号；是否需要存储由 Store.YES 或 Store.No 决定。
• LongField(FieldName, FieldValue, Store.YES) - 数值型代表 - 默认分词 - 默认索引 - 可以开启存储 - Long 数值类型 Field 代表，默认分词并且索引，如价格；是否需要存储由 Store.YES 或 Store.No 决定。
• StoredField(FieldName, FieldValue) - 重载方法支持多种类型 - 不可分词 - 不可索引 - 默认开启存储 - 构建不同类型的 Field，不分词，不索引，要存储，如商品图片路径。
• TextField(FieldName, FieldValue, Store.NO) - 文本类型 - 默认分词 - 默认索引 - 可以开启存储 - 文本类型 Field，默认分词并且索引，是否需要存储由 Store.YES 或 Store.No 决定。

查询索引

com.renda.LuceneDemoApplicationTests

@RunWith(SpringRunner.class) @SpringBootTest public class LuceneDemoApplicationTests { ​ @Autowired private JobInfoService jobInfoService; ​ ... ​ @Test public void query() throws Exception { // 1.指定索引文件的存储位置，索引具体的表现形式就是一组有规则的文件 Directory directory = FSDirectory.open(new File("E:/class/index")); // 2.IndexReader 对象 IndexReader indexReader = DirectoryReader.open(directory); // 3.创建查询对象，IndexSearcher IndexSearcher indexSearcher = new IndexSearcher(indexReader); // 使用 term, 查询公司名称中包含"北京"的所有的文档对象 Query query = new TermQuery(new Term("companyName", "北京")); TopDocs topDocs = indexSearcher.search(query, 100); // 获得符合查询条件的文档数 int totalHits = topDocs.totalHits; System.out.println("符合条件的文档数：" totalHits); // 获得命中的文档 ScoreDoc封装了文档id信息 ScoreDoc[] scoreDocs = topDocs.scoreDocs; for (ScoreDoc scoreDoc : scoreDocs) { // 文档 id int docId = scoreDoc.doc; // 通过文档 id 获得文档对象 Document doc = indexSearcher.doc(docId); System.out.println("id:" doc.get("id")); System.out.println("companyName:" doc.get("companyName")); System.out.println("companyAddr:" doc.get("companyAddr")); System.out.println("companyInfo:" doc.get("companyInfo")); System.out.println("jobName:" doc.get("jobName")); System.out.println("jobInfo:" doc.get("jobInfo")); System.out.println("*******************************************"); } // 资源释放 indexReader.close(); } ​ }

这里需要使用可以合理分词的分词器，否则中文会一个字一个字地分词，其中最有名的中文分词器是 IKAnalyzer 分词器。

中文分词器的使用

第一步：导入依赖。

<!-- IK 中文分词器 --> <dependency> <groupId>com.janeluo</groupId> <artifactId>ikanalyzer</artifactId> <version>2012_u6</version> </dependency>

第二步：根据需求，可以添加配置文件放入到 resources 文件夹中（可以在配置文件额外加扩展词典和停止词典）。

IKAnalyzer.cfg.xml stopword.dic

第三步：创建索引时使用 IKanalyzer。

Analyzer analyzer = new IKAnalyzer();

考虑一个问题：一个大型网站中的索引数据会很庞大的，所以使用 Lucene 这种原生的写代码的方式就不合适了，所以需要借助一个成熟的项目或软件来实现，目前比较有名是 solr 和 ElasticSearch。

想了解更多，欢迎关注我的Renda_Zhang

,