devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

项目实战--文档搜索引擎

作者：Gausst松鼠会 | 2024-06-17 15:59:01

赞

踩

项目实战--文档搜索引擎

在我们的学习过程中，会阅读很多的文档，例如jdk的API文档，但是在这样的大型文档中，如果没有搜索功能，我们是很难找到我们想查阅的内容的，于是我们可以实现一个搜索引擎来帮助我们阅读文档。

1. 实现思路

1.1 获取文档 

第一点，要搜索指定内容，首先要先获取到内容，我们以实现Java API文档搜索引擎来说，我们要先获取到Java的API文档，我们可以在Oracle的官网找到：Overview (Java SE 17 & JDK 17) (oracle.com)

Oracle官网提供了在线和离线两种文档，我们可以下载离线文档，通过离线文档来实现。

离线文档下载地址：Java 开发工具包 17 文档 (oracle.com)

下载好后解压缩，在 jdk-17.0.11_doc-all\docs\api 目录和子目录下的所有html文件就是所有的api文档

1.2 通过关键词查询

获取到了文档，我们还需要能够通过关键词定位到相关的文档，这里需要用到索引 

  • 正排索引： 给每个文档引入一个文档id，文档id是每个文档的身份标识，不能重复，通过文档id快速获取到对应文档就叫正排索引。
  • 倒排索引：通过一个或几个关键词查询到与之有关的所有文档的文档id，这种方式就叫到排索引。

于是要实现关键词查询，我们只需要给下载好的Java API文档实现一个正排索引和倒排索引，通过到排索引查询到相关的文档的id，要查看某个文档时再用查询到的id使用正排索引查询到对应文档。

1.3 如何返回查询到的结果

查询到对应的api文档之后，如何返回给用户，这里我的想法是返回一个在线文档的url，当用户想要查看某个文档时，返回Oracle官方的在线文档对应的页面的url。

那么此种方式就需要我们把在线文档的url和离线文档联系起来：

我们观察某个文档的url和在线文档的本地路径：

在线文档：

离线文档： 

 

 我们发现相同api文档的在线版本的url和离线版本路径，它们的后半部分是相同的，所有我们只需要通过一些字符串拼接操作，就可以通过离线文档的文件路径得到在线文档的url。

1.4 模块划分

通过上面的叙述，我们可以对我们的程序进行一个模块划分：

  • 索引模块：扫描并解析所有的本地文档并构建出索引；提供一些API实现查正排/到排的功能
  • 搜索模块：调用索引模块通过关键词查询到相关文档信息，并处理后返回
  • Web模块：实现一个简单的Web程序，能通过网页的形式和用户交互

2. 索引模块实现

创建一个Spring项目

2.1 实现Parser类 

实现一个Parser类用于扫描并解析本地的离线文档：

  1. package org.example.docsearcher.config;
  2.  
  3. @Configuration
  4. public class Parser {
  5.     //指定文档文件的路径
  6.     private static final String FILE_PATH = "D:/桌面/jdk-17.0.11_doc-all/docs/api";
  7.  
  8.  
  9.     //解析文档
  10.     private void parser() {
  11.         //1.找出所有html文件
  12.         List<File> fileList = new ArrayList<>();
  13.         enumFile(FILE_PATH, fileList);
  14.  
  15.         //2.对每个HTML文件进行解析
  16.        for(File f : fileList) {
  17.            parserHTML(f);
  18.        }
  19.     }
  20.  
  21.     //枚举出所有的html文件
  22.     private void enumFile(String filePath, List<File> fileList) {
  23.  
  24.     }
  25.  
  26.     //解析出html文件的内容
  27.     private void parserHTML(File file) {
  28.  
  29.     }
  30. }

实现enumFile方法：

  1.     private void enumFile(String filePath, List<File> fileList) {
  2.         File file = new File(filePath);
  3.         //获取目录下的文件列表
  4.         File[] files = file.listFiles();
  5.         for(File f : files) {
  6.             if(f.isDirectory()) {
  7.                 //如果f是目录则递归添加文件
  8.                 enumFile(f.getAbsolutePath(), fileList);
  9.             }else if(f.getName().endsWith(".html")){
  10.                 //如果f是html文件则添加到fileList中
  11.                 fileList.add(f);
  12.             }
  13.         }
  14.     }

实现parserHTML方法：

要实现parserHTML方法我们要先理清楚，html文件中有什么和我们需要什么：

  • 标题：返回查询结果时，可以展示给用户以供选择
  • 正文：用于提取关键词构建倒排索引
  • url：用户点击时通过url跳转到对应页面
  1.     private void parserHTML(File file) {
  2.         //a.解析出标题
  3.         String title = parserTitle(file);
  4.  
  5.         //b.解析出url
  6.         String url = parserUrl(file);
  7.  
  8.         //c.解析出正文
  9.         String content = parserContent(file);
  10.  
  11.     }
  12.  
  13.     private String parserContent(File file) {
  14.         StringBuilder content = new StringBuilder();
  15.         //按字节读,这里使用BufferedReader 提高速度
  16.         try(BufferedReader bufferedReader = new BufferedReader(new FileReader(file), 1024 * 1024)) {
  17.             while(true) {
  18.                 int ch = bufferedReader.read();
  19.                 if(ch == -1) {
  20.                     //文件读完了
  21.                     break;
  22.                 }
  23.                 content.append((char)ch);
  24.             }
  25.         } catch (IOException e) {
  26.             throw new RuntimeException(e);
  27.         }
  28.         String ret = content.toString();
  29.  
  30.         //使用正则表达式替换掉js代码
  31.         ret = ret.replaceAll("<script.*?>.*?</script>", "");
  32.         //使用正则表达式替换html标签
  33.         ret = ret.replaceAll("<.*?>", "");
  34.         //把换行符和连续的多个空格替换为一个空格使内容更美观
  35.         ret = ret.replaceAll("\\s+", " ");
  36.     }
  37.  
  38.     private String parserUrl(File file) {
  39.         //拼接出在线文档对应的url
  40.         String s1 = "https://docs.oracle.com/en/java/javase/17/docs/api";
  41.         String s2 = file.getAbsolutePath().substring(FILE_PATH.length()).replace("\\", "/");
  42.         return s1 + s2;
  43.     }
  44.  
  45.     private String parserTitle(File file) {
  46.         String fileName = file.getName();
  47.         return fileName.substring(0, fileName.length() - ".html".length());
  48.     }

 注意：FileReader的read方法是每次从磁盘里读取一个字符到内存中，BuferedReader 内部带有一个缓存区，会一次把多个字符加载到缓存区中，调用read方法时会从缓存区中读取字符，减少直接访问磁盘的次数提高了速度，构造方法中的第二个参数就是设置缓冲区的大小，单位是字节

2.2 实现Index类

实现Index类用于创建索引和通过关键词和索引查询相关文档：

前排索引由文档id和文档组成，要求能够通过文档id快速查询到文档，索引我们可以使用一个List来储存前排索引，即通过数组下标当作文档id，数组的内容即为文档的信息，于是我们创建一个DocInfo类用于存储文档信息：

  1. package org.example.docsearcher.model;
  2.  
  3. import lombok.Data;
  4.  
  5. @Data
  6. public class DocInfo {
  7.     //储存一个文档的相关信息
  8.     private int docId;
  9.     private String title;
  10.     private String url;
  11.     private String content;
  12.  
  13.     public DocInfo() {
  14.  
  15.     }
  16.  
  17.     public DocInfo(String title, String url, String content) {
  18.         this.title = title;
  19.         this.url = url;
  20.         this.content = content;
  21.     }
  22. }

于是前排索引的形式就是：

List<DocInfo> forwardIndex;

后排索引要求由关键词查询到文档id，索引我们可以使用哈希表来关联关键词和文档id：

Map<String, List<Integer>> invertedIndex;

 但是只存储一个文档id无法表示不同文档和某一个关键词的相关程度，于是这里我们可以实现一个Relate类，用于存储一个关键词和一个文档直接的关联程度：

  1. package org.example.docsearcher.model;
  2.  
  3. import lombok.Data;
  4.  
  5. @Data
  6. public class Relate {
  7.     //存储某个关键词和文档的相关程度
  8.  
  9.     //关键词
  10.     private String key;
  11.     //文档id
  12.     private int docId;
  13.     //权重，该值越大说明相关性越高
  14.     private int weight;
  15.  
  16.     public Relate() {
  17.  
  18.     }
  19.  
  20.     public Relate(String key, int docId, int weight) {
  21.         this.key = key;
  22.         this.docId = docId;
  23.         this.weight = weight;
  24.     }
  25. }

这里的权重我们可以以该关键词在该文档中出现的次数来表示 

于是最后的后排索引的形式是：

Map<String, List<Relate>> invertedIndex;

Index实现： 

  1. package org.example.docsearcher.config;
  2.  
  3. @Configuration
  4. public class Index {
  5.  
  6.     //前排索引
  7.     public static List<DocInfo> forwardIndex = new ArrayList<>();
  8.     //后排索引
  9.     public static Map<String, List<Relate>> invertedIndex = new HashMap<>();
  10.  
  11.     //通过docId,在正排索引中查询文档信息
  12.     public DocInfo getDocInfoById(int docId) {
  13.         return forwardIndex.get(docId);
  14.     }
  15.  
  16.     //通过一个关键词在倒排索引中查看相关文档
  17.     public List<Relate> getDocInfoByKey(String key) {
  18.         return invertedIndex.get(key);
  19.     }
  20.  
  21.     //在索引中新增一个文档
  22.     public void addDoc(String title, String url, String content) {
  23.         //增加前排索引
  24.         DocInfo docInfo = addForward(title, url, content);
  25.  
  26.         //增加后排索引
  27.         addInverted(docInfo);
  28.     }
  29.  
  30.  
  31.     private DocInfo addForward(String title, String url, String content) {
  32.  
  33.     }
  34.  
  35.     private void addInverted(DocInfo docInfo) {
  36.  
  37.     }
  38. }

 实现addForward：

  1.     private DocInfo addForward(String title, String url, String content) {
  2.         DocInfo docInfo = new DocInfo(title, url, content);
  3.         docInfo.setDocId(forwardIndex.size());
  4.         forwardIndex.add(docInfo);
  5.         return docInfo;
  6.     }

实现addInverted：

实现该方法我们需要找出该文档中的所有词，并统计每个词出现的次数，我们可以使用 ansj 库来实现分词操作：

在pom文件中添加对应依赖：

  1.         <dependency>
  2.             <groupId>org.ansj</groupId>
  3.             <artifactId>ansj_seg</artifactId>
  4.             <version>5.1.6</version>
  5.         </dependency>
  1.     private void addInverted(DocInfo docInfo) {
  2.         //通过分词统计每个词在文章中出现的次数来作为相关性权重
  3.         Map<String, Integer> countMap = new HashMap<>();
  4.  
  5.         //统计标题中的词 权重为10
  6.         String title = docInfo.getTitle();
  7.         //分词，Term是ansj中的库,用于储存一个词的信息
  8.         //parse()方法用于分词，getTerms把parse的返回结果转为一个List<Term>
  9.         List<Term> terms = ToAnalysis.parse(title).getTerms();
  10.         for(Term term : terms) {
  11.             String key = term.getName();
  12.             int count = countMap.getOrDefault(key, 0) + 10;
  13.             countMap.put(key, count);
  14.         }
  15.  
  16.         //统计正文中的词 权重为1
  17.         String content = docInfo.getContent();
  18.         terms = ToAnalysis.parse(content).getTerms();
  19.         for(Term term : terms) {
  20.             String key = term.getName();
  21.             int count = countMap.getOrDefault(key, 0) + 1;
  22.             countMap.put(key, count);
  23.         }
  24.  
  25.         //添加到invertedIndex
  26.         for(Map.Entry<String, Integer> entry : countMap.entrySet()) {
  27.             String key = entry.getKey();
  28.             int weight = entry.getValue();
  29.             List<Relate> relates = invertedIndex.get(key);
  30.             Relate relate = new Relate(key, docInfo.getDocId(), weight);
  31.             if(relates == null) {
  32.                 relates = new ArrayList<>();
  33.                 relates.add(relate);
  34.                 invertedIndex.put(key, relates);
  35.             }else {
  36.                 relates.add(relate);
  37.             }
  38.         }
  39.     }

由于制作索引的速度是非常慢的，所有我们可以把制作好的索引存储在磁盘里，使用时再从磁盘加载到内存中，避免每次使用都要制作索引：

在Index类中增加一个存储索引的文件夹路径的常量：SAVE_PATH

实现save 和 load 方法用于保存和加载索引：

由于我们的索引是以对象的形式存在的，所以我们先需要把对象序列化再存入磁盘中，我们可以使用jackson库来完成这个操作

  1.         <dependency>
  2.             <groupId>com.fasterxml.jackson.core</groupId>
  3.             <artifactId>jackson-databind</artifactId>
  4.             <version>2.17.0</version>
  5.         </dependency>
  1.  
  2.     public void save() {
  3.         //jackson
  4.         ObjectMapper mapper = new ObjectMapper();
  5.  
  6.         File file = new File(SAVE_PATH);
  7.         //判断目录是否存在，不存在则创建目录
  8.         if(!file.exists()) {
  9.             file.mkdirs();
  10.         }
  11.  
  12.         //使用两个文件分别保存正排索引和倒排索引
  13.         File forward = new File(SAVE_PATH + "forward.txt");
  14.         File inverted = new File(SAVE_PATH + "inverted.txt");
  15.         try {
  16.             //写入到文件
  17.             mapper.writeValue(forward, forwardIndex);
  18.             mapper.writeValue(inverted, invertedIndex);
  19.         } catch (IOException e) {
  20.             throw new RuntimeException(e);
  21.         }
  22.     }
  23.  
  24.     public void load() {
  25.         ObjectMapper mapper = new ObjectMapper();
  26.         File forward = new File(SAVE_PATH + "forward.txt");
  27.         File inverted = new File(SAVE_PATH + "inverted.txt");
  28.         try {
  29.             //加载到内存
  30.             forwardIndex = mapper.readValue(forward, new TypeReference<List<DocInfo>>() {});
  31.             invertedIndex = mapper.readValue(inverted, new TypeReference<Map<String, List<Relate>>>() {});
  32.         } catch (IOException e) {
  33.             throw new RuntimeException(e);
  34.         }
  35.     }

2.3 联系Parser和Index

 在上面的代码中，Parser类主要负责解析html文件，Index负责通过解析出的信息来生成索引，所以需要把Parser类解析出来的信息传给Index生成索引，我们可以在parserHTML()方法的最后调用Index类的addDoc()方法，让文件一解析就传给addDoc()开始添加索引，我们给Parser类添加一个Index类的成员变量，通过这个对象来调用addDoc()方法：

 parserHTML()方法：

  1.     private void parserHTML(File file) {
  2.         //a.解析出标题
  3.         String title = parserTitle(file);
  4.  
  5.         //b.解析出url
  6.         String url = parserUrl(file);
  7.  
  8.         //c.解析出正文
  9.         String content = parserContent(file);
  10.  
  11.         //d.添加索引
  12.         index.addDoc(title, url, content);
  13.     }

到现在我们的索引模块的功能就已经实现了，调用Parser类的parser方法即可开始解析文件并制作索引。

2.4 速度优化

当我们完成这部分代码，开始制作索引时，发现制作索引的速度是非常慢的，我们添加一些代码统计制作索引的过程消耗的时间：

可以看到，我们制作索引的时间大概消耗了15秒，这只是相对于Java文档来说，要是是更大的文档时间会更长，要想提高速度，我们要先找到代码的那一步影响的速度，显而易见，解析和田间索引消耗的时间最多即parser()方法包含的代码，我们可以考虑优化这部分代码，该部分的代码主要包含三个操作：

  • 解析文件
  • 生成正排索引
  • 生成到排索引 

要优化这部分操作的速度我们可以考虑使用多线程，使用多个线程来并发完成这个操作：

实现一个parserByThread()方法使用多线程完成索引制作：

  1.     private void parserByThread() throws InterruptedException {
  2.         //1.找出所有html文件
  3.         List<File> fileList = new ArrayList<>();
  4.         enumFile(FILE_PATH, fileList);
  5.  
  6.         //2.使用线程词并发对每个HTML文件进行解析并制作索引
  7.         CountDownLatch countDownLatch = new CountDownLatch(fileList.size());
  8.         ExecutorService executorService = Executors.newFixedThreadPool(4);
  9.         for(File f : fileList) {
  10.             executorService.submit(new Runnable() {
  11.                 @Override
  12.                 public void run() {
  13.                     System.out.println("开始解析：" + f.getAbsolutePath());
  14.                     parserHTML(f);
  15.                     countDownLatch.countDown();
  16.                 }
  17.             });
  18.         }
  19.  
  20.         //等待所有任务执行完成
  21.         countDownLatch.await();
  22.  
  23.         //3.把索引文件保存到磁盘
  24.         index.save();
  25.     }

上面代码中我们使用了线程池，用4个线程来完成解析和制作索引的工作，使用CountDownLatch类来保证所有任务执行完再开始执行save方法，CountDownLatch构造方法传入的参数是执行任务的个数，每个任务执行完后需调用countDown方法，执行到await方法时如果调用countDown方法的次数小于实例CountDownLatch时传入的参数就会阻塞等待，直到调用countDown方法次数等于传入参数。

接下来我们还需要考虑线程安全问题，当多个线程操作同一块内存时就会出现线程安全问题 ：

在我们的代码中有添加索引时存在这种情况，也就是addForward方法和addInverted方法，我们需要给访问内存的代码加锁来保证线程安全问题：

  1.     private DocInfo addForward(String title, String url, String content) {
  2.         DocInfo docInfo = new DocInfo(title, url, content);
  3.         synchronized (locker1) {
  4.             docInfo.setDocId(forwardIndex.size());
  5.             forwardIndex.add(docInfo);
  6.         }
  7.         return docInfo;
  8.     }
  1.     private void addInverted(DocInfo docInfo) {
  2.         //通过分词统计每个词在文章中出现的次数来作为相关性权重
  3.         Map<String, Integer> countMap = new HashMap<>();
  4.  
  5.         //统计标题中的词 权重为10
  6.         String title = docInfo.getTitle();
  7.         List<Term> terms = ToAnalysis.parse(title).getTerms();
  8.  
  9.         for(Term term : terms) {
  10.             String key = term.getName();
  11.             int count = countMap.getOrDefault(key, 0) + 10;
  12.             countMap.put(key, count);
  13.         }
  14.  
  15.         //统计正文中的词 权重为1
  16.         String content = docInfo.getContent();
  17.         terms = ToAnalysis.parse(content).getTerms();
  18.         for(Term term : terms) {
  19.             String key = term.getName();
  20.             int count = countMap.getOrDefault(key, 0) + 1;
  21.             countMap.put(key, count);
  22.         }
  23.  
  24.         //添加到invertedIndex
  25.         for(Map.Entry<String, Integer> entry : countMap.entrySet()) {
  26.             String key = entry.getKey();
  27.             int weight = entry.getValue();
  28.             synchronized (locker2) {
  29.                 List<Relate> relates = invertedIndex.get(key);
  30.                 Relate relate = new Relate(key, docInfo.getDocId(), weight);
  31.                 if(relates == null) {
  32.                     relates = new ArrayList<>();
  33.                     relates.add(relate);
  34.                     invertedIndex.put(key, relates);
  35.                 }else {
  36.                     relates.add(relate);
  37.                 }
  38.             }
  39.         }
  40.     }

注意两个方法操作的内存不是同一块，所有可以使用不同的的对象来加锁。

运行代码：

可以看到速度的提升非常明显 ，不过这里我们发现当索引制作完成我们的代码还没有提示运行结束，这是因为，我们通过线程池创建的线程模式是非守护线程，非守护线程会阻止进程的结束，我们可以在任务执行完时调用ExecutorService类的shutdown()方法来销毁线程，从而让进程顺利结束：

3. 搜索模块实现

搜索模块的功能是调用索引模块的代码，通过用户输入的关键词查询到相关文档信息，处理后返回

查询操作只需要调用索引模块的方法，这里我们重点关注如何处理查询到的信息。

首先我们先思考，需要返回什么信息，首先能想到的有文档标题，和文档描述（这两项需要展示给用户），所以需要在返回结果中包含这两项信息，其次，用户如果想要查看文档的具体信息，那么需要url来跳转到在线文档界面，所以还需要url，最后，如果我们是用户，我们肯定希望能更快的找到想要查询的文档，所以我们还可以对查询结果按和关键词的相关性做一个降序排序。

定义一个Result类用于充当返回结果的类型：

  1. package org.example.docsearcher.model;
  2.  
  3. import lombok.Data;
  4.  
  5. @Data
  6. public class Result {
  7.     private String title;
  8.     private String url;
  9.     //描述
  10.     private String desc;
  11. }

定义DocSearcher类完成搜索模块的主要功能：

  1. import org.ansj.domain.Term;
  2. import org.ansj.splitWord.analysis.ToAnalysis;
  3.  
  4. import java.util.ArrayList;
  5. import java.util.Comparator;
  6. import java.util.List;
  7. import java.util.Locale;
  8.  
  9. @Configuration
  10. public class DocSearcher {
  11.     //用于调用索引模块接口
  12.     private Index index = new Index();
  13.  
  14.     public List<Result> search(String query) {
  15.         //1.对用户输入结果进行分词
  16.  
  17.         //2.通过用户输入的关键词在倒排索引中查询相关文档
  18.  
  19.         //3.对查询到的结果按相关性降序排序
  20.  
  21.         //4.通过正排索引查询文档相关信息并做返回处理
  22.         
  23.     }
  24.  
  25. }

这里对用户输入结果处理时还需要考虑一个问题：用户输入的词一定都是关键词吗？显然不是，例如用户输入：What is HashMap? ，显然里面的what 和 is 都不是关键词，并且这样的词在文档里会出现很多，就可能会导致用户想要看到的结果被挤到下方去了，这样的词称为暂停词，我们在对用户输入进行分词时要去掉暂停词，我们可以在网络上下载一个现成的暂停词表，运行程序时把它加载到内存中，用一个Set存储，用于排除分词结果中的暂停词。

这里我放在一个txt文件中。 

  1. @Configuration
  2. public class DocSearcher {
  3.     public Index index = new Index();
  4.  
  5.     private static final String STOP_WORD_PATH = "D:/桌面/stopWords.txt";
  6.     private Set<String> stopWords = new HashSet<>();
  7.  
  8.     public DocSearcher() {
  9.         //加载索引
  10.         index.load();
  11.  
  12.         //加载停用词
  13.         loadStopWord();
  14.     }
  15.  
  16.     public List<Result> search(String query) {
  17.         //1.对用户输入结果进行分词
  18.         List<Term> terms = ToAnalysis.parse(query).getTerms();
  19.  
  20.         //2.通过用户输入的关键词在倒排索引中查询相关文档
  21.         List<Relate> allDocs = new ArrayList<>();
  22.         for(Term term : terms) {
  23.             String key = term.getName();
  24.             //判断是否是暂停词,或者空格
  25.             if(!stopWords.contains(key) && !key.equals(" ")) {
  26.                 List<Relate> docs = index.getInverted(key);
  27.                 //判断是否有相关文章
  28.                 if(docs == null) {
  29.                     continue;
  30.                 }
  31.                 //添加到查询结果
  32.                 allDocs.addAll(docs);
  33.             }
  34.         }
  35.  
  36.         //3.对查询到的结果按相关性降序排序
  37.         allDocs.sort(new Comparator<Relate>() {
  38.             @Override
  39.             public int compare(Relate o1, Relate o2) {
  40.                 return o2.getWeight() - o1.getWeight();
  41.             }
  42.         });
  43.  
  44.         //4.通过正排索引查询文档相关信息并做返回处理
  45.         List<Result> results = new ArrayList<>();
  46.         for(Relate relate : allDocs) {
  47.             DocInfo docInfo = index.getForward(relate.getDocId());
  48.             Result result = new Result();
  49.             result.setTitle(docInfo.getTitle());
  50.             result.setUrl(docInfo.getUrl());
  51.             result.setDesc(genDesc(relate.getKey(), docInfo.getContent()));
  52.             results.add(result);
  53.         }
  54.         return results;
  55.     }
  56.  
  57.     private void loadStopWord() {
  58.         try(BufferedReader bufferedReader = new BufferedReader(new FileReader(STOP_WORD_PATH))) {
  59.             while(true) {
  60.                 String line = bufferedReader.readLine();
  61.                 if(line == null) {
  62.                     //读取完毕
  63.                     break;
  64.                 }
  65.                 stopWords.add(line);
  66.             }
  67.  
  68.         } catch (IOException e) {
  69.             throw new RuntimeException(e);
  70.         }
  71.     }
  72.     private String genDesc(String key, String content) {
  73.         //通过关键词和正文生成摘要
  74.  
  75.         //在正文中查找第一次出现关键词的位置，使用正则表达式确保找到的的是单独的一个单词
  76.         //注意ansj分词结果会转为小写，所以需要把content也转为小写再匹配
  77.         content = content.toLowerCase().replaceAll("\\b" + key + "\\b", " " + key + " ");
  78.         int firstPos = content.indexOf(" " + key + " ");
  79.  
  80.         //取该位置前后各150个字符作为摘要
  81.         int begPos = Math.max(firstPos - 150, 0);
  82.         int endPos = Math.min(firstPos + 150, content.length());
  83.         String desc = content.substring(begPos, endPos) + "...";
  84.  
  85.         //给关键词加上<i>标签,(?i)表示不区分大小写替换
  86.         desc = desc.replaceAll("(?i)" + " " + key + " ", " <i>" + key + "</i> ");
  87.  
  88.         return desc;
  89.     }
  90.  
  91. }

4. Web模块实现

基本的功能已经实现，现在只需提供一个接口供用户访问即可

  1. package org.example.docsearcher.controller;
  2.  
  3. import org.example.docsearcher.model.Result;
  4. import org.example.docsearcher.service.SearcherService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RestController;
  8.  
  9. import java.util.List;
  10.  
  11. @RestController
  12. @RequestMapping("/searcher")
  13. public class SearcherController {
  14.     @Autowired
  15.     SearcherService service;
  16.     @RequestMapping("/getInfo")
  17.     public List<Result> getInfo(String query) {
  18.         return service.getInfo(query);
  19.     }
  20. }
  1. package org.example.docsearcher.service;
  2.  
  3. import org.example.docsearcher.config.DocSearcher;
  4. import org.example.docsearcher.model.Result;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7.  
  8. import java.util.List;
  9.  
  10. @Service
  11. public class SearcherService {
  12.     @Autowired
  13.     DocSearcher searcher;
  14.     public List<Result> getInfo(String query) {
  15.         return searcher.search(query);
  16.     }
  17. }

5. 前端页面实现

现在后端代码已经全部完成，接下来实现一个简单的页面调用后端的接口即可：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <title>Java文档搜索</title>
  7.     <style>
  8.         * {
  9.             margin: 0;
  10.             padding: 0;
  11.             box-sizing: border-box;
  12.         }
  13.     
  14.         html, body {
  15.             height: 100%;
  16.             background-image: url(image/image.png);
  17.             background-repeat: no-repeat;
  18.             background-position: center center;
  19.             background-size: cover;
  20.         }
  21.     
  22.         .container {
  23.             width: 70%;
  24.             height: 100%;
  25.             margin: 0 auto;
  26.             background-color: rgba(255, 255, 255, 0.8);
  27.             border-radius: 20px;
  28.             padding: 20px;
  29.             overflow: auto;
  30.         }
  31.  
  32.  
  33.     
  34.         .header {
  35.             display: flex;
  36.             align-items: center;
  37.             padding: 30px;
  38.             background-color: #f8f9fa;
  39.             border-radius: 8px;
  40.             box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
  41.         }
  42.  
  43.         #search-input {
  44.             width: 90%;
  45.             padding: 12px;
  46.             font-size: 16px;
  47.             border: 2px solid #dee2e6;
  48.             border-radius: 5px;
  49.             transition: border-color 0.3s ease;
  50.         }
  51.  
  52.         #search-input:focus {
  53.             border-color: #495057;
  54.             outline: none;
  55.         }
  56.  
  57.         #search-btn {
  58.             margin-left: 5px;
  59.             padding: 12px 20px;
  60.             background-color: #007bff;
  61.             color: white;
  62.             border: none;
  63.             border-radius: 5px;
  64.             cursor: pointer;
  65.         }
  66.  
  67.         #search-btn:active {
  68.             background-color: #007bbf;
  69.         }
  70.  
  71.         .item {
  72.             width: 100%;
  73.             margin-top: 20px;
  74.         }
  75.  
  76.         .item a{
  77.             display: block;
  78.             height: 40px;
  79.             font-size: 22px;
  80.             line-height: 40px;
  81.             font-weight: 700px;
  82.             color: #007bff;
  83.         }
  84.  
  85.         .item desc{
  86.             font-size: 18px;
  87.         }
  88.  
  89.         .item .url {
  90.             font-size: 18px;
  91.             color: rgb(0, 200, 0);
  92.         }
  93.     </style>
  94. </head>
  95. <body>
  96.     <!-- 整个页面元素的容器 -->
  97.     <div class="container">
  98.         <!-- 搜索框和搜索按钮 -->
  99.         <div class="header">
  100.             <input type="text" id="search-input" placeholder="请输入搜索内容...">
  101.             <button id="search-btn" onclick="getInfo()">搜索</button>
  102.         </div>
  103.  
  104.         <!-- 搜索结果 -->
  105.         <div class="result">
  106.  
  107.             <!-- <div class="item">
  108.                 <a href="#">我是标题</a>
  109.                 <div class="desc">我是描述</div>
  110.                 <div class="url">www.baidu.com</div>
  111.             </div> -->
  112.  
  113.         </div>
  114.     </div>
  115.  
  116.     <script src="js/jquery.min.js"></script>
  117.     <script>
  118.         <-- 点击搜索按钮后调用该方法 -->
  119.         function getInfo() {
  120.             $(".result").empty();
  121.             var query = $("#search-input").val();
  122.             $.ajax({
  123.                 url: "/searcher/getInfo?query=" + query,
  124.                 type: "get",
  125.                 success: function(results) {
  126.                     var html = "";
  127.                     for(var result of results) {
  128.                         html += '<div class="item"><a href="'+result.url+'" target="_blank">'+result.title+'</a>';
  129.                         html += '<div class="desc">'+result.desc+'</div>';
  130.                         html += '<div class="url">'+result.url+'</div></div>';
  131.                     }
  132.                     $(".result").html(html);
  133.                 }
  134.             }); 
  135.         }
  136.     </script>
  137. </body>
  138.  
  139. </html>

启动服务器在前端界面搜索：

可以看到成功的弹出了搜索结果。这里我们还可以做一个优化，当我们使用浏览器搜索某个关键词时，浏览器的搜索结果中会把我们所输入的关键词标红：

我们也可以实现一个同样的功能。

这里我们通过前后端配合的方式实现，在后端生成每个搜索结果的描述的时候，我们给描述中的关键词都加上一个<i>标签，再通过前端设置样式来调整字体颜色：

修改 genDesc方法：

  1.     private String genDesc(List<Term> terms, String key, String content) {
  2.         //通过关键词和正文生成摘要
  3.  
  4.         //在正文中查找第一次出现关键词的位置，使用正则表达式确保找到的的是单独的一个单词
  5.         //注意ansj分词结果会转为小写，所以需要把content也转为小写再匹配
  6.         content = content.toLowerCase().replaceAll("\\b" + key + "\\b", " " + key + " ");
  7.         int firstPos = content.indexOf(" " + key + " ");
  8.  
  9.         //取该位置前后各150个字符作为摘要
  10.         int begPos = Math.max(firstPos - 150, 0);
  11.         int endPos = Math.min(firstPos + 150, content.length());
  12.         String desc = content.substring(begPos, endPos) + "...";
  13.  
  14.         //给关键词加上<i>标签,(?i)表示不区分大小写替换
  15.         for(Term term : terms) {
  16.             String word = term.getName();
  17.             desc = desc.replaceAll("(?i)" + " " + word + " ", " <i>" + word + "</i> ");
  18.         }
  19.         return desc;
  20.     }

在前端的代码中添加对<i>标签的样式：

  1.         .item .desc i {
  2.             color: red;
  3.             font-style: normal;
  4.         }

重新启动程序：

可以看到关键词成功被标红 , 这里我们还可以在前端代码中添加一个显示搜索结果数量的功能：

 

6. 部署程序

到此位置我们 api文件搜索引擎的所有功能都实现了，接下来就可以部署到云服务器上，在此之前我们需要把在本地制作好的索引文件和暂停词文件拷贝到云服务器上：

 

然后把代码中的路径改为云服务器中对应的路径：

 

打包程序：

 

双击package：

把生成的jar包拷贝到云服务器上，输入指令：

nohup java -jar jar包名称.jar &

即部署完毕 

接下来就可以支持用户使用公网id访问 我们的程序。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/731839
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号