敏感词汇过滤

敏感词汇过滤功能(DFA算法)

作者：MrKay

说明：

个人网站虽然已经部署成功,但是仍然有一些东西没有考虑到,这里介绍对数据库安全，对评论敏感词汇过滤的一些知识点，也是对自己学习的总结；（评论功能其实很简单，就是将评论数据写入到评论数据库表，评论数据库表中记录着该评论的博客文章id，这其实不是难点，难点是对数据库的设计，因为评论者A可能会对评论者B进行回复，这就牵扯到子父关系，数据库设计时就需要添加自关联）

技术：DFA算法、MySQL、SpringData Jpa、SpringBoot等

时间:2020 年

1 问题分析

1.1 访客评论

1.1.1 敏感内容

评论虽然可有可无，但是有总比没有强，评论者的素质有高有低，一些辱骂和政治敏感词汇就不能将其写入到数据库，更不能将其展示在页面上。但是一些好的建议和友好的评论则需要写入数据库，并展示在页面上。该怎么解决？？？

1.1.2 频繁写入

因为数据库的读写速率和个人服务器的承受能力有限，如果访客存在频繁评论，这就会导致数据库面和服务器面临崩溃。所以限制访客的恶意频繁写入评论也是很有必要的。该怎么解决？？？

1.2 敏感词

1.2.1 敏感词存储

既然要进行敏感词汇的过滤，就需要实现准备好敏感词汇，因为敏感词汇是不断增加的，所以是存储到数据库中还是以其他形式进行存储是需要考虑的问题；该怎么解决？？？

2 解决分析

2.1 敏感词存储方案

1 通过数据库存储

评论数据相对于文章等其他数据不是特别重要,但是需要考虑到的是如果存储到数据库,就需要不断地从数据库中频繁进行读写操作,对数据库性能消耗很大;

MySQl: 不太可行, 只使用MySQL数据库方案不妥,原因上面已经说过了;

MongoDB: 还行,MongoDB是一款介于关系型和菲关系型数据库之间的分布式文件存储数据库,读写速率很有优越,如果使用它存储敏感词汇,后台数据封装和解析可能会有点麻烦,因为敏感词汇只是一行一行的数据;

MySQl+Redis: 可行, 将数敏感词汇存储到MySQL数据库,并将词汇在Redis中做缓存,后期从缓存中读取数据; 原因:Redis读取速率比MySQL快的多,但是数据安全却没有MySQL高,结合使用扬长避短;

2 文本存储

txt文本:还可行, 直接使用txt文本或者配置文件的方式,这样敏感词汇就不需要存储到数据库,避免了数据库读写操作,数据库性能会有所提高,但是需要对该文本进行频繁的I/O操作后期更新词库相对麻烦;

2.1.1 我的解决方案

存储方式：

我使用txt文本进行存储敏感词汇.

原因说明:

因为我的个人网站只是用于自己的学习和笔记总结,访客很少,留言也比较少,更新词库的时候也比较少,相比之下,我更多考虑的是个人服务器的性能和数据库压力问题。使用IO读取文本中数据虽然不是最好的解决方式，但是对于我来说足够了。

备注：

如果项目中使用到IKAnalyzer中文分词器， 也可以考虑使用IKAnalyzer进行敏感词汇过滤；

IKAnalyzer参考链接：

官网： https://code.google.com/archive/p/ik-analyzer/

网友博客：https://www.cnblogs.com/magicalSam/p/7473791.html

2.2 频繁写入解决方案

频繁写入其实就是恶意写入，也就是单位时间内突然写入很多条数据（往往是开启多线程之后机器写入）另一种恶意写入就是机器性的一直写入，这样就使得你数据库的东西越来越多，并且没有一点用处没有。

1 前端后台验证码校验

这种方案需要在填写评论的时候手动输入生成的验证码，才能提交，并在提交之后重新刷新验证码，后台判断验证码是否输入有误，有误则不能评论，这样就避免了频繁写入的操作。这也是一种比较理想的解决方案。（如果是人工一直手动输入填写验证码在那频繁评论，那只能证明Ta对我的博客爱的太深，Ta有大把时间我也没啥说的了…）

2 后台限制

这里的后台限制其实就是，通过获取本篇博客下评论的条数，当该博客评论的条数达到一定数量之后就限制评论，无论谁都不能再进行评论。这种方式太粗暴了，但确实能解决问题。

2.2.1 我的解决方案

方案：我采用的是后台限制这种暴力方式；

原因说明：

还是那句话，个人网站仅用于学习和记录生活，访客较少，留言较少。另一方面，个人前端页面开发能理有限。所以专注于后台代码的开发。

这里虽然没有使用理想方案，但是我做了一个生成验证码的工具类（Java版），注释详细：（网上这种工具类很多）

package show.mrkay.utils;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @Author MrKay
 * @program: Utils
 * @description: 验证码生成工具
 */
public class VerifyCodeUtil {
    /*
    生成验证码图片;以验证码内容
     */
    public static List<Object> getVerifyCodeImage() {
        //设置图片大小
        int length = 200;
        int height = 100;
        //1.创建一对象，验证码图片对象
        BufferedImage image = new BufferedImage(length, height, BufferedImage.TYPE_INT_RGB);
        //2.美化图片，填充背景色
        Graphics gra = image.getGraphics();
        //设置背景填充颜色
        gra.setColor(Color.black);//设置填充颜色
        gra.fillRect(0, length, 0, height);//设置填充范围
        //设置字体、加粗、斜体、大小
        gra.setFont(new Font("宋体", Font.BOLD | Font.ITALIC, 40));
        //设置字体的随机颜色数组
        Color[] colors = new Color[]{Color.YELLOW, Color.pink, Color.BLUE, Color.GREEN, Color.white, Color.RED};
        //创建要出现的验证码字符串
        String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890";
        //随机生成验证码内容
        Random random = new Random();
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 4; i++) {
            //生成随机角标索引
            int index = random.nextInt(str.length());
            //获取随机字符
            char c = str.charAt(index);
            //追加内容
            sb.append(c);
            //设置随机字符的字体随机颜色
            gra.setColor(colors[random.nextInt(colors.length)]);
            //写验证码,以及验证码应该出现的位置
            gra.drawString(c + " ", length / 5 * i, height / 2);
        }
        //画5条干扰线，防止被别人破解
        for (int i = 1; i <= 5; i++) {
            //随机生成x1点和x2点的横坐标位置
            int x1 = random.nextInt(length);
            int x2 = random.nextInt(length);
            //随机生成y1点和y2点的纵坐标位置
            int y1 = random.nextInt(height);
            int y2 = random.nextInt(height);

            //画干扰线，设置随机颜色
            gra.setColor(colors[random.nextInt(colors.length)]);
            gra.drawLine(x1, y1, x2, y2);
        }
        List<Object> list = new ArrayList<>();
        //添加验证码和验证码内容
        list.add(image);
        list.add(sb.toString());
        return list;
    }

    /*
    将验证码图片输出
     */
    public static void printCodeImage(BufferedImage image, HttpServletResponse response) throws IOException {
        //将图片输出到页面展示
        ImageIO.write(image, "jpg", response.getOutputStream());
    }
}

2.3 敏感内容解决方案（重头）

2.3.1 头绪

小的问题思路已经分析透彻了，接下来就到了重点中的重点：评论的敏感内容该怎么过滤？？有没有较好的解决方式？

这些问题一直在我脑子里挥之不去，就连手里的馒头辣条都瞬间不香了~~~如果这个问题不解决，那前面分析的种种都TM泡汤了，终究还会成为“纸上谈兵”。

没办法，刚接触这个问题，第一时间想到的就是一行行的读取txt文本中的数据，读一行判断该敏感词是不是在评论里面，大致核心代码就是这样的：

String comment = "爸爸我好难啊";
String sensitiveWord = "我好难";
int result = comment.indexOf(sensitiveWord);//返回-1代表不包含

这种做法实在是太low了。？。。这要判断到猴年马月啊。。？。。。。。？

…谷歌…百度…ing

他来了！他来了！他带着思路走来了！

感谢马爸爸的云栖社区~~~ 这是链接：https://yq.aliyun.com/articles/322464>

马爸爸给我提供了一个思路就是使用DFA算法来完成敏感词的过滤。

2.3.2 DFA算法

啥 是DFA算法 ?

定义:

DFA全称为：Deterministic Finite Automaton,即确定有穷自动机。其特征为：有一个有限状态集合和一些从一个状态通向另一个状态的边，每条边上标记有一个符号，其中一个状态是初态，某些状态是终态。但不同于不确定的有限自动机，DFA中不会有从同一状态出发的两条边标志有相同的符号。

…反正我读到这段话越读越蒙~…似懂非懂…???

结果在阿里云栖社区看到这样的一篇文章 这是链接：https://yq.aliyun.com/articles/322464

里面介绍到:DFA算法简单的说就是:

它是是通过event和当前的state得到下一个state，即event+state=nextstate。理解为系统中有多个节点，通过传递进入的event，来确定走哪个路由至另一个节点，而节点是有限的。

这样一句话就是大白话了,我来按照我的理解举个简单的例子吧。

DFA算法举例理解：（敏感词库查询过程）

先简单理解为DFA算法就是一个很智能的机器人，它能够负责对写有不同内容的纸牌进行规律存放，这时候它已经完成了对写有 “你” 、“是” 、“个” 、“王”、“八”、“蛋”、“羔”、“子”的存储过程。具体结构可以参考阿里云栖社区的参考链接中存储图示；

这时候你拿着“王”、“八”、“好” 的这样四个纸牌去找这个机器人让他给你查找你的这里面有多少是在仓库里面的。首先该机器人就会先拿到你的第一章“王” 他一分析你的这个字就判断出是不是有这样一个字有的话就直接定位到哪里接着看这个字在仓库中不是已经在仓库的最后一个位置存放着,如果是就结束查找了,如果不是就再次判断你的这个字是不是给到他的最后一个字,如果是,结束,如果不是,继续获取你的下一张纸牌"八" 重复之前的步骤继续查找;

以上介绍的是他的关键字查询过程,想要查询那前提就是仓库中需要有数据,这就涉及到仓库的初始化问题了,也就是将敏感词存储到仓库中:(初始化词库)

在存储的过程中,将你的敏感词读取出来存存放到Set集合中,这一步是为了去重;然后使用while循环去除set集合中的敏感词,通过for循环遍历这个敏感词的每一个字符将它存储到Map集合中(key存储的是该字符,value存储的是另一个新的Map集合),如果存储的字符是最后一个则在Map集合中存储结束标志,不是也存储不是最后一个字符的标志.

以上文字说明没有明白问题不大，后面看了我的实现步骤的代码也就明白了！

2.4 我的敏感词过滤实现步骤（实现DFA算法）

2.4.1 初始化敏感词库

个人网站中我将初始化词库的代码封装成了一个类,并将其加入了IOC容器，代码如下

import org.springframework.stereotype.Component;

import java.util.*;
/**
 * @program: blog
 * @description: 初始化敏感词库,就是搭建一个仓库
 * @create: 2020-05-12 15:47
 */
@Component
public class SensitiveWordInit {
    /**
     * 创建敏感词库
     */
    private HashMap sensitiveWordMap;

    /**
     * 初始化敏感词库
     */
    public Map initSensitiveWord(List<String> sensitiveWordList) {
        try {
            //遍历List集合对象,并将敏感词去重存储到set集合中
            HashSet<String> sensitiveWordSet = new HashSet<>();
            for (String sensitiveWord : sensitiveWordList) {
                //截取掉首尾空格将敏感词添加进去
                sensitiveWordSet.add(sensitiveWord.trim());
            }
            this.addSensitiveWord2Map(sensitiveWordSet);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sensitiveWordMap;
    }

    /**
     * 将敏感词汇添加到词库容器sensitiveWordMap中;
     * @param sensitiveWordSet
     */
    private void addSensitiveWord2Map(Set<String> sensitiveWordSet) {
        //初始化敏感词库的大小
        sensitiveWordMap = new HashMap(sensitiveWordSet.size());
        //初始化敏感词为null
        String key = null;
        //初始化当前敏感词库为null
        Map nowMap = null;
        //初始化辅助敏感词库
        Map<String, String> newMap = null;
        //迭代器遍历敏感词Set集合
        Iterator<String> iterator = sensitiveWordSet.iterator();
        while (iterator.hasNext()) {
            //赋值key敏感词
            key = iterator.next();
            //nowMap地址指向sensitiveWordMap
            nowMap = sensitiveWordMap;
            //遍历敏感词长度
            for (int i = 0; i < key.length(); i++) {
                //取出第i个char
                char keyChar = key.charAt(i);
                //判断该char是不是已经存在与当前词库中
                Object wordMap = nowMap.get(keyChar);
                if (wordMap != null) {
                    //存在,用此wordMap替换nowMap
                    nowMap = (Map) wordMap;
                } else {
                    //不存在就在nowMap中存(key是keyChar,value是)
                    newMap = new HashMap<String, String>();
                    newMap.put("isEnd", "0");
                    nowMap.put(keyChar, newMap);
                    nowMap = newMap;
                }
                //如果当前char是敏感词的最后一个字,存放标识为结尾字
                if (i == key.length() - 1) {
                    nowMap.put("isEnd", "1");
                }
                //输出查看敏感词存储过程
                // System.out.println("敏感词存储过程" + sensitiveWordMap);
            }
            //查看最终敏感词存放结构
            // System.out.println("最终数据" + sensitiveWordMap);
        }
    }

}

2.4.2 操作敏感词库

既然已经有了敏感词库,那我们就可以操作词库了,如果哪里用就在那里写操作的代码,这样就显得太麻烦了,我们何苦呢?不如封装一个工具类好了,这个工具类专门用来操作敏感词库这样多好呀~~

于是下手准备做。在做之前通过浏览资料刚好看到网上有这样的工具类，我不是一个好的程序员但我绝对是一个会偷懒的程序员！那就拿来改改用上呗！

import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
 * @program: blog
 * @description: 敏感词工具类, 用于操作敏感词库
 * @create: 2020-05-12 20:41
 */
public class SensitiveUtil {
    /**
     * 敏感词汇库
     */
    public static Map sensitiveWordMap;
    /**
     * 创建最小敏感词过滤类型
     */
    public static int minMatchType = 1;
    /**
     * 创建最大敏感词过滤类型,过滤所有
     */
    public static int maxMatchType = 2;

    /**
     * @return int
     * @Author MrKay
     * @Description 获取敏感词库敏感词数量
     * @Date 2020/5/12
     * @Param [sensitiveWordMap]
     */
    public static int getSensitiveWordsNumber() {
        if (sensitiveWordMap == null) {
            return 0;
        }
        return SensitiveUtil.sensitiveWordMap.size();
    }

    /**
     * @return boolean
     * @Author MrKay
     * @Description 判断是否包含敏感词
     * @Date 2020/5/12
     * @Param [txtString, matchTpe]
     */
    public static boolean isContainsSensitiveWord(String txtString, int matchTpe) {
        boolean flag = false;
        for (int i = 0; i < txtString.length(); i++) {
            //获取文本中包含敏感词的数量
            int sensitiveNum = getNumberFTxt(txtString, i, matchTpe);
            if (sensitiveNum > 0) {
                flag = true;
            }
        }
        return flag;
    }

    /**
     * @return java.util.Set<java.lang.String>
     * @Author MrKay
     * @Description 获取敏感词汇内容
     * @Date 2020/5/12
     * @Param [txtString, matchType]
     */
    public static Set<String> getSensitiveContext(String txtString, int matchType) {
        //初始化Set集合
        HashSet sensitiveSet = new HashSet();
        for (int i = 0; i < txtString.length(); i++) {
            //查询文本中敏感词数量
            int sensitiveNum = getNumberFTxt(txtString, i, matchType);
            if (sensitiveNum > 0) {
                sensitiveSet.add(txtString.substring(i, i + sensitiveNum));
                //移动循环角标
                i = i + sensitiveNum - 1;
            }
        }
        return sensitiveSet;
    }

    /**
     * @return java.lang.String
     * @Author MrKay
     * @Description 替换文本中的敏感词
     * @Date 2020/5/13
     * @Param [txtString, matchType, replaceStr]
     */
    public static String replaceSensitiveWord(String txtString, int matchType, String replaceChar) {
        String resultTxt = txtString;
        //获取敏感词内容
        Set<String> set = getSensitiveContext(txtString, matchType);
        Iterator<String> iterator = set.iterator();
        String word = null;
        String replaceString = null;
        while (iterator.hasNext()) {
            word = iterator.next();
            replaceString = getReplaceString(replaceChar, word.length());
            resultTxt = resultTxt.replaceAll(word, replaceString);
        }
        return resultTxt;
    }

    /**
     * @return java.lang.String
     * @Author MrKay
     * @Description 将敏感词汇替换为指定字符
     * @Date 2020/5/13
     * @Param [replaceChar, length]
     */
    public static String getReplaceString(String replaceChar, int length) {
        String replaceString = replaceChar;
        for (int i = 0; i < length; i++) {
            replaceString += replaceChar;
        }
        return replaceString;
    }

    /**
     * @return int
     * @Author MrKay
     * @Description 获取文本中敏感词数量
     * @Date 2020/5/12
     * @Param [txtString, matchTpe]
     */
    public static int getNumberFTxt(String txtString, int beginIndex, int matchTpe) {
        boolean flag = false;
        //初始化敏感词汇数量
        int sensitiveNum = 0;
        //初始化文本中字符
        char word = 0;
        Map nowMap = SensitiveUtil.sensitiveWordMap;
        for (int i = beginIndex; i < txtString.length(); i++) {
            word = txtString.charAt(i);
            nowMap = (Map) nowMap.get(word);
            if (nowMap != null) {
                sensitiveNum++;
                //判断是否已经到了敏感词的结尾,是的话通过matchType判断是否需要继续检测
                if ("1".equals(nowMap.get("isEnd"))) {
                    flag = true;
                    if (SensitiveUtil.minMatchType == matchTpe) {
                        break;
                    }
                }
            } else {//为空就跳出
                break;
            }
        }
        if (!flag) {
            sensitiveNum = 0;
        }
        return sensitiveNum;
    }
}

2.4.3 controller层使用

操作都已经操作完了，接下来就直接开始在访客评论的controllersang使用吧（具体你怎么用就看你的项目需求了）

以下代码只粘贴了获取到用户评论之后进行过滤的部分，其他评论的存储等代码没有进行展示。

注意：FileUtil是我封装的一个操作流对象的工具类（后期在jar包中读取resources中文件会有介绍）

这里的返回值是返回的一个提示页面(所以Controller上不能使用@RestController)

//首先在CommentController中注入刚才加入IOC容器的敏感词库:
@Autowired
private SensitiveWordInit sensitiveWordInit;

//其次在用户评论的方法中嘉瑞下段代码
try {
            //将文本中的敏感词读取出来存入List集合
            ClassPathResource classPathResource = new ClassPathResource("/static/txttemplate/maren.txt");
            List<String> list = FileUtil.readFile2List(classPathResource.getInputStream());
            //初始化词库
            Map sensitiveWordMap = sensitiveWordInit.initSensitiveWord(list);
            //初始化传入SensitiveUtil的敏感词库
            SensitiveUtil.sensitiveWordMap = sensitiveWordMap;
            String txtString = comment.getContent();
            boolean flag = SensitiveUtil.isContainsSensitiveWord(txtString, 2);
            if (flag) {
                return "error/zang";
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

2.4.4 前端相关改动

增加了一个页面用于返回评论非法提示(内容如下)

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head th:replace="_fragments :: head(~{::title})">
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>mrkay</title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/semantic-ui/2.2.4/semantic.min.css" >
  <link rel="stylesheet" href="../../static/css/me.css" >
</head>
<body>

<div class="m-container-small m-padded-tb-massive">
  <div class="ui error message m-padded-tb-huge" >
    <div class="ui contianer">
      <h2>凯哥劝你善良</h2>
      <p>
        <font color="red">
          生活如此美好,你却如此暴躁，这样，不好，不好~<br>
          恶言于人，犹仰天吐沫，逆风扶火，终究伤己。<br>
          想通了就刷新下页面,爸爸给你个重新做人的机会~~~
        </font>
      </p>
    </div>
  </div>
</div>
</body>
</html>

3 总结

敏感词汇过滤虽然已经完成但是仍然有很多不足之处,比如txt文本中的词库后期增加会很麻烦等

4 参考资料

https://yq.aliyun.com/articles/322464

笔记网盘地址:

链接：https://pan.baidu.com/s/1zxmKRTmhDZnL5AzxjHbdgQ
提取码：uqaz