640-倒排索引的理论和实现

桃扇骨 2022-09-12 11:50 40阅读 0赞

## 倒排索引理论 ##

我们在打开百度，或者是谷歌，360浏览器，我们输入关键字以后，浏览器作为客户端把关键字发到对应的搜索引擎的服务器server端，服务器去分析这个关键字，在全网的所有网页html中（几千万，上亿个文件）中快速搜索出我们想要的内容，我们输一个关键字，敲一个回车，很快的所有的搜索结果都出来了，不到1秒的时间内搜索几千万个网页。**为什么搜索这么快？**  
我们在自己的电脑上去搜索一个文件，速度却非常的慢，有时候几十分钟都搜索不出来。  
**为什么搜索引擎的服务器搜索那么多的文件内容很快就可以定位到哪些文件包含这些关键字呢？**  
这都是因为搜索引擎的服务器对全网的页面的内容进行分词，看看有哪些关键字，对这些关键字建立了倒排索引，才能够通过一个关键字进行非常快速的搜索  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]  
**在文件里面进行内容搜索，在一个文件里搜索，在多个文件里搜索共同的内容，都可以用倒排索引！**

## 举个例子 ##

**假如现在我们有2个页面：**  
![在这里插入图片描述][16747eb7f63a4acdac2c0d912276ee3e.png]  
我们可以把它们想象成2个文件，或者是网站上的两个页面，都是包含内容的单位，文档。  
有倒排，就有正排。  
如果我们不给这些数据建立索引的话，当我们去搜索关键字的时候，我们只能是打开一个文件及时的进行搜索，进行字符串的匹配，这样太慢了，我们全网有那么多的html页面，在本地搜索那么多的文件文档，要搜索的时候临时的去打开内容文件进行搜索，这样太慢了。  
首先我们肯定要建索引，给文件文档的内容的这些关键字建索引，所以我们可以建正排索引。

## 正排索引 ##

![在这里插入图片描述][dc2cbccf60d0461194f8edccf9be787a.png]  
**行就是代表文档：p1文档,p2文档**  
![在这里插入图片描述][71e63129ca004453859de5e26541e831.png]  
**列就是代表这些关键字，**![在这里插入图片描述][f2e24572659841e6b533553adc2a7afc.png]  
**1表示i这个关键字在p1出现。以此类推。1就是在所在的文档里是出现的，0就是在所在的文档里是没有出现的，不存在的。**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
**正排索引**：行是文档，列是关键字  
在这个表里通过添加1个标志来表示这个关键字是否在当前文档里出现。  
实际上，我们不仅仅用是否存在来记录1或者0，我们还可以记录i在这个p1文档出现了，具体出现在哪个位置，出现了多少次，这里的1就包含了在p1文档里的详细的信息。  
如果建立正排索引，当我们去搜索“search”这个关键字的时候，实际上，通过正排索引是不能直接知道search这个关键字在哪些文档里面的。  
因为我只能把所有文档去搜索一遍，看这个关键字在这个文档里的标志是1还是0，到底有没有，把所有文档（所有行）都扫描一遍，才知道这个“search”关键字在哪个文档里有，哪个文档里没有。  
实际上，我们想要的一个搜索的过程是：当我们去得到这个关键字的时候，我们去搜索这个关键字，有没有一种方法，直接就知道这个关键字在哪些文档里存在，这才是给这个关键字建立索引的初衷啊，这样，建索引的优势就发挥出来了。所以，我们采用的是倒排索引结构。

## 倒排索引 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
**倒排和正排，刚好是行列反转了。  
倒排：行是单词，列是文档。**  
**右边这个图是对左边这个图的简写。**  
![在这里插入图片描述][f8d93e9ac77847b58094fb2cd274f92a.png]  
**有了这个倒排索引，当我们去搜索“search”的时候，就一下子知道它在P1,P2文档存在，其他文档我们就不用去搜索了。**  
当我们要做一个搜索引擎，通过网络爬虫把全网的很多页面都爬出来了，爬出来的页面就是文档，如何给用户提供快速的搜索服务呢？  
我们把这些文档的内容，比如说先不考虑中文，把英文的每个单词抽取出来，这就是关键字，给这些关键字建立倒排索引，也就是说，创建这么一张表，即这么一种关系，知道这些关键字都在哪些文档存储着呢。1表示存在，0表示不存在。![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_13_color_FFFFFF_t_70_g_se_x_16]  
当我们搜索“engine”的时候，就直接给出：在P1这个文档里面  
当我们搜索“google”的时候，就直接给出：在P2这个文档里面  
**倒排索引结构里，可以不仅仅存储一个在或者不在这个状态，还可以存一些关键字，作为在这个文档里的简要的描述信息，就是把这个关键字的前后一些数据，字符都保存起来。**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
**我们输入的关键字是“软件工程”，我们发现，越往前排列显示的越重要，越热点，越相似。**  
我们不仅仅会存：在这个文档里在不在，还可以存这个关键字在这个文档里出现的次数（就是频率）![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_13_color_FFFFFF_t_70_g_se_x_16]  
出现的频率越高，说明这个文档和搜索的关键字的匹配度越高，所以在结果呈现的时候，这个文档会优先给用户呈现出来，可能还会存储一些位置信息，甚至存储一些简要描述，在搜索页面给用户呈现。实际上，存储位置就可以了，存这个关键字在这个文档里的第几行，当显示的时候，直接读这个文件的第几行以及上面的两三行信息显示出来就可以了，快速检索！  
**如果有很多的文件，文件里有很多很多内容，在文件搜索关键字相关的一些问题，我们就要想想能否使用到倒排索引，来加速我们的文件的搜索，尤其是文件数量特别大的时候，倒排索引就是专门去解决这样的问题的。**

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_12_color_FFFFFF_t_70_g_se_x_16]  
**倒排索引结构的左边这一部分叫做：词典。**  
**包含了所有文档抽取出来的关键字**  
![在这里插入图片描述][785a6dda5f2f46b3baf315cbfb33f948.png]  
**也是我们用户搜索的关键字。**  
实际上，真真正正的搜索引擎在这里面处理是比较复杂的，因为这些关键字是有大小写的，不能说是建立了一个i，只能搜小写i，大小I就不能搜。大小写相当于是同一个意思的  
**所以我们要把大小写归为一类。  
比如说像“like"，它还有一些近义词，不能说不是同一个单词就不是关键字，近义词也是可以搜索的。  
还有就是单数和复数，不能说是只认“like”，不认“likes"，当我们搜”like“的时候，”likes“也是得要匹配上的。**  
这些都是搜索引擎要考虑的。  
这一切东西都需要在倒排索引结构中处理  
**倒排索引结构的右边这一部分叫做：倒排项。**  
![在这里插入图片描述][32d4f68ef1b44cd1918ca59e46c002b2.png]  
**这里面只写了文档，还可以存储单词出现的次数或者位置信息。**  
**这多个倒排项组成的一行一行的叫做倒排列表**  
![在这里插入图片描述][81c6b04fa7e44a61872db2e08fdbd0d3.png]  
![在这里插入图片描述][f9f4a0f0d30f4c0c93a2865409426c14.png]  
是词典  
![在这里插入图片描述][06475ece7b0b4dfe907c05adec22d58b.png]  
是倒排项  
**一个关键字的所有倒排项称作这个关键字的倒排列表**  
大家可以想象，全网中1亿个html文件，每一个html文件包含了甚至上万个关键字，那么这个词典跟这个倒排列表是相当庞大的，**所以，我们一般把这些东西（词典，倒排列表）都是存在磁盘上的。**  
存在磁盘上的数据可以进行快速的读取，我们应该把磁盘上的数据读出来，组织在B+树上，磁盘I/O次数少，搜索速度快，我们实际使用倒排索引的时候，我们直接把倒排索引存到数据库就可以了，关系型数据库天然的实现了磁盘的读取，B+树的结构，我们就不用自己实现了。

## 倒排索引结构分析 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
**词典：从文件里面抽取出来的所有的分词，有中文的，有英文的，有同义词的，有近义词的，有单数复数的，这些都是需要归类的。  
每一个词典里的每一个关键字都有它对应的倒排项：在哪个文档里啊，出现了多少次啊，在哪些位置啊。  
一个关键字的多个倒排项合起来就叫做：倒排列表（最终存储在磁盘上）**  
**磁盘上的文件保存了所有的倒排列表：叫做倒排文件**

**当我们去搜索“search”的时候**，首先从词典中找到“search”，然后就直接就可以找到“search”对应的倒排列表了，![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
在倒排列表里面，我们拿了2个倒排项：P1和P2，  
这2个倒排项给用户呈现结果的时候，是怎么样呈现的？  
我们的倒排项里有：词频。词频高的往前放，比如说，“search”在P1里出现了3次，在P2里面出现了5次，所以我们就把P2先呈现，先呈现P2文档的链接，甚至可以把P2文档包含的这个“search”关键字的一些前后的简要信息呈现出来，然后再呈现P1。

再比如说，我们用户搜索的是“search google”，搜索了2个关键字。  
这2个关键字首先对于搜索引擎来说，会把它们分开，分别找“search”和“google”的倒排列表，  
先搜索“search”，直接找见其对应的倒排列表：P1,P2  
然后搜索“google"，直接找到其对应的倒排列表：P2  
然后因为用户搜索的是“search google”，此时搜索引擎分别找到这2个关键字对应的倒排项后，会对这2个关键字的倒排项进行取交集。这个交集就是P2  
![在这里插入图片描述][9853bb7fe0374a8a9931a6518d2cffca.png]  
**也就是说，只有在P2这个文档里，既包含了search，又包含了google**  
**所以优先呈现的是P2了。**  
首先呈现的是最匹配的，然后呈现的那些文档可能就只包含了用户搜索的关键字的其中几个。根据匹配度进行结果的呈现。  
实际上，在罗列的时候，更加严格，因为取交集以后，人家用户搜索的是search google这2个关键字是在一起连着的，虽然取的是交集-包含了search和google的文档P2，但是在P2文档中，search和google可能不是连在一起的 ，不在一块，没有组成1个句子的，此时，它怎么去分辨？假如说，交集的结果是有很多个文档，怎么办？它首先在这些文档看， 看一下search和google在这个文档里的位置，有没有哪一个位置是前后的，比如说，search是10，google是11，就说明这2个关键字是连续出现的，和用户的搜索的匹配度是最高的，就优先呈现，而且关键字的前后的备注信息，就是从这2个词的前后拿一些信息作为搜索结果呈现的摘要信息。  
**倒排项经常必须有的就是**：文档编号，词频，在文档的位置

## 倒排索引的代码实现 ##

**我们在源文件当中搜索包含指定的关键字都在哪些Java源文件中，我们把D盘中的Java源文件当中搜索的文件，对象，如何快速搜索文件的内容。**

package com.fixbug;
    
    
    import java.io.*;
    import java.lang.reflect.Array;
    import java.util.*;
    
    /**
     * 倒排项的实现
     */
    class InvertTerm{
        
        private int docid;//标识文档
        private int freqs;//单词词频
        private List<Integer> locations;//存储单词的位置
    
        /**
         * 初始化
         * @param docid
         * @param freqs
         * @param location
         */
        public InvertTerm(int docid, int freqs, int location) {
        
            this.docid = docid;
            this.freqs = freqs;
            this.locations = new ArrayList<>();
            this.locations.add(location);
        }
    
        public int getDocid() {
        //获取文档的标识
            return docid;
        }
    
        public void setDocid(int docid) {
        //设置文档的标识
            this.docid = docid;
        }
    
        public int getFreqs() {
        //获取单词词频
            return freqs;
        }
    
        public void setFreqs(int freqs) {
        //设置单词词频
            this.freqs = freqs;
        }
    
        public List<Integer> getLocations() {
        //获取单词的位置
            return locations;
        }
    
        public void setLocations(List<Integer> locations) {
        //设置单词的位置
            this.locations = locations;
        }
    
        /**
         * 通过docid比较两个倒排项是否相同
         * @param obj
         * @return
         */
        @Override
        public boolean equals(Object obj) {
        //通过docid比较两个倒排项是否相同
            return this.docid == ((InvertTerm)obj).docid;
        }
    
        public void increaseFreqs() {
        //增加词频
            this.freqs++;
        }
    
        public void addLocation(int location) {
        //添加单词的位置信息
            this.locations.add(location);
        }
    }
    
    /**
     * 倒排列表定义 = 由单词的所有倒排项组成
     */
    class InvertList{
        
        private List<InvertTerm> invertList;//存储单词的所有倒排项
    
        public InvertList() {
        //构造函数
            this.invertList = new ArrayList<>();
        }
    
        /**
         * 添加倒排项
         * @param docid
         * @param location
         */
        public void addTerm(int docid, int location){
        
            for (int i = 0; i < this.invertList.size(); i++) {
        
                InvertTerm term = this.invertList.get(i);
                if(docid == term.getDocid()){
        
                    //docid对应的倒排项已经存在
                    term.increaseFreqs();//增加词频
                    term.addLocation(location);//增加单词位置信息
                    return;
                }
            }
    
            //没有搜索到倒排项，搜索的是一个新文档，包含了这个关键字，所以给单词添加一个倒排项
            InvertTerm term = new InvertTerm(docid, 1, location);
            this.invertList.add(term);
        }
    
        /**
         * 获取倒排项集合
         * @return
         */
        public List<InvertTerm> getInvertTermList() {
        
            return this.invertList;
        }
    }
    
    /**
     * 倒排索引的实现
     */
    class InvertIndex{
        
        private Map<String, InvertList> invertIndex;//倒排索引
        private List<File> fileList;//存储所有待搜索的文件
        private String path;//指定的文件搜索根路径
        private String keywords;//用户输入的搜索关键字&句子
        //我们实现的是用空格隔着
        public InvertIndex() {
        //初始化
            this.invertIndex = new HashMap<>();
            this.fileList = new ArrayList<>();
        }
    
        /**
         * 设置文件根路径
         * @param path
         */
        public void setSearchPath(String path) {
        
            this.path = path;
    
            //搜索path路径下的所有文件
            searchFiles(new File(path));
            System.out.println(path + " 路径下的文件搜索完毕!");
    
            //开始创建倒排索引
            createInvertIndex();
            System.out.println("倒排索引生成完毕!");
        }
    
        //搜索文件
        private void searchFiles(File file) {
        
            File[] files = file.listFiles();
            if(files == null){
        
                return;
            }
            for(File f : files){
        
                if(f.isDirectory()){
        //没有搜到
                    searchFiles(f);//继续递归搜索
                } else {
        //找到了
                    if(f.getName().endsWith(".java")) {
        
                        this.fileList.add(f);
                    }
                }
            }
        }
    
        /**
         * 开始创建倒排索引
         */
        private void createInvertIndex() {
        
            //1. 读取所有的文件fileList
            String line = null;
            int number = 0;
    
            try {
        
                for (int i = 0; i < this.fileList.size(); i++) {
        
                    File file = this.fileList.get(i);//一行一行的读
                    BufferedReader reader = new BufferedReader(new FileReader(file));
                    number = 0;//读取一个文件，把文件一行一行读出来，读完一个文件置为0，记录一个文件里单词的序号
                    while(null != (line = reader.readLine())){
        //没有读完
                        String[] words = line.split(" ");//用空格分割
                        for (String word : words) {
        
                            word = word.trim();//去掉单词前后无效的空格
                            number++;//单词个数
                            InvertList it = invertIndex.get(word);//获取单词是不是对应倒排列表
                            if(it == null){
        
                                it = new InvertList();//创建单词word的倒排列表
                                it.addTerm(i, number);
                                this.invertIndex.put(word, it);//把[单词，倒排列表]添加到倒排索引当中
                            } else {
        //倒排表原先存在
                                it.addTerm(i, number);
                            }
                        }
                    }
                }
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    
        /**
         * 基于倒排索引提供搜索服务的接口
         * @param phrase
         */
        public void query(String phrase){
        
            //把用户输入的句子进行单词分解
            List<String> wordsList = new ArrayList<>();
            String[] words = phrase.split(" ");//空格分割开
            for (int i = 0; i < words.length; i++) {
        
                String word = words[i].trim();//去掉单词前后无效的空格
                wordsList.add(word);
            }
    
            if(wordsList.size() == 1){
        //搜索一个单词
                InvertList il = this.invertIndex.get(wordsList.get(0));//获取唯一的单词
                if(il == null){
        
                    System.out.println("未搜索到任何相关的文件!");
                } else {
        
                    //输出搜索的结果
                    List<InvertTerm> termList = il.getInvertTermList();
                    for (int i = 0; i < termList.size(); i++) {
        
                        File file = this.fileList.get(termList.get(i).getDocid());
                        System.out.println(file.getName() + " 词频:" + termList.get(i).getFreqs());
                    }
                }
            } else {
        //搜索多个单词
                //创建存储多个单词倒排列表的数组
                InvertList[] invertLists = new InvertList[wordsList.size()];
                for (int i = 0; i < wordsList.size(); i++) {
        
                    invertLists[i] = this.invertIndex.get(wordsList.get(i));
                }
    
                //给上面的倒排列表数组中，所有的倒排项求交集
                List<InvertTerm> termsList = invertLists[0].getInvertTermList();//获取第0个倒排列表的倒排项
                for(int i=1; i < invertLists.length; ++i){
        
                    List<InvertTerm> tl = invertLists[i].getInvertTermList();//获取下一个倒排列表的倒排项
                    termsList.retainAll(tl);//求交集
                }
    
                if(termsList.isEmpty()){
        
                    System.out.println("未搜索到任何相关的文件!");
                } else {
        
                    //输出搜索的结果
                    for (InvertTerm invertTerm : termsList) {
        
                        File file = this.fileList.get(invertTerm.getDocid());
                        System.out.println(file.getName() + " 词频:" + invertTerm.getFreqs());
                    }
                }
            }
        }
    }
    
    /**
     * 倒排索引代码测试
     */
    public class InvertIndexTest
    {
        
        public static void main( String[] args )
        {
        
            Scanner in = new Scanner(System.in);
            System.out.println("输入搜索根路径:");
            String path = in.nextLine();
    
            InvertIndex index = new InvertIndex();
            index.setSearchPath(path);
    
            for(;;){
        
                System.out.println("输入搜索的内容:");
                String words = in.nextLine();
                index.query(words);
            }
        }
    }

![在这里插入图片描述][7794d0c49af94a029b51044e346dc0e2.png]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 6]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 7]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/6ff0ed117c4843d799b08b0a0181f9ea.png
[16747eb7f63a4acdac2c0d912276ee3e.png]: /images/20220828/d29904c401e54fffa45e359fd4f0733f.png
[dc2cbccf60d0461194f8edccf9be787a.png]: /images/20220828/2fa472ce38c645469b875248238e12c3.png
[71e63129ca004453859de5e26541e831.png]: /images/20220828/1256dc255bdb45cf94e9ac1f849ae95b.png
[f2e24572659841e6b533553adc2a7afc.png]: /images/20220828/8da12a275d08480f8434b95171a524bd.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/1bb3e3f0e2a545fda6aa1b0d9f32435e.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/e30f62fcfe20478ab92015c7ca49b8f0.png
[f8d93e9ac77847b58094fb2cd274f92a.png]: /images/20220828/12f957a601fb4dce8f0167de5ce7f5e7.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_13_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/0461639a7f2d43cca3758f4793fdd675.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/783b91ec348441a3998acaac9a9ff311.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_12_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/621dc2aff0eb4b5d913175a97279608f.png
[785a6dda5f2f46b3baf315cbfb33f948.png]: /images/20220828/c809e29c29ba4ec388e32a37f35e5558.png
[32d4f68ef1b44cd1918ca59e46c002b2.png]: /images/20220828/3a8a07f8904d4d948b62209fb315e2dc.png
[81c6b04fa7e44a61872db2e08fdbd0d3.png]: /images/20220828/5dad07e431ce46a4872d2f44d52899b8.png
[f9f4a0f0d30f4c0c93a2865409426c14.png]: /images/20220828/1ebeebed9d794cabb61ceec0dbeffc9f.png
[06475ece7b0b4dfe907c05adec22d58b.png]: /images/20220828/ada4598e9f064902a395d6b4bf513fc9.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220828/eb2fd897df9e4db0a13b685c64bafb4a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220828/79d6eaef37f0471b8e6bbf527b5eb3ce.png
[9853bb7fe0374a8a9931a6518d2cffca.png]: /images/20220828/0ea84f7e0ab24888aca2475de7432ab8.png
[7794d0c49af94a029b51044e346dc0e2.png]: /images/20220828/994711948a73428c9ab96e0c39f36c04.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220828/9bd8bf4bf41a4c0c9d8c29a53fdfad12.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220828/7753109abbf2438a9d342786e4a34976.png