自己动手写搜索引擎_制作简单的搜索引擎

一、项目背景

搜索引擎是现代设备中被广泛利用的一种系统软件，诸如百度、谷歌、搜索、bing等，或者抖音、快手、b站、小红书，甚至软件应用市场，Windows（操作系统）中的各类提供搜索功能的背后都有搜索引擎的影子。

二、使用技术

Spring + SpringMVC + Mybatis

Spring 负责提供：IoC、AOP

SpringMVC 负责提供：Web 业务处理

Mybatis 负责提供：方便 SQL 处理

三、项目功能

根据用户检索的内容，把检索到的相关信息展现给用户。

四、整体逻辑图

五、具体实现

1.基本流程（用户角度）：

用户输入搜索词（一个词或者多个词），在已有文档中，找到文档包含这些词的所有文档信息，再给出搜索后的列表。

2.设计

（1）初步想法（不可行）

首先，我们可以分析到，这实际上就是需要一个文档表，里面记录他的 id、标题、内容。然后在数据库中查找：select * from 文档表 where 标题 like ‘%搜索词%’ or 内容 like ‘%搜索词%’

但我们不使用这种方式（SQL），因为上述 SQL 的查找性能非常差。

文档个数记为 m，文档的平均长度（标题 + 内容）记为 n。O(m*n)。

现实中，m 非常大（几百亿篇文档），所以从性能上这个方案不可行。

（2）可实行的方法

使用倒排索引（inverted index）

倒排索引的大概结构：key-value 形式。key：词，value：词出现在哪些文档中。

①提前构造好倒排索引，倒排索引中有 id、单词、这个单词对应的文章编号、这个单词的权重。

②当我们比如说去搜索 “list” 这个单词的时候，根据倒排索引，我们可以找到这个单词出现在哪些文档中，根据文档的编号，取出对应的文档内容。

③我们再维护一个正排索引，这里面有 docid（文章的编号）、文章标题、文章的 URL、文章的内容

④当我们根据倒排索引搜索到单词对应的文章id时，比如只取前 20 篇文章，那我们就只需要进行 20 次正排索引查找即可。

补充：文档是什么文档不重要，可以是 html、pdf、图片、视频等等。

我们经常用到的搜索引擎（百度、搜狗），他背后的数据获取一般使用爬虫自动在互联网上搜集信息，将所有内容爬成文档下来，然后进行检索和排序等操作。

我们这个项目只针对 JDK API 文档库中的 html 做搜索

（3）构建两大模块

3.构建索引模块

不需要使用 web 功能，只需要执行一次

我们写一个 Indexer 类（indexer/command/Indexer），这是：构建索引的模块，是整个程序的逻辑入口。@Slf4j ——添加 Spring 日志的使用 @Component —— 注册成 Spring 的 bean

我们让这个类实现 CommandLineRunner 接口。

@Component public class Indexer implements CommandLineRunner { @Override public void run(String... args) throws Exception { log.info("这里的整个程序的逻辑入口"); } }

知识补充：

CommandLineRunner 接口：

Spring boot的CommandLineRunner接口主要用于实现在应用初始化后，去执行一段代码块逻辑，这段初始化代码在整个应用生命周期内只会执行一次。

使用CommandLineRunner接口和@Component注解一起使用

为什么要使用CommandLineRunner接口

实现在应用启动后，去执行相关代码逻辑，且只会执行一次；

spring batch批量处理框架依赖这些执行器去触发执行任务；

我们可以在run()方法里使用任何依赖，因为它们已经初始化好了；

构造索引的大概步骤：

1.扫描文档目录下的所有文档：目录遍历的过程 FileScanner

// 1. 扫描出来所有的 html 文件
        log.debug("开始扫描目录，找出所有的 html 文件。{}", properties.getDocRootPath());
        List<File> htmlFileList = fileScanner.scanFile(properties.getDocRootPath(), file -> {
            return file.isFile() && file.getName().endsWith(".html");
        });
        log.debug("扫描目录结束，一共得到 {} 个文件。", htmlFileList.size());

我们把这个类注册成 Spring bean —— @Service

知识补充：

1、@Service注解是标注在实现类上的，因为 @Service 是把 spring 容器中的 bean 进行实例化，也就是等同于 new操作，只有实现类是可以进行 new 实例化的，而接口则不能，所以是加在实现类上的。

2、要说明@Service注解的使用，就得说一下我们经常在 spring 配置文件applicationContext.xml中看到如下图中的配置：
 <context:component-scan base-package="com.study.persistent" />
在applicationContext.xml配置文件中加上这一行以后，将自动扫描指定路径下的包，如果一个类带了 @Service注解，将自动注册到 Spring容器，不需要再在applicationContext.xml配置文件中定义 bean 了，类似的还包括 @Component、@Repository、@Controller。

具体在 indexer.util.FileScanner 中完成。

以 rootPath 作为根目录，开始进行文件的扫描，把所有符合条件的 File 对象，作为结果，以 List 形式返回（把这个过程想象成一棵树）
针对目录树进行遍历，深度优先 or 广度优先即可，确保每个文件都没遍历到即可，我们这里采用深度优先遍历，使用递归完成

1. 先通过目录，得到该目录下的孩子文件有哪些

File[] files = directoryFile.listFiles();

2. 遍历每个文件，检查是否符合条件

for (File file : files) { // 通过 filter.accept(file) 的返回值，判断是否符合条件 if (filter.accept(file)) { // 说明符合条件，需要把该文件加入到结果 List 中 resultList.add(file); } }

3. 遍历每个文件，针对是目录的情况，继续深度优先遍历（递归）

for (File file : files) { if (file.isDirectory()) { traversal(file, filter, resultList); } }

2.针对每一篇文档进行分析、处理

得到文档的标题（这里就把他的文件名作为标题）、最终访问的 URL（实际上是一个相对路径）、文档下的内容（IO 读操作）

标题：

URL：

进行分词后才能得到倒排索引中保存的key，也就是你想要搜索的词。

这个分词引入第三方库来做NLP

// 2. 针对每个 html 文件，得到其 标题、URL、正文信息，把这些信息封装成一个对象（文档 Document）
        File rootFile = new File(properties.getDocRootPath());
        List<Document> documentList = htmlFileList.stream()
                .parallel()         // 【注意】由于我们使用了 Stream 用法，所以，可以通过添加 .parallel()，使得整个操作变成并行，利用多核增加运行速度
                .map(file -> new Document(file, properties.getUrlPrefix(), rootFile))
                .collect(Collectors.toList());
        log.debug("构建文档完毕，一共 {} 篇文档", documentList.size());

具体在 indexer.model.Document 中完成

扫描出来所有的 html 文件（需要依赖FileScanner 对象，构造方法注入的方式，让 Spring 容器，注入 FileScanner 对象进来）

这里最好，把要扫描的文件路径放在配置文件（src/main/resources/application.yml）中，这样有利于以后修改会更方便

List<File> htmlFileList = fileScanner.scanFile(properties.getDocRootPath(), file -> {
            return file.isFile() && file.getName().endsWith(".html");
        });

searcher: indexer: doc-root-path: E:\java程序\docs\api url-prefix: https://docs.oracle.com/javase/8/docs/api/

之后用 properties 的方式来读取

package com.lingqi.searcher.indexer.properties; import lombok.*; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; @Component // 是注册到 Spring 的一个 bean @ConfigurationProperties("searcher.indexer") @Data // = @Getter + @Setter + @ToString + @EqualsAndHashCode public class IndexerProperties { // 对应 application.yml 配置下的 searcher.indexer.doc-root-path private String docRootPath; }

针对每个 html 文件，得到其标题、URL、正文信息，把这些信息封装成一个对象（文档 Document——model/Document)

标题：从文件名中，将 .html 后缀去掉，剩余的看作标题

    private String parseTitle(File file) {
        // 从文件名中，将 .html 后缀去掉，剩余的看作标题
        String name = file.getName();
        String suffix = ".html";
        return name.substring(0, name.length() - suffix.length());
    }

URL：需要得到一个相对路径，file 相对于 rootFile 的相对路径。

比如：rootFile 是 E:\java程序\docs\api 。

file 是 E:\java程序\docs\api\javax\sql\DataSource.html

则相对路径就是：javax\sql\DataSource.html

把所有反斜杠(\) 变成正斜杠(/)

最终得到 java/sql/DataSource.html

正文信息：

随便打开一篇文档：

我们需要做的是：

1.<script…> … </sprict> 这是我们不要的

2.所有标签都不要：<p>Hello</p><p>World</p> 我们要的只是 Hello World

3.所有的换行符替换成’ ‘（空格）

我们只保留纯文本内容，用来做分词

因此使用正则表达式完成上述工作

知识补充：

正则表达式

” . ” 匹配任意字符，匹配多少个需要根据后续字符来判断，默认就是一个

” /s ” 匹配任意空格，包括” “，”\t”，”\r\n”，”\r”，”\n”

” /d ” 匹配任意数字（只有一位）0-9

” a+ ” 匹配 “a”，出现的次数 >= 1次

” a* ” 匹配 “a”，出现的次数 >= 0次

” .+ ” 匹配任意字符，出现次数 >= 1 次

” .* ” 匹配任意字符，出现次数 >= 0 次

” ? ” 可选的

先把文章一行一行全部读取到 StringBuilder 中，再把 StringBuilder 中不需要的那些内容进行删除或者替换

return contentBuilder.toString() // 首先去掉 <script ...>...</script> .replaceAll("<script.*?>.*?</script>", " ") // 去掉标签 .replaceAll("<.*?>", " ") // 把最后多出来的空格删除掉 .replaceAll("\\s+", " ") .trim();

3.进行正排索引的保存

拿到分词后，我们就知道每一篇文档的标题、URL、内容、标题和内容的每个词

利用上述信息就可以构建索引了。正排索引、倒排索引

正排索引有1W条数据，倒排索引有600W条。如果一条一条插入，需要循环600W次才可以插入完成。但我们可以设置成一次插入1000条数据，这样只需要循环6000次就可以了。

因此我们只需要两张表存在数据库中：

正排索引表（docid-pk、title、url、content）整体数量级不大，只有1W条，但是每一条比较大（content大）——批量插入的时候，每次记录不用太多（每次插入 10 条）

倒排索引（id-pk、word、docid、weight）整体数量级较大，有600W条，每一条的记录比较小——批量插入的时候，每次记录多插入一些（每次插入 1W条）

我们docid的生成方式利用 MySQL 的表中的自增机制作为docid

MySQL 批量插入语法：

insert into forward_indexs(title,url,content) values

(‘1′,’2′,’3’),

(‘4′,’5′,’6’),

(‘7′,’8′,’9’)；

既然需要批量插入，我就要用到 mybatis 的动态SQL特性

遍历 collection=”list”，其中，下标保存在 index （index=“index”），其中遍历时的每一项保存在item（item=“item”）

写sql的：

@Repository // 注册 Spring bean @Mapper // 是一个 Mybatis 管理的 Mapper public interface IndexDatabaseMapper { // 正排 void batchInsertForwardIndexes(@Param("list") List<Document> documentList); //倒排 void batchInsertInvertedIndexes(@Param("list") List<InvertedRecord> recordList); }

准备一个xml

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.lingqi.searcher.indexer.mapper.IndexDatabaseMapper">

在配置文件中也加入。在 Spring 的配置文件中，指定 mybatis 查找 mapper xml 文件的路径

classpath：代表从 src/main/resources 下进行查找（这实际上是错误的理解，暂且可以这么简单理解关系不大）

index-mapper.xml文件中设置的

实际上对应的就是我们用于写sql 的类 IndexDatabaseMapper。

因为我们这里实际上就是一个插入，所以是 insert 语句，因此我们在index-mapper.xml中写入insert语句

sql语句（写在index-mapper.xml中）：

最终的到的 sql 就是拼接好的sql。

<insert id="batchInsertForwardIndexes" useGeneratedKeys="true" keyProperty="docId" keyColumn="docid"> insert into forward_indexes (title, url, content) values <!-- 一共有多少条记录，得根据用户传入的参数来决定，所以这里采用动态 SQL 特性 --> <foreach collection="list" item="doc" separator=", "> (#{doc.title}, #{doc.url}, #{doc.content}) </foreach> </insert>

我们在 indexer/core/IndexManager 中完成插入

批量生成、保存正排索引

 indexManager.saveForwardIndexesConcurrent(documentList);

单线程版本：

1. 批量插入时，每次插入多少条记录（由于每条记录比较大，所以这里使用 10 条就够了）

int batchSize = 10;

2. 一共需要执行多少次 SQL？向上取整(documentList.size() / batchSize)

int listSize = documentList.size(); int times = (int) Math.ceil(1.0 * listSize / batchSize); // ceil(天花板): 向上取整

3. 开始分批次插入

for (int i = 0; i < listSize; i += batchSize) { // 从 documentList 中截取这批要插入的 文档列表（使用 List.subList(int from, int to) int from = i; int to = Integer.min(from + batchSize, listSize); List<Document> subList = documentList.subList(from, to); // 针对这个 subList 做批量插入 mapper.batchInsertForwardIndexes(subList); }

多线程版本：

前面两步和单线程版本相同，在第三步循环插入中，把他们放到任务中去执行

我们需要一个线程池，定义在 indexer/config/AppConfig 中：

@Configuration public class AppConfig { @Bean public ExecutorService executorService() { ThreadPoolExecutor executor = new ThreadPoolExecutor( 8, 20, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5000), (Runnable task) -> { Thread thread = new Thread(task); thread.setName("批量插入线程"); return thread; }, new ThreadPoolExecutor.AbortPolicy() ); return executor; } }

@Timing("构建 + 保存正排索引 —— 多线程版本") @SneakyThrows public void saveForwardIndexesConcurrent(List<Document> documentList) { // 1. 批量插入时，每次插入多少条记录（由于每条记录比较大，所以这里使用 10 条就够了） int batchSize = 10; // 2. 一共需要执行多少次 SQL？ 向上取整(documentList.size() / batchSize) int listSize = documentList.size(); int times = (int) Math.ceil(1.0 * listSize / batchSize); // ceil(天花板): 向上取整 log.debug("一共需要 {} 批任务。", times); CountDownLatch latch = new CountDownLatch(times); // 统计每个线程的完全情况，初始值是 times(一共多少批) // 3. 开始分批次插入 for (int i = 0; i < listSize; i += batchSize) { // 从 documentList 中截取这批要插入的 文档列表（使用 List.subList(int from, int to) int from = i; int to = Integer.min(from + batchSize, listSize); Runnable task = () -> { // 内部类 / lambda 表达式里如果用到了外部变量，外部变量必须的 final（或者隐式 final 的变量） List<Document> subList = documentList.subList(from, to); // 针对这个 subList 做批量插入 mapper.batchInsertForwardIndexes(subList); latch.countDown(); // 每次任务完成之后，countDown()，让 latch 的个数减一 }; executorService.submit(task); // 主线程只负责把一批批的任务提交到线程池，具体的插入工作，由线程池中的线程完成 } // 4. 循环结束，只意味着主线程把任务提交完成了，但任务有没有做完是不知道的 // 主线程等在 latch 上，只到 latch 的个数变成 0，也就是所有任务都已经执行完了 latch.await(); }

4.倒排索引的生成和保存

针对文档进行分词，并且分别计算每个词的权重

在倒排索引中，我们需要进行分词、处理词的权重问题，这里我们统一放到 Document 类中处理

对于每个 Document 进行分词处理，需要第三方库的支持

在pom.xml 中添加依赖，它支持中文和英文分词

<dependency> <groupId>org.ansj</groupId> <artifactId>ansj_seg</artifactId> <version>5.1.6</version> </dependency>

用法示例：

public void Ansj() { Result result = ToAnalysis.parse("我爱北京天安门，天安门上太阳升。"); List<Term> termList = result.getTerms(); for (Term term : termList) { System.out.print(term.getName() + ", "); System.out.print(term.getNatureStr() + ", "); System.out.println(term.getRealName()); } }

权重的设计

比如说用户要查找 “list” 这个单词，找到了好几篇文档都含有 “list” ，那么哪篇文章显示在前，哪篇在后？

第一种：按照 docid 从小到大去显示：1，2，13，25，27，34，67，….

第二种：按照匹配程度去显示：比如说：13号的 list 在标题出现了10次，在正文出现了 100 次；1号的 list 在标题出现了1次，在正文出现了 1次。那么13号文档更匹配，所以排名要在1号的前面。

第三种：更加智能的计算：根据用户的点击数、点击频率、文档的更新频率、作者的维权程度、文档来源的权威程度等信息更精准的计算。

第四种：谁给的钱多，谁靠前。

我们这里采用的是第二种方法。

所以，我们针对每个单词 —> 每篇文档，都伴随一个 weight（权重），根据这个权重去排序（d倒序）

权重的计算：10 * 单词出现在标题的次数 + 1 * 单词出现在正文中的次数。

这里我们使用map 来维护，key就是某个词，value就是该词对应的权重

标题 | 分词

List<String> wordInTitle = ToAnalysis.parse(title) //对title进行分词 .getTerms() .stream() .parallel() .map(Term::getName) .filter(s -> !ignoredWordSet.contains(s)) .collect(Collectors.toList());

标题 | 出现次数

Map<String, Integer> titleWordCount = new HashMap<>(); for (String word : wordInTitle) { int count = titleWordCount.getOrDefault(word, 0); titleWordCount.put(word, count + 1); }

正文 | 分词

List<String> wordInContent = ToAnalysis.parse(content) .getTerms() .stream() .parallel() .map(Term::getName) .collect(Collectors.toList());

正文 | 出现次数

 Map<String, Integer> contentWordCount = new HashMap<>(); for (String word : wordInContent) { int count = contentWordCount.getOrDefault(word, 0); contentWordCount.put(word, count + 1); }

计算权重值

用map，某个词对应的权重是多少

Map<String, Integer> wordToWeight = new HashMap<>();

1. 先计算出有哪些词，不重复

就是使用set ，把所有的标题中的词初始化就都放入，然后再把所有正文的词也放入，set 中的元素是不能重复的。

2.遍历set中的元素，看这个词在标题中出现多少次，在正文中出现多少次，最后计算权重：

10 * 单词出现在标题的次数 + 1 * 单词出现在正文中的次数。

3.最后把该词和他的权重放到map中，最后返回这个map即可。

上述准备工作处理完成之后，我们开始进行倒排索引的生成和保护（在IndexManager类中）

1.定义一个类，里面的对象用来映射 inverted_indexes 表中的一条记录

// 这个对象映射 inverted_indexes 表中的一条记录（我们不关心表中的 id，就不写 id 了） @Data public class InvertedRecord { private String word; private int docId; private int weight; public InvertedRecord(String word, int docId, int weight) { this.word = word; this.docId = docId; this.weight = weight; } }

2.执行 sql 在index-mapper.xml 中

<!-- 不关心自增 id --> <insert id="batchInsertInvertedIndexes"> insert into inverted_indexes (word, docid, weight) values <foreach collection="list" item="record" separator=", "> (#{record.word}, #{record.docId}, #{record.weight}) </foreach> </insert>

单线程版本：

3.设置批量插入时，最多 10000 条

int batchSize = 10000;

4.准备一个List （recordList），里面是 InvertedRecord 类型的，然后根据分词不断向里面放入，放够10000条了就插入一次。（也就是本批次要插入的数据）

5.遍历document 文件，调用 document.segWordAndCalcWeight() 方法，拿到分词结果。

6.遍历每个单词，得到单词和权重，再得到他的docid。构建出这三个后把他们放入recordList中。

7.如果 recordList.size() == batchSize，说明够一次插入了，够10000条了，就进行插入，插入完成之后清空 recordList。然后就会重新循环再走。

8. recordList 还剩一些，之前放进来，但还不够 batchSize 个的，所以最后再批量插入一次。执行完成之后就可以认为是所有插入都完成了。

多线程版本：

一次插入10000条，一次处理50篇文档

int batchSize = 10000; // 批量插入时，最多 10000 条 int groupSize = 50;

提前把线程一批一批分好，分好之后交给线程去提交。

 static class InvertedInsertTask implements Runnable { private final CountDownLatch latch; private final int batchSize; private final List<Document> documentList; private final IndexDatabaseMapper mapper; InvertedInsertTask(CountDownLatch latch, int batchSize, List<Document> documentList, IndexDatabaseMapper mapper) { this.latch = latch; this.batchSize = batchSize; this.documentList = documentList; this.mapper = mapper; } @Override public void run() { List<InvertedRecord> recordList = new ArrayList<>(); // 放这批要插入的数据 for (Document document : documentList) { Map<String, Integer> wordToWeight = document.segWordAndCalcWeight(); for (Map.Entry<String, Integer> entry : wordToWeight.entrySet()) { String word = entry.getKey(); int docId = document.getDocId(); int weight = entry.getValue(); InvertedRecord record = new InvertedRecord(word, docId, weight); recordList.add(record); // 如果 recordList.size() == batchSize，说明够一次插入了 if (recordList.size() == batchSize) { mapper.batchInsertInvertedIndexes(recordList); // 批量插入 recordList.clear(); // 清空 list，视为让 list.size() = 0 } } } // recordList 还剩一些，之前放进来，但还不够 batchSize 个的，所以最后再批量插入一次 mapper.batchInsertInvertedIndexes(recordList); // 批量插入 recordList.clear(); latch.countDown(); } } @Timing("构建 + 保存倒排索引 —— 多线程版本") @SneakyThrows public void saveInvertedIndexesConcurrent(List<Document> documentList) { int batchSize = 10000; // 批量插入时，最多 10000 条 int groupSize = 50; int listSize = documentList.size(); int times = (int) Math.ceil(listSize * 1.0 / groupSize); CountDownLatch latch = new CountDownLatch(times); for (int i = 0; i < listSize; i += groupSize) { int from = i; int to = Integer.min(from + groupSize, listSize); List<Document> subList = documentList.subList(from, to); Runnable task = new InvertedInsertTask(latch, batchSize, subList, mapper); executorService.submit(task); } latch.await(); }

4.搜索模块

依赖索引构建完成之后才能进行，需要 web 功能

使用SpringMVC 实现了Web服务

只针对一个词进行搜索

select docid,weight from inverted_indexes where word = ‘list’ order by weight desc;

select * from forward_indexes where docid in (…); 这样排出来是无序的

需要根据 weight 重新再进行一次排序

把上述合并成一条联表 SQL

select ii.docid,title,url,content,from inverted_indexes ii

join forward_indexes fi on ii.docid = fi.docid

where word = ‘list’

order by weight desc; 这样排完之后是有序的

前端传过来这个词，根据词去倒排索引 + 正排索引中搜索，得到文档列表（可以做分页）

查询很慢，只是一个词就需要1.8秒，如果搜索的多了，时间更久，没有人愿意等待这么久

这里我们使用向表中新建索引来解决这个问题（针对 word 列去建索引）

建索引的过程，就是把 word 列作为 key，docid 作为 value，新建一棵搜索树（B+树）

从 key 查找 value，则时间复杂度变成O(log(n)) 21次远远小于O(n) 200W 次

建索引的速度很慢，而且会导致数据插入很慢，所以，在表中的数据已经插入完成的情况下，再添加索引

给 word 和 weight 都添加索引，先用word 查，查完之后利用 weight 我们可以利用索引直接进行排序。

建立索引之后，查询只需要0.2秒

搜索树的 key：索引中的字段 word + weight（复合索引）

左边是word，右边weight

左边可以比较大小：索引的命中规则遵守靠左原则，select … from 表 where word = ‘ … ‘ 可以用上索引

随后按weight 进行排序，因为 key 里就有 weight ，所以 key 本身就是按照 weight 排序好的（搜索树的有序原则）

不加索引的情况下查询慢（因为排序和查询都没有用到索引）。

针对 word 加索引，性能有所提升（查询使用了索引，排序没有用，相对快，但还不够快）。

针对word 和 weight ，使用索引，性能明显提升（查询和排序都使用了索引，非常快）

1.动态资源 /web， qurty=… 必须填的 page=…选填，但必须是数字

写一个Controller ，叫做 SearchController ，通过 @Controller 注解修饰，代表这是一个控制器。实现 @GetMapping(“/web”)，查询的url 是 /web。里面 return “search”;最后会渲染 search.html 这个模板

@GetMapping 注解

@GetMapping是一个组合注解，等价于@RequestMapping (method = RequestMethod.GET)，它将HTTP Get请求映射到特定的处理方法上。

2.之后就需要进行查询，定义一个 Document 类模板，其中需要 title、url、content。

3.这些东西需要根据数据库去查，因此我们需要一个接口——SearchMapper，用@Repository @Mapper 这两个注解来修饰。里面返回的是一组 Document 类型的 list

@Repository @Mapper public interface SearchMapper { List<Document> query( @Param("word") String word, @Param("limit") int limit, @Param("offset") int offset); List<DocumentWightWeight> queryWithWeight( @Param("word") String word, @Param("limit") int limit, @Param("offset") int offset ); }

@param 注解

@param 标签提供了对某个函数的参数的各项说明，包括参数名、参数数据类型、描述等。

@param 标签要求您指定要描述参数的名称。

您还可以包含参数的数据类型，使用大括号括起来，和参数的描述。

参数类型可以是一个内置的JavaScript类型，如 string 或 Object ，或是你代码中另一个标识符的 JSDoc namepath（名称路径）。

如果你已经在这namepath（名称路径）上为标识符添加了描述，JSDoc会自动链接到该标识符的文档。

配置文件：

spring: main: log-startup-info: false banner-mode: off datasource: url: jdbc:mysql://127.0.0.1:3306/searcher_refactor?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai username: root password:  mybatis: mapper-locations: classpath:mapper/search-mapper.xml logging: level: com.lingqi.searcher.web: debug

具体的查询语句，这里使用 mybatis ，在 search-mapper.xml 语句中写具体的查询语句

<!-- #{...} 会添加引号上去; ${...} 不会添加引号 --> <select id="query" resultMap="DocumentResultMap"> select ii.docid, title, url, content from inverted_indexes ii join forward_indexes fi on ii.docid = fi.docid where word = #{word} order by weight desc limit ${limit} offset ${offset} </select>

4. 在 SearchController 中写具体步骤

得到查询的词是哪个词（query）参数的合法性检查 + 处理

if (query == null) { log.debug("query 为 null，重定向到首页"); return "redirect:/"; } query = query.trim().toLowerCase(); if (query.isEmpty()) { log.debug("query 为空字符串，重定向到首页"); return "redirect:/"; }

分词

List<String> queryList = ToAnalysis.parse(query) .getTerms() .stream() .map(Term::getName) .collect(Collectors.toList());

如果分词后，queryList 为空，也就是分词后一个词都没有，那么证明没有找到这个词，让他重定向到首页
处理分页的问题（得到page，计算出limit + offset）

int limit = 20; int offset = 0; int page = 1; if (pageString != null) { pageString = pageString.trim(); try { page = Integer.parseInt(pageString); if (page <= 0) { page = 1; } limit = page * 20; } catch (NumberFormatException ignored) {} }

执行SQL进行查询
将数据添加到 model 中，是为了在渲染模板的时候用到（这里使用了SpringMVC的模板渲染技术（ViewResover），这里具体使用的是 Thymeleaf）
Model 添加渲染需要的数据：query、docList、page

model.addAttribute("query", query); model.addAttribute("docList", documentList); model.addAttribute("page", page);

指定使用哪个模板来进行渲染 return “search” 对应 resources/templates/search.html

5.搜索出来之后，展示基本内容部分

首先我们可以拿到这个文本的内容，我们可以前面截取120 个字，后面截取120 个字。

public Document build(List<String> queryList, Document doc) { // 找到 content 中包含关键字的位置 // query = "list" // content = "..... hello list go come do ...." // desc = "hello <i>list</i> go com..." String content = doc.getContent().toLowerCase(); String word = ""; int i = -1; for (String query : queryList) { i = content.indexOf(query); if (i != -1) { word = query; break; } } if (i == -1) { // 这里中情况如果出现了，说明咱的倒排索引建立的有问题 log.error("docId = {} 中不包含 {}", doc.getDocId(), queryList); throw new RuntimeException(); } // 前面截 120 个字，后边截 120 个字 int from = i - 120; if (from < 0) { // 说明前面不够 120 个字了 from = 0; } int to = i + 120; if (to > content.length()) { // 说明后面不够 120 个字了 to = content.length(); } String desc = content.substring(from, to); // 这里添加i标签，可以使这个单词高亮显示 desc = desc.replace(word, "<i>" + word + "</i>"); doc.setDesc(desc); return doc; }

针对多个词进行搜索

和单词搜索的区别就是权重值需要重新计算

多次中，就需要有一个权重值聚合的问题

docid 相同的，weight=sum（w1,w2,w3）

docid=1 weight = 13 + 7 + 1

docid=2 weight = 22

把实际业务抽象成如下的简单题：给定3个有序数组（按照权重从大到排序），最终结果的权重（sum=w1+w2+w3|docid相同），给出第 x 到第 y 个元素

假如需要【0，20），必须把每个【0，20）找出，聚合权重，重新排序，算出结果中的【0，20）

假如需要【20，40），必须把每个【0，40）找出，聚合权重，重新排序，算出结果中的【20，40）

假如需要【40，60），必须把每个【0，60）找出，聚合权重，重新排序，算出结果中的【40，60）

如果数据量太大，这种找法是不可能的，内存空间可能不足，时间效率也很低

因此实际中我们会舍弃他的准确性，比如说某次考试，前1000名学生，各自的排名多少是非常重要的，不能出错。后1000名同学，排名略有错误，其实也不重要。实际上上就是牺牲正确性来换取性能。

结果必须重新计算，所以没办法使用MySQL帮我们排序了

首先我们先对所有的词进行查找，查找出来先放到 totalList 中

List<DocumentWightWeight> totalList = new ArrayList<>(); for (String s : queryList) { List<DocumentWightWeight> documentList = mapper.queryWithWeight(s, limit, offset); totalList.addAll(documentList); }

针对所有文档列表，做权重聚合工作

维护:docId -> document 的 map

1.我们遍历 totalList 针对每一个docid 我们往里面放。遇到重复的，不断累加。

2.此时我们就有了每个单词对应的权重了，这放在 documentMap 中，我们需要对这个权重进行一个排序，首要要拿到这些权重，放在 Collection 中

3.但 Collection 没有排序这个概念（只有线性结构才有排序的概念），所以我们需要一个 List

4. 按照 weight 的从大到小排序

Collections.sort(list, (item1, item2) -> { return item2.weight - item1.weight; });

5. 从 list 中把分页区间取出来

int from = (page - 1) * 20; int to = from + 20; List<DocumentWightWeight> subList = list.subList(from, to); List<Document> documentList = subList.stream() .map(DocumentWightWeight::toDocument) .collect(Collectors.toList());

具体的查询语句，这里使用 mybatis ，在 search-mapper.xml 语句中写具体的查询语句：

 <select id="queryWithWeight" resultMap="DocumentWithWeightResultMap"> select ii.docid, title, url, content, weight from inverted_indexes ii join forward_indexes fi on ii.docid = fi.docid where word = #{word} order by weight desc limit ${limit} offset ${offset} </select>

完整代码：

构造索引：搜索引擎_构建索引模块: 写一个搜索引擎的项目

搜索模块：https://gitee.com/hlingqi/search-engine-search-module

项目测试：[测试] 搜索引擎的相关测试_我要敲代码6400的博客-CSDN博客

今天的文章
自己动手写搜索引擎_制作简单的搜索引擎分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/80264.html

自己动手写搜索引擎_制作简单的搜索引擎

一、项目背景

二、使用技术

三、项目功能

四、整体逻辑图

五、具体实现

1.基本流程（用户角度）：

2.设计

（1）初步想法（不可行）

（2）可实行的方法

（3）构建两大模块

3.构建索引模块

知识补充：

CommandLineRunner 接口：

为什么要使用CommandLineRunner接口

构造索引的大概步骤：

1.扫描文档目录下的所有文档：目录遍历的过程 FileScanner

知识补充：

具体在 indexer.util.FileScanner 中完成。

2.针对每一篇文档进行分析、处理

具体在 indexer.model.Document 中完成

知识补充：

3.进行正排索引的保存

4.倒排索引的生成和保存

4.搜索模块

只针对一个词进行搜索

@GetMapping 注解

@param 注解

针对多个词进行搜索

相关推荐

发表回复