【从0做项目】Java文档搜索引擎（9）烧脑终章!

阿华代码，不是逆风，就是我疯

你们的点赞收藏是我前进最大的动力！！

希望本文内容能够帮助到你！！

文章导读

阿华将发布项目复盘系列的文章，旨在：

1：手把手细致带大家从0到1做一个完整的项目，保证每2~3行代码都有详细的注解

2：通过文字+画图的方式，对项目进行整个复盘，更好的理解以及优化项目

3：总结自己的优缺点，扎实java相关技术栈，增强文档编写能力

零：项目结果展示

项目目前已经上线，小伙伴们可以进行使用！！！

Java 文档搜索

简述：在我的搜索引擎网站，用户进行关键字搜索，就可以查询到与这个关键字相关的java在线文档，（包含标题，关键字附近的简述，url），用户点击标题，即可跳转到相关在线文档，适用于JDK17版本。

一：导入

在前文（8）中我们使用停用词表对用户的搜索词句进行了过滤，并且在后端处理正文描述的时候使用正则表达式进行优化，让返回结果更加合理。本篇文章将会有点烧脑~

二：问题引入

1：情景引入

这里我们同样搜索array空格list

惊奇的发现array这个文档返回了两次，什么鬼~~！！

2：思考

为什么一个文档会返回两次。想后端处理逻辑，我们拿到array这个词，在倒排索引中返回一堆docId；再拿到list这个词，再在倒排索引中返回一堆docId

注：（这里拿到的其实是一个集合，里面有好多Weight对象，对象里包含docId和weight权重，这里这么说是方便大家理解）

思考：那有没有一种可能就是说，一个文档中既包含array，又包含list，所以这个文档被查到了两次，就返回给前端两遍，显然，这种情况是非常有可能的！！

不多bb直接上图，这里图解可能更清楚。

3：处理设计

（1）问题总结

①一个文档不能出现两次

②像Array.html这样的文档，同时包含多个分词结果，意味着这个文档的“相关性”更高——所以就应该提高这个文档的权重！！

设计

（2）设计

①去重：把多个分词结果触发出来的文档，按照docId进行去重

②权重合并

（3）核心思路

①把分词结果进行排序处理（按照docId升序排序）

②对于docId相同的情况，进行权重的相加

注意：这里的分词结果可能不止两个，当有多个的时候，每一个分词都对应一个list集合，这里就是多路数组的归并了。

这里不理解的看下面这个图文字

不多bb上图理解

三：代码讲解

1：search方法

不要捉急，我们一点点的看代码

在search方法中我们使用mergeResult方法来进行合并，这里的参数传递，可以理解成把所有查到的docId相关文档作为参数进行传参，实际上传的是一个双重集合，这个集合中装的全都是Weight对象

    public List<Result> search(String query){
        //1：对query分词
        List<Term> oldTerms = ToAnalysis.parse(query).getTerms();//未过滤的分词结果集合
        List<Term> terms = new ArrayList<>();//过滤后的分词结果集合
        //针对分词结果，使用暂停词表进行过滤
        for(Term term : oldTerms){
            if(stopWords.contains(term.getName())){
                continue;
            }
            terms.add(term);
        }
        //2：对分词查倒排
        List<List<Weight>> termResult = new ArrayList<>();
//        List<Weight> allTermResult = new ArrayList<>();
        for (Term term : terms){
            String word = term.getName();
            List<Weight> invertedList = index.getInverted(word);//如果查不到就返回一个null
            if(invertedList == null){
                continue;
            }
//            allTermResult.addAll(invertedList);//把集合中所有Weight对象都扔到allTermResult中
            termResult.add(invertedList);
        }
        //3:[合并]对多个分词结果处发出的相同文档，进行权重合并
        List<Weight> allTermResult = mergeResult(termResult);

        //4: 按权重降序排序
        allTermResult.sort(new Comparator<Weight>() {
            @Override
            public int compare(Weight o1, Weight o2) {
                return o2.getWeight() - o1.getWeight();//降序排列
            }
        });
        //5:查正排,构造出想要的Result，返回结果
        List<Result> results = new ArrayList<>();
        for(Weight weight : allTermResult){//对每一个Weight都构建result,可能最后的结果会很多，但是用户一般只看第一页查询出来的信息，一般懒得翻页
            DocInfo docInfo = index.getDocInfo(weight.getDocId());//获取当前Weight对应的文档信息
            Result result = new Result();
            result.setTitle(docInfo.getTitle());
            result.setUrl(docInfo.getUrl());
//            result.setDesc(docInfo.getContent());//很明显把正文全部返回不合理
            result.setDesc(GenDesc(docInfo.getContent(),terms));//搞个正文简述，这个词前60个字符为起始，往后截取160个
            results.add(result);
        }
        return results;
    }

2：mergeResult

（1）Pos定位类

用来描述，我们Weight对象所在的位置

    static class Pos{
        public int row;
        public int col;
        public Pos(int row , int col){
            this.row = row;
            this.col = col;
        }
    }

（2）看图说话

搞一个优先级队列，比较规则就是，docId值更小的往里面放

（3）步骤拆解

①对每一路按docId的升序给Weight对象排个序

②new一个集合用来存放最后的Weight对象的合集

③把每一行的第一个元素放进队列中（初始化）

④优先级队列的比较规则是docId升序排列，放的是Pos对象也就是Weight对象的位置！！

⑤当队列不为空时，循环弹出元素Pos，找到对应的Weight对象，将这个Weight对象与我们target集合中最后一个位置的Weight对象进行对比看是不是同一个对象，若不是则直接加入集合，若是则合并权重。

⑥指针移动

喵喵喵~~妙脆角！跟着我的注解，看着图，敲一遍代码会更清楚内部的一个逻辑！

 private List<Weight> mergeResult(List<List<Weight>> source) {
        //把多路合并成一路
        //1:先给每一路按升序排个序
        for (List<Weight> curRow : source){
            curRow.sort(new Comparator<Weight>() {
                @Override
                public int compare(Weight o1, Weight o2) {
                    return o1.getDocId()- o2.getDocId();
                }
            });
        }
        //2:借优先级队列合并多路
        List<Weight> target = new ArrayList<>();
        PriorityQueue<Pos> queue = new PriorityQueue<>(new Comparator<Pos>() {
            @Override
            public int compare(Pos o1, Pos o2) {
                Weight w1 = source.get(o1.row).get(o1.col);//用下标找到Weight对象
                Weight w2 = source.get(o2.row).get(o2.col);
                return w1.getDocId() - w2.getDocId();
            }
        });
        //2.1:初始化队列——把每一行第一个元素放到队列当中
        for(int row = 0 ; row < source.size() ; row++){
            queue.offer(new Pos(row,0));
        }
        //2.2:循环取队首元素（也就是当前若干行中最小的元素）
        while(!queue.isEmpty()){
            Pos curMinPos = queue.poll();
            Weight curWeight = source.get(curMinPos.row).get(curMinPos.col);

            //2.3：检查当前的Weight对象，与上一个插入到target中的对象是否是相同的对象，这里可以用Weight对象中的docId作为比较依据
            if(target.size() > 0){
                Weight lastWeight = target.get(target.size()-1);
                if(lastWeight.getDocId() == curWeight.getDocId()){
                    //文档id若相等则合并
                    int weightSum = lastWeight.getWeight() + curWeight.getWeight();
                    lastWeight.setWeight(weightSum);
                }else{
                    //文档id不相等就直接入target
                    target.add(curWeight);
                }
            }else{
                //若当前的target为空，就直接加入
                target.add(curWeight);
            }

            //2.4:考虑移动光标，当前元素处理完了之后，要把对应的这个元素光标往后移动，取这一行的下一个元素
            Pos newpos = new Pos(curMinPos.row , curMinPos.col+1);
            if(newpos.col > source.get(newpos.row).size() - 1){
                //说明光标已经超出这一行的范围了，到达末尾了，这一行就处理完了
                continue;//直接进入下一次循环
            }
            //否则把新的坐标扔到队列当中
            queue.offer(newpos);
        }
        return target;
    }