API文档搜索引擎

导航小助手

一、认识搜索引擎

二、项目目标

三、模块划分

四、创建项目

五、关于分词

六、实现索引模块

6.1 实现 Parser类

6.2 实现 Index类

6.2.1 创建 Index类

6.2.2 创建DocInfo类

6.2.3 创建 Weight类

6.2.4 实现 getDocInfo 和 getInverted方法

6.2.5 实现 addDoc方法

6.2.6 实现save方法

6.2.7 实现 load方法

6.3 在 Parser 中调用 Index

6.3.1 新增 Index实例

6.3.2 修改 parseHTML方法

6.3.3 新增save方法的调用

6.4 验证索引模块

6.5 优化制作索引速度

七、实现搜索模块

7.1 创建 DocSearcher类

7.1.1 创建 Result类

7.1.2 实现 search方法

7.1.3 验证 DocSearcher类

7.1.4 修改 Parser类

八、实现Web模块

一、认识搜索引擎

关于搜索引擎，平时的时候都是用的比较多，如：百度、搜狗、谷歌等搜索引擎，但是并没有仔细的观察过~

以搜狗搜索为例，我们打开搜狗搜索，就会发现，有一个搜索主页，并且有一个搜索框，我们可以在搜索框中搜索想要知道的内容，点击搜索，就可以查找搜索结果的页面~

搜索引擎的核心功能，就是查找到一组和用户输入的查询词（或者是一句话），所相关联的网页~

通过观察可以发现，对于每一条搜索结果，都会显示该搜索结果的标题、描述、展示url等属性（虽然有的结果样式上可能会更复杂，但是还是会有标题、描述、展示url属性），当我们点击一条搜索记录的时候，就跳转到相应的页面（称之为落地页）~

搜索引擎的核心实现思路：

搜索引擎的核心目的是：在很多很多的网页中找到和查询词相关联的内容~

那么，对于一个搜索引擎来说，首先需要获取到很多的网页，然后再根据用户输入的查询词，在这些网页中进行查找~

这就涉及到了几个问题：

搜索引擎的网页是怎么获取到的（此处主要是涉及到 "爬虫" 程序，此处不过多介绍）
用户输入查询词之后，如何让查询词和当前的这些网页进行匹配呢（这个是重点）

假设当前已经爬取到了 1亿个网页(html文件)，用户输入了一个 "蛋糕"查询词，此时如果使用的是 "暴力搜索"的话，那么就需要把 "蛋糕"这个字符串在这1亿个网页里面进行查找，那肯定是效率很低的（特别是对于搜索引擎来说，我们都希望再进行搜索之后，会立刻出现我们所要查找的结果）~

因此为了更加高效的解决这个问题，大佬们专门设计了一种特殊的数据结构 —— 倒排索引~

需要知道的知识：

举个例子：

在日常的生活中，我们也会有所体会（就比如说在玩王者荣耀的时候）：

二、项目目标

像搜索引擎这样的程序，是一个很复杂的程序，很难做出像百度、搜狗一样的规模庞大的搜索引擎，所以可以简化一下目标：可以做一个针对 Java API文档的搜索引擎~

通过观察可以发现，官方文档上面并没有一个搜索框，所以想要去查找某个类，但又不知道这个类在哪个包里，就会显得很麻烦~

因此就可以实现这样一个站内搜索引擎，让用户输入一些查询词，之后就可以找到相关的文档页面~

获取Java文档：

要想实现这个项目，首先就需要把相关的网页文档给获取到，然后才可以继续接下来的过程~

相关网页在 oracle官方网站上面，想要把上面所有的页面获取到，并不是一件很容易的事情~

虽然说，可以通过 "爬虫"技术，把这些文档获取到，但是 "爬虫"技术还没有学到（听说实现"爬虫"程序会存在法律风险的），所以就暂时放弃这个方法~

针对于 Java API文档来说，还有更加简单的方法 —— 可以直接从官网上直接下载，因此就不必通过爬虫来实现~

Java API文档线上版本：https://docs.oracle.com/javase/8/docs/api/index.html

Java API文档线下版本下载地址：https://www.oracle.com/java/technologies/downloads/

三、模块划分

1）索引模块

扫描下载到的文档，分析文档内容，构建出正排索引+倒排索引，并且把索引内容保存到文件中~
加载制作好的索引，并提供一些API实现查正排和查倒排这样的功能~

2）搜索模块

调用索引模块，实现一个搜索的完整过程~
输入：用户的查询词；输出：完整的搜索结果（包含了很多条记录，每个记录有标题、描述、展示url，并且点击可以跳转）~

3）Web模块

需要实现一个简单的 web程序，能够通过网页的形式和用户进行交互~

四、创建项目

五、关于分词

用户在搜索引擎中，输入的查询词，不一定真的只是一个词，也有可能是一句话：

由上面的搜索结果我们可以知道，先针对完整的句子进行分词，然后根据每个词的分词结果，分别找到相关的文档~

针对 "分词"操作，人是非常容易完成的；但是对于机器来说，这就困难很多；英文的话还好，有空格就可以了，但是中文博大精深，额，就非常的哇塞了~

比如说，"我一把把车把把住"，"小龙女也想过过过儿过过的生活"，"下雨天留客天留我不留" ~

好在，我们要想实现这个分词效果，就可以基于一些现成的第三方库，从而实现分词效果~

分词实现原理

虽然说，我们现在使用的是第三方库，并不是自己实现分词逻辑，但是还是需要了解一下分词的原理~

第一种情况：基于词库！

以汉语为例，虽然说，汉字很多，但是仍然是可以尝试着把所有的词都穷举在一本词典文件中，然后就可以依次的取句子中的内容：如：每隔一个字，就在词典里查一下；每隔两个字，查一下；......

但是，这并不能把所有的词都穷举出来，而且随着时间的推移，也会产生越来越多的新词，......，关是基于词库，并不能分出所有的词~

第二种情况：基于统计！

利用这种方法，收集很多很多的 "语料库"（如：现有的一些文章、资料等等），接着就可以进一步进行人工标注/或者是直接统计，接着就进一步的知道了哪些词成词的情况比较高（就类似于根据用户的习惯）~

分词的实现，就是属于 "人工智能" 典型应用的场景 ~

使用第三方库：

在Java中可以实现分词的第三方库也是有很多的，在这里我们可以使用 ansj分词库~

        <!-- 引入分词依赖，下载安装ansj       -->
        <!-- https://mvnrepository.com/artifact/org.ansj/ansj_seg -->
        <dependency>
            <groupId>org.ansj</groupId>
            <artifactId>ansj_seg</artifactId>
            <version>5.1.6</version>
        </dependency>

示例：

   public static void main(String[] args) {
        //准备一个比较长的话，用来分词(中文分词)
        String str1 = "人终将被少年不可得之物困其一生，但也终会因一事一景解开一生困惑";
        List<Term> terms1 = ToAnalysis.parse(str1).getTerms();
        for (Term term1 : terms1) {
            System.out.print(term1.getName() + '/');
        }
        System.out.println();
        //英文分词(会把大写字母转换成小写字母)
        String str2 = "I have a dream!";
        List<Term> terms2 = ToAnalysis.parse(str2).getTerms();
        for (Term term2 : terms2) {
            System.out.print(term2.getName() + ' ');
        }
    }

结果：

六、实现索引模块

6.1 实现 Parser类

创建一个Parser类，通过这个类来完成制作索引的过程~

Parser：读取之前下载好的离线文档，去解析文档的内容，并完成索引的制作！

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

public class Parser {
    //指定加载文档的路径
    private static final String INPUT_PATH = "E:/doc_searcher_index/jdk-8u361-docs-all/docs/api/";

    private void run() {
        //整个Parser类的入口
        //1、根据上面指定的路径，枚举出该路径中所有的 html文件(包括子目录中的文件)
        //2、针对上面罗列出文件的路径，打开文件，读取文件内容，并进行解析，并构建索引
        //3、todo 把在内存中构造好的索引数据结构，保存到指定的文件中

        ArrayList<File> fileList = new ArrayList<>();
        enumFile(INPUT_PATH,fileList);
        /**
         * System.out.println(fileList);
         * System.out.println(fileList.size());
         */

        for (File f:fileList) {
            //通过parseHTML()方法解析 .html文件
            System.out.println("开始解析：" + f.getAbsolutePath());
            parseHTML(f);
        }

    }

    /**
     * 解析 .html文件 的方法
     * @param f
     */
    private void parseHTML(File f) {
        //解析 标题
        String title = parseTitle(f);
        //解析 url
        String url = parseUrl(f);
        //解析 对应的正文(描述 是正文的一小部分，先解析出来正文，然后才可以获取到 描述)
        String content = parseContent(f);

        //todo 把解析出来的这些信息，加入到索引当中
    }

    /**
     * 通过观察，可以发现，在 .html文件中，<title>标签 里面的就是标题
     * 进一步可以发现，.html文件名 就是该文件的标题
     */
    private String parseTitle(File f) {
        return f.getName().substring(0,f.getName().length() - ".html".length());
    }

    /**
     * url 是在线文档对应的链接
     */
    private String parseUrl(File f) {
        //先获取到固定的前缀
        String part1 = "https://docs.oracle.com/javase/8/docs/api/";
        //后获取 线下文档api后面的部分
        String part2 = f.getAbsolutePath().substring(INPUT_PATH.length());
        return part1 + part2;
    }

    /**
     * 一个完整的 .html文件，里面有的是 <html>标签 + 内容
     * 所以 解析正文的核心工作是：去掉 <html>标签,只剩下 内容
     */
    public String parseContent(File f) {
        //先按照一个字符一个字符的方式来读取( < 和 > 来控制拷贝数据的开关)
        try( FileReader fileReader = new FileReader(f)) {
            //加上一个开关:true拷贝，false不拷贝
            boolean isCopy = true;
            //加上一个保存结果的stringBuilder
            StringBuilder stringBuilder = new StringBuilder();

            while (true) {
                //read()返回值是 int，而不是 char
                //主要是为了表示一些非法情况，文件读完了，返回-1
                int ret = fileReader.read();
                if (ret == -1) {
                    break;
                }

                //如果结果不是-1，那就是合法的字符
                char c = (char) ret;
                if (isCopy) {
                    //开关打开，遇到普通字符就拷贝到 StringBuilder中
                    if (c == '<') {
                        //关闭开关
                        isCopy = false;
                        continue;
                    }
                    //去掉 .html文件当中的换行，不然实在是不好看
                    if (c == '\n' || c == '\r') {
                        //把换行替换成空格
                        c = ' ';
                    }
                    //其他字符，直接拷贝
                    stringBuilder.append(c);
                }else {
                    //开关不拷贝，直到遇到 >
                    if (c == '>') {
                        isCopy = true;
                    }
                }
            }
            return stringBuilder.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }





    /**
     *
     * @param inputPath 表示从哪个目录开始进行递归遍历
     * @param fileList 表示递归所得到的结果
     */
    private void enumFile(String inputPath, ArrayList<File> fileList) {
        File rootPath = new File(inputPath);
        File[] files = rootPath.listFiles(); //listFiles()方法，获取到rootPath目录下的路径名(仅仅只能看到一层内容)

        //使用递归，看见所有子目录下面的内容
        for (File f:files) {
            //根据f类型，来决定是否需要递归
            if (f.isDirectory()) {
                //f 是一个目录，递归调用enumFile()方法，进一步获取子目录的内容
                enumFile(f.getAbsolutePath(),fileList);
            }else {
                //f 是一个普通文件，加入到 fileList中
                //在此处排除非.html文件(以.html的文件才添加上去)
                if (f.getAbsolutePath().endsWith(".html")) {
                    fileList.add(f);
                }
            }
        }
    }


    public static void main(String[] args) {
        //通过 main方法，实现整个制作索引的过程
        Parser parser = new Parser();
        parser.run();
    }
}

在Parser类当中，主要做的是，枚举出当前指定目录中的所有的 .html文档，通过递归函数 enumFile(INPUT_PATH,fileList) ，把所获取到的文档存储在 fileList里面；接下来就可以循环遍历这里的每一个文件，再针对文件进行解析，每一个文件都是一个 .html，解析 .html文件的标题、描述、展示url ~

在解析好了这些信息，就可以把它们加入到索引数据结构当中；于是，就可以专门创建一个 Index类，来负责构建索引数据结构~

6.2 实现 Index类

6.2.1 创建 Index类

Index类主要实现的功能有：

正排索引
倒排索引
新增一个文档
保存索引文件
加载索引文件

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * 通过这个类在内存中构造出索引结构
 */
public class Index {

    //使用数组下标表示 docId(正排索引)
    private ArrayList<DocInfo> forwardIndex = new ArrayList<>();

    //使用 哈希表 来表示倒排索引(key是词，value是一组和这个词相关联的文章)
    private HashMap<String,ArrayList<Weight>> invertedIndex = new HashMap<>();

    //这个类所提供的方法
    //1.正排索引：给定一个 docId，在正排索引中，可以查询到文档的详细信息
    //2.倒排索引：给定一个词，在倒排索引中，查找那些文档和这个词有关联
    //3.将前面所解析出来的信息添加进去，向索引当中新增一个文档
    //4.把内存中的索引结构保存到磁盘中
    //5.把磁盘中的索引数据加载到内存

    //1.
    public DocInfo getDocInfo(int docId) {
        //todo
        return null;
    }

    //2.
    public List<Weight> getInverted(String term) {
        //todo
        return null;
    }

    //3.
    public void addDoc(String title,String url,String content) {
        //todo
    }

    //4.
    public void save() {
        //todo
    }

    //5.
    public void load() {
        //todo
    }
}

6.2.2 创建DocInfo类

DocInfo类主要表示的是：在正排索引中，根据 docId 所查询的文档的相关细节~

/**
 * 该类当中可以表示一个文档的相关细节
 */
public class DocInfo {
    private int docId;
    private String title;
    private String url;
    private String content;

    public int getDocId() {
        return docId;
    }

    public void setDocId(int docId) {
        this.docId = docId;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

6.2.3 创建 Weight类

Weight类主要表示的是：在倒排索引中，文档id 和文档与词的相关性的权重~

/**
 * 这个类是把 文档id 和 文档与词的相关性 的权重 进行一个包裹
 */
public class Weight {
    private int docId;
    //weight表示 文档和词之间的"相关性"，值越大，就说明 这个词和这个文档越有关的
    private int weight;

    public int getDocId() {
        return docId;
    }

    public void setDocId(int docId) {
        this.docId = docId;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

6.2.4 实现 getDocInfo 和 getInverted方法

    //1.
    public DocInfo getDocInfo(int docId) {
        return forwardIndex.get(docId);
    }

    //2.
    public List<Weight> getInverted(String term) {
        return invertedIndex.get(term);
    }

6.2.5 实现 addDoc方法

//3.
    public void addDoc(String title,String url,String content) {
        //新增文档操作，需要给正排索引和倒排索引都新增
        //构建正排索引
        DocInfo docInfo = buildForward(title,url,content);
        //构建倒排索引
        buildInverted(docInfo);

    }

    private void buildInverted(DocInfo docInfo) {
        //倒排索引，是词与文档id的映射关系
        //就需要知道当前的文档，里面存在有哪些词，就需要实现"分词"
        //就需要针对 标题、正文 进行分词，之后就可以根据分词的结果，知道当前的文档id 应该要加入到哪一个倒排索引的key里

        //1.针对标题进行分词，遍历分词结果，统计每个词出现的次数
        //2.针对正文进行分词，遍历分词结果，统计每个词出现的个数
        //3.汇总到HashMap中，简单设置权重，权重=标题出现的次数*10 + 正文出现的次数
        //4.遍历HashMap，依次更新倒排索引中的结构

        class WordCount {
            public int titleCount; //标题次数
            public int contentCount;//正文次数
        }
        //用来统计词频的数据结构
        HashMap<String,WordCount> wordCountHashMap = new HashMap<>();
        List<Term> terms = ToAnalysis.parse(docInfo.getTitle()).getTerms();
        for (Term term:terms) {
            //先判定term 是否存在
            String word = term.getName();
            WordCount wordCount = wordCountHashMap.get(word);
            if (wordCount == null) {
                //不存在，创建一个新的键值对，插入进去，titleCount设为1
                WordCount newWordCount = new WordCount();
                newWordCount.titleCount = 1;
                newWordCount.contentCount = 0;
                wordCountHashMap.put(word,newWordCount);
            }else {
                //存在，找到之前的值，对应的 titleCount+1
                wordCount.titleCount += 1;
            }
        }

        terms = ToAnalysis.parse(docInfo.getContent()).getTerms();
        for (Term term:terms) {
            String word = term.getName();
            WordCount wordCount = wordCountHashMap.get(word);
            if (wordCount == null) {
                WordCount newWordCount = new WordCount();
                newWordCount.titleCount = 0;
                newWordCount.contentCount = 1;
                wordCountHashMap.put(word,newWordCount);
            }else {
                wordCount.contentCount += 1;
            }
        }

        for (Map.Entry<String,WordCount> entry : wordCountHashMap.entrySet()) {
            //先根据这里的词去倒排索引中查一查
            List<Weight> invertedList = invertedIndex.get(entry.getKey()); //倒排拉链
            if (invertedList == null) {
                ArrayList<Weight> newInvertedList = new ArrayList<>();
                //把新的文档(当前 DocInfo),构造成 Weight对象，插入进来
                Weight weight = new Weight();
                weight.setDocId(docInfo.getDocId());
                //权重计算公式：标题中出现的次数*10+正文中出现的次数
                weight.setWeight(entry.getValue().titleCount * 10 + entry.getValue().contentCount);
                newInvertedList.add(weight);
                //如果为空，就插入一个新的键值对
                invertedIndex.put(entry.getKey(),newInvertedList);
            }else {
                //如果非空，就把这个文档，构造一个 Weight对象，插入到倒排拉链的后面
                Weight weight = new Weight();
                weight.setDocId(docInfo.getDocId());
                //权重计算公式：标题中出现的次数*10+正文中出现的次数
                weight.setWeight(entry.getValue().titleCount * 10 + entry.getValue().contentCount);
                invertedList.add(weight);
            }
        }

    }

6.2.6 实现save方法

至于为什么要实现save方法呢其实原因也是很简单的：当前索引是存储在内存中，而构建索引的过程(即上面实现的addDoc方法)，实际上是非常耗时间的，仅仅一个API就有上万份文档了，更别说其他的了~

因此我们不应该服务器启动的时候才构建索引(启动服务器就可能会被拖慢很多了)，万一服务器在运行过程中又崩溃了，那又要重启服务器，那又要浪费更长的时间了~

通常的操作可以是：先把这些耗时的操作，单独的去执行；执行好了之后，再让线上服务器直接加载这个构造好的索引；此时，加载的速度就仅在读磁盘上面花费时间了~

至于具体该如何去保存到文件中呢？我们都知道，文件里保存的不是二进制数据，就是文本数据；这就需要把内存中的索引结构变成一个字符串（这个过程叫做序列化），然后就可以直接写文件就可以了~

类似的，把特定结构的字符串按照一定的结构解析回来（类/对象/基础数据结构），我们就称之为反序列化~

其实，序列化和反序列化，都有许多现成的方法，此处可以使用JSON的格式，来完成序列化和反序列化，就可以很轻松的完成保存和加载索引的操作了~

此处使用JSON的格式，可以从中央仓库中引入相关依赖：

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

//引入 jackson 里面的核心对象
private ObjectMapper objectMapper = new ObjectMapper();

//保存的地址
private static final String INDEX_PATH = "E:\\doc_searcher_index\\";

由于涉及到两种索引，就可以分别使用两个文件来保存正排索引和倒排索引~

    //4.
    public void save() {
        //序列化
        //使用两个文件，分别保存正排和倒排
        System.out.println("保存所以开始！");
        //1.先判断索引对应的目录是否存在，不存在就创建
        File indexPathFile = new File(INDEX_PATH);
        if (!indexPathFile.exists()) {
            indexPathFile.mkdirs();
        }
        File forwardIndexFile = new File(INDEX_PATH + "forward.txt");
        File invertedIndexFile = new File(INDEX_PATH + "inverted.txt");
        try {
            objectMapper.writeValue(forwardIndexFile,forwardIndex);
            objectMapper.writeValue(invertedIndexFile,invertedIndex);
        }catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("保存索引完成！");
    }

6.2.7 实现 load方法

    //5.
    public void load() {
        //反序列化
        System.out.println("加载索引开始！");
        File forwardIndexFile = new File(INDEX_PATH + "forward.txt");
        File invertedIndexFile = new File(INDEX_PATH + "inverted.txt");
        try {
            forwardIndex = objectMapper.readValue(forwardIndexFile, new TypeReference<ArrayList<DocInfo>>() {});
            invertedIndex = objectMapper.readValue(invertedIndexFile, new TypeReference<HashMap<String, ArrayList<Weight>>>() {});
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("加载索引结束！");
    }

当然，由于索引中的文件可能会有很多，构造出来的索引数据也是比较大的，那么保存和加载到底会消耗多长时间呢？我们就可以修改一下 load和save方法，来衡量出它们的运行时间：

//4.
    public void save() {
        //序列化
        long beg = System.currentTimeMillis();
        //使用两个文件，分别保存正排和倒排
        System.out.println("保存索引开始！");
        //1.先判断索引对应的目录是否存在，不存在就创建
        File indexPathFile = new File(INDEX_PATH);
        if (!indexPathFile.exists()) {
            indexPathFile.mkdirs();
        }
        File forwardIndexFile = new File(INDEX_PATH + "forward.txt");
        File invertedIndexFile = new File(INDEX_PATH + "inverted.txt");
        try {
            objectMapper.writeValue(forwardIndexFile,forwardIndex);
            objectMapper.writeValue(invertedIndexFile,invertedIndex);
        }catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();

        System.out.println("保存索引完成！所消耗的时间是:" + ( end - beg ) + "ms");
    }

    //5.
    public void load() {
        //反序列化
        long beg = System.currentTimeMillis();
        System.out.println("加载索引开始！");
        File forwardIndexFile = new File(INDEX_PATH + "forward.txt");
        File invertedIndexFile = new File(INDEX_PATH + "inverted.txt");
        try {
            forwardIndex = objectMapper.readValue(forwardIndexFile, new TypeReference<ArrayList<DocInfo>>() {});
            invertedIndex = objectMapper.readValue(invertedIndexFile, new TypeReference<HashMap<String, ArrayList<Weight>>>() {});
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("加载索引结束！消耗时间：" + ( end - beg ) + "ms");
    }

6.3 在 Parser 中调用 Index

当然，关于 Parser类和 Index类之间的关系我们需要清楚：Parser类就相当于是制作索引的入口，通过 Parser类中的 main方法，就可以把整个流程给跑起来；Index类就相当于是实现了索引的数据结构，并且提供了一些API供他人调用~

因此，Index类需要给 Parser类调用，才可以完成整个制作索引的过程~

这也是上面的曾经留下了两个todo 需要做的事情：

6.3.1 新增 Index实例

public class Parser {
    ......
    
    //创建一个 Index实例
    private Index index = new Index();
    
    ......
}

6.3.2 修改 parseHTML方法

新增 addDoc方法的调用

private void parseHTML(File f) {
        //解析 标题
        String title = parseTitle(f);
        //解析 url
        String url = parseUrl(f);
        //解析 对应的正文(描述 是正文的一小部分，先解析出来正文，然后才可以获取到 描述)
        String content = parseContent(f);

        //todo 把解析出来的这些信息，加入到索引当中[新增]
        index.addDoc(title,url,content);
    }

6.3.3 新增save方法的调用

 private void run() {
        long beg = System.currentTimeMillis();
        System.out.println("索引制作开始！");
        //整个Parser类的入口
        //1、根据上面指定的路径，枚举出该路径中所有的 html文件(包括子目录中的文件)
        //2、针对上面罗列出文件的路径，打开文件，读取文件内容，并进行解析，并构建索引
        //3、todo 把在内存中构造好的索引数据结构，保存到指定的文件中

        long begEnumFile = System.currentTimeMillis();
        ArrayList<File> fileList = new ArrayList<>();
        enumFile(INPUT_PATH,fileList);
        long endEnumFile = System.currentTimeMillis();
        System.out.println("枚举文件完毕！消耗时间：" + ( endEnumFile - begEnumFile ) + "ms");
        /**
         * System.out.println(fileList);
         * System.out.println(fileList.size());
         */

        long begFor = System.currentTimeMillis();
        for (File f:fileList) {
            //通过parseHTML()方法解析 .html文件
            System.out.println("开始解析：" + f.getAbsolutePath());
            parseHTML(f);
        }
        long endFor = System.currentTimeMillis();
        System.out.println("循环遍历文件完毕！消耗时间：" + ( endFor - begFor ) + "ms");

        //新增save方法的调用(好吧，其实也新增了一些时间戳)
        index.save();
        long end = System.currentTimeMillis();
        System.out.println("索引制作完毕！消耗时间：" + ( end - beg ) + "ms");
    }

6.4 验证索引模块

运行Parser类，观察运行结果：

6.5 优化制作索引速度

关于性能优化，首先就需要通过 "测试的手段"（咳咳，通过一些时间戳知道某一段程序运行所花费的时间），找到其中的 "性能瓶颈"~

通过结果发现，主要花费的时间（性能瓶颈）就是在循环遍历文件上面，每次遍历一个 .html文件，都需要进行读文件+分词+解析内容等操作（主要就是花费在CPU运算上面）~

在单个线程的情况下，这些任务都是串行执行的；因此，可以引进多线程，并发执行，优化速度（当然，需要通过加锁来完成线程安全）~

//通过这个方法实现多线程制作索引
    public void runByThread() throws InterruptedException {
        long beg = System.currentTimeMillis();
        System.out.println("索引制作开始！");

        //1.枚举所有文件
        ArrayList<File> files = new ArrayList<>();
        enumFile(INPUT_PATH,files);

        //2.循环遍历文件(引入线程池)
        CountDownLatch latch = new CountDownLatch(files.size());
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        for (File f:files) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("解析：" + f.getAbsolutePath());
                    parseHTML(f);
                    latch.countDown();
                }
            });
        }
        //await方法会阻塞，直到所有选手都调用countDown撞线，才会阻塞结束
        latch.await();
        executorService.shutdown(); //手动杀死线程池里面的线程

        //3.保存索引
        index.save();

        long end = System.currentTimeMillis();
        System.out.println("索引制作完毕(多线程)！消耗时间：" + ( end - beg ) + "ms");
    }

解决线程安全问题：

    //创建两个锁对象
    private Object locker1 = new Object();
    private Object locker2 = new Object();

修改 buildForward方法：

private DocInfo buildForward(String title, String url, String content) {
        DocInfo docInfo = new DocInfo();
        docInfo.setTitle(title);
        docInfo.setUrl(url);
        docInfo.setContent(content);
        synchronized (locker1) {
            docInfo.setDocId(forwardIndex.size());
            forwardIndex.add(docInfo);
        }
        return docInfo;
    }

修改 buildInverted方法：

private void buildInverted(DocInfo docInfo) {

        ......

        for (Map.Entry<String,WordCount> entry : wordCountHashMap.entrySet()) {
            //先根据这里的词去倒排索引中查一查
            synchronized (locker2) {

                   ......

            }
        }
    }

在调用多线程的方法之后，我们就可以发现制作索引的速度就快了很多：

一些其他的小问题：

比如说，第一次制作索引的时候，它的制作速度会特别慢，在之后制作索引的时候，速度又会快很多；但把电脑关掉，再一次重启电脑，第一次制作索引的时候又变得慢很多，后面的时候速度又会快很多，这是为什么呢？

分析：在代码中核心操作还是在循环遍历上面，循环遍历上面又调用了 parseHTML方法，parseHTML方法中又调用了 parseContent方法，进行了读取文件的操作~

在计算机读取文件的时候，是一个开销比较大的操作~

我们就可以猜想：是不是开机之后，首次读取文件的时候速度特别慢呢~

实际上，是因为缓存的问题~

首次运行的时候，由于当前的这些 Java API 文档，没有在内存中进行缓存，因此读取的时候就只能从硬盘上进行读取（这是及其耗时的）；后面再运行的时候，由于前面已经读取过文档了，即在操作系统中其实已经有了一个缓存（在内存中），所以这次读取的就不是直接读硬盘，而是直接读内存的缓存（速度就会快很多）~

当然，这也是可以进行优化的~

BufferedReader 和 FileReader 搭配着来使用，BufferedReader 内部会内置一个缓冲区，就可以自动的把 FileReader 中的一些内容预读到内存中，从而减少直接访问磁盘的次数~

虽然说，后面的运行程序的时候操作系统已经做了缓存，此时运行速度也提高不了太多，但也好歹是优化了一点点~

七、实现搜索模块

搜索模块主要是调用索引模块，来完成搜索的核心过程！！！！！！

其中是可以包括：

分词：针对用户输入的查询词，进行分词
触发：拿着每一个分词结果，去倒排索引当中找出具有相关性的文章（调用 Index类里面查倒排的方法即可）
排序：根据上面所触发出来的结果，根据相关性降序进行排序
包装结果：根据排序后的结果，依次去查正排，获取到每个文档的详细信息，包装成一定结构的数据返回出去

7.1 创建 DocSearcher类

import java.util.List;

//通过这个类 来完成整个搜索模块的过程
public class DocSearcher {

    //此处需要加上索引对象的实例,同时需要完成索引加载的工作
    private Index index = new Index();
    public DocSearcher() {
        index.load();
    }

    /**
     * 完成整个搜索过程的方法
     * @param query 查询词
     * @return 搜索结果的集合
     */
    public List<Result> searcher(String query) {
        //1.分词
        //2.触发
        //3.排序
        //4.包装结果
        return null;
    }
}

7.1.1 创建 Result类

//这个类来表示一个搜索结果
public class Result {
    private String title;
    private String url;
    private String desc; //描述(正文的一段摘要)

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "Result{" +
                "title='" + title + '\'' +
                ", url='" + url + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

7.1.2 实现 search方法

//通过这个类 来完成整个搜索模块的过程
public class DocSearcher {

    //此处需要加上索引对象的实例,同时需要完成索引加载的工作
    private Index index = new Index();
    public DocSearcher() {
        index.load();
    }

    /**
     * 完成整个搜索过程的方法
     * @param query 查询词
     * @return 搜索结果的集合
     */
    public List<Result> searcher(String query) {
        //1.分词
        List<Term> terms = ToAnalysis.parse(query).getTerms();

        //2.触发(/针对分词结果进行倒排查找)
        List<Weight> allTermResult = new ArrayList<>();
        for (Term term:terms) {
            String word = term.getName();
            List<Weight> invertedList = index.getInverted(word);
            if (invertedList == null) {
                //说明这个词在所有文档中不存在
                continue;
            }
            allTermResult.addAll(invertedList);
        }

        //3.排序
        allTermResult.sort(new Comparator<Weight>() {
            @Override
            public int compare(Weight o1, Weight o2) {
                //如果是升序排序：return o1.getWeight() - o2.getWeight()
                //如果是降序排序：return o2.getWeight() - o1.getWeight()
                return o2.getWeight() - o1.getWeight();
            }
        });

        //4.包装结果
        List<Result> results = new ArrayList<>();
        for (Weight weight:allTermResult) {
            DocInfo docInfo = index.getDocInfo(weight.getDocId());
            Result result = new Result();
            result.setTitle(docInfo.getTitle());
            result.setUrl(docInfo.getUrl());
            result.setDesc(GenDesc(docInfo.getContent(),terms)); //描述
            results.add(result);
        }
        return results;
    }

    //生成描述信息
    private String GenDesc(String content, List<Term> terms) {
        //先遍历分词结果，看看结果是否在 content 中存在
        //正文需要先转成小写(重要)
        int firstPos = -1;
        for (Term term:terms) {
            String word = term.getName();
            firstPos = content.toLowerCase().indexOf( " " + word + " ");
            if (firstPos >= 0) {
                //找到了位置
                break;
            }
        }

        if (firstPos == -1) {
            //所有的分词结果不在正文中存在
            //取正文的前 160 个字符作为描述
            return content.substring(0,160) + "...";
        }

        //从 firstPos 作为基准位置，往前找60个字符，往后找100个字符
        String desc = " ";
        int descBeg = firstPos < 60 ? 0 : firstPos-60;
        if (descBeg + 160 > content.length()) {
            //descBeg 位置很靠后面了
            desc = content.substring(descBeg);
        } else {
            desc = content.substring(descBeg,descBeg+160) + "...";
        }
        return desc;
    }
}

在包装结果生成描述的时候，需要注意的是：

前面使用第三方库分词的结果都是小写形式的，所以不可以直接对着内容进行比较，需要先转换成小写才可以
其实需要根据实际的情况，类似于买了一份"老婆饼"，并不可以送一个"老婆"，我们搜索的时候，不能把两个单词由于差不多，就归结于相关性较强，所以在查找单词的时候，可以在前面和后面加上 " "，虽然可能会查询不到在最前面或者最后面，但这毕竟还是少数情况（当然，也可以使用正则表达式去解决这个问题）

7.1.3 验证 DocSearcher类

验证 DocSearcher类

    public static void main(String[] args) {
        DocSearcher docSearcher = new DocSearcher();
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("-> ");
            String query = scanner.next();
            List<Result> results = docSearcher.searcher(query);
            for (Result result : results) {
                System.out.println("====================================");
                System.out.println(result);
            }
        }
    }

我们观察结果可以发现，在有的查询结果中出现了下面的内容：

其实，这个内容就是 JavaScript 的代码，由于在处理文档的时候，只是针对正文进行了 "去标签"，而有的 HTML 里面包含了 script标签，就导致了在去标签过后，JS的代码也被整理到索引里面了，所以查的时候就出现了这个情况~

而这种情况并不科学，因此还需要在后面去掉（可以使用正则表达式）~

7.1.4 修改 Parser类

修改 Parser类（换成使用正则表达式来解决）：

    /**
     * 通过这个方法内部基于正则表达式，实现去除标签，以及 script的效果
     */
    public String parseContentByRegex(File f) {
        //1.先把这个文件都读到 String 里面
        String content = readFile(f);
        //2.替换script标签
        content = content.replaceAll("<script.*?>(.*?)</script>"," ");
        //3.替换普通的 .html标签
        content = content.replaceAll("<.*?>"," ");
        return content;
    }

    private String readFile(File f) {
        try(BufferedReader bufferedReader = new BufferedReader(new FileReader(f))) {
            StringBuilder content = new StringBuilder();
            while (true) {
                int ret = bufferedReader.read();
                if (ret == -1) {
                    //读完了
                    break;
                }
                char c = (char) ret;
                if (c == '\n' || c == '\r') {
                    c = ' ';
                }
                content.append(c);
            }
            return content.toString();
        }catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

此时，就可以验证一下效果如何：

可是，新的看起来也不是很好看（原因是因为空格太多了），我们就可以把多个空格合并成一个即可（同样是使用正则表达式）：

        //4.使用正则表达式，把多个空格合并成一个空格
        content = content.replaceAll("\\s+"," ");

所以在解析正文的时候，就可以使用正则的方式了~

八、实现Web模块

此时，搜索的核心功能都已经实现出来了，但是此时仍然需要提供一个Web接口，以网页的形式，把程序呈现给用户~

因为此时的效果只能是在控制台中进行操作，此时对于普通用户来说并不友好，此时如果想真正的搜索引擎一样，有一个搜索框，有一个搜索按钮......想必这样的界面对于用户来说更加的友好~

要想实现这样的Web模块，需要约定一下前后端通信的接口，需要明确的描述出，服务器都能接受什么样的请求，都能返回什么样的响应的~

前端（HTML+CSS+JS）+ 后端（Java + Servlet/Spring相关）~

针对于这个项目，我们只需要实现一个搜索接口即可~
//约定
//请求：
GET/searcher?query=[查询词] HTTP/1.1

//响应：
HTTP/1.1

[
    {
        title:"这是标题1",
        url:"这是描述1",
        desc:"这是描述1"
    }
]

如果是使用 Servlet 来实现后端的接口的话，第一步需要引入相关的依赖的jar包~

        <!-- 引入 Servlet依赖      -->
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

创建 DocSearchServlet类，基于Servlet来实现后端

//指定当前的路径 和哪个Servlet类对应
@WebServlet("/searcher")
public class DocSearchServlet extends HttpServlet {

    //引入 DocSearcher实例，调用 searcher方法
    private static DocSearcher docSearcher = new DocSearcher();
    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.先解析请求，拿到用户所提交的查询词
        String query = req.getParameter("query");
        if (query == null || query.equals(" ")) {
            //用户的参数是不科学的，一个没有key，一个有key没有value
            String msg = "您的参数非法！没有获得query的值";
            System.out.println(msg);
            System.out.println();
            resp.sendError(404,msg);
            return;
        }

        //2.打印 记录 query的值
        System.out.println("query=" + query);

        //3.调用搜索模块，来进行一下搜索
        List<Result> results = docSearcher.searcher(query);

        //4.把当前的搜索结果进行打包
        resp.setContentType("application/json;charset=utf-8");
        objectMapper.writeValue(resp.getWriter(),results);
    }
}

嗯，最后剩下的就是实现前端页面的部分了，关于这一部分内容，就不细细展开了~

而如果是使用 Spring Boot 来实现后端接口的话，那么可以这样做：

在 controller包下面，创建 DocSearcherController 类：

@RestController
public class DocSearcherController {
    private static DocSearcher = new DocSearcher();
    private ObjectMapper objectMapper = new ObjectMapper();
    
    @RequestMapping("/searcher")
    public String search(@RequestParam("query") String query) throws JsonProcessingException {
        //参数是查询词，返回值是响应内容
        //参数来自于请求query string中的query这个key的值
        List<Result> results = searcher.search(query);
        return objectMapper.writeValueAsString(results);
    }
}

对了，由于在运行的时候，路径会发生错误，因为有两条路径：一条是云服务器上的路径，一条是本地路径~

那么想要在哪里运行的话，就需要去运行哪条路径~

所以，想要更加方便的运行，可以制作一个开关来切换路径~

虽然说在实际开发中不是这样子的，但是这个却是一个更加简单粗暴的方法:

//创建一个Config类
public class Config {
    // 这个变量为 true，表示在云服务器上运行，为 false，表示在本地运行
    public static boolean isOnline = false;
}

//Index类底下

public class Index {
    private static  String INDEX_PATH = null;
    static {
        if (Config.isOnline) {
            INDEX_PATH = "/root/java/doc_searcher_index/";
        }else {
            INDEX_PATH = "E:\\doc_searcher_index\\";
        }
    }
    
    ......
}

//DocSearcher类底下

public class DocSearcher {

    //停用词表的路径
    private static  String STOP_WORD_PATH = null;

    static {
        if (Config.isOnline) {
            STOP_WORD_PATH = "/root/java/doc_searcher_index/stop_word.txt";
        }else {
            STOP_WORD_PATH = "E:\\doc_searcher_index\\stop_word.txt";
        }
    }
    
    ......
}