一、需求背景

项目中需要对敏感词做一个过滤，首先有几个方案可以选择：

• A方案：将敏感词存入数组中，然后判断搜索词是否在数组中即可，这种方式适用于敏感词很少并且对性能要求不高的情况。

   @Test
    public void test1(){
        Set<String>  sensitiveWords=new HashSet<>();
        sensitiveWords.add("shit");
        sensitiveWords.add("傻逼");
        sensitiveWords.add("笨蛋");
        String text="你是傻逼啊";
        for(String sensitiveWord:sensitiveWords){
            if(text.contains(sensitiveWord)){
                System.out.println("输入的文本存在敏感词。——"+sensitiveWord);
                break;
            }
        }
    }

• B方案：传统的敏感词入库后SQL查询。

• C方案：利用Lucene建立分词索引来查询。

• D方案：利用DFA算法来进行。

首先，项目收集到的敏感词有几千条，使用A方案肯定不行。其次，为了方便以后的扩展性尽量减少对数据库的依赖，所以放弃B方案。然后Lucene本身作为本地索引，敏感词增加后需要触发更新索引，并且这里本着轻量原则不想引入更多的库，所以放弃C方案。于是我们选定D方案为研究目标。

二、DFA算法

2.1 DFA算法简介

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

1

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

2.2 敏感词搜寻中的DFA算法

2.2.1 敏感词库构造描述

以王八蛋和王八羔子两个敏感词来进行描述，首先构建敏感词库，该词库名称为SensitiveMap，这两个词的二叉树构造为：

2

2.2.2 基于敏感词库收索算法的描述

以上面例子构造出来的SensitiveMap为敏感词库进行示意，假设这里输入的关键字为：王八不好，流程图如下：

3

2.3 代码编写

2.3.1 构造敏感词实现代码

4

2.3.2 实现敏感词查询代码

image.png

2.4 敏感词中间填充无意义字符问题

对于“王*八&&蛋”这样的词，中间填充了无意义的字符来混淆，在我们做敏感词搜索时，同样应该做一个无意义词的过滤，当循环到这类无意义的字符时进行跳过，避免干扰。

三、Hutool-DFA

针对DFA算法以及网上的一些实现，Hutool做了整理和改进，最终形成现在的Hutool-dfa模块。Hutool-dfa文档

四、基于Hutool-DFA项目实践

4.1 项目设计概述

本项目敏感词存在MySQL数据库，可批量导入，也可以在系统管理后台管理员通过系统维护，系统启动时再构建Hutool-DFA的关键词树，提供敏感词查找、匹配、过滤。

4.2 代码

1 数据库实体类

@Data
@TableName("t_sys_sensitive_word")
public class SensitiveWord {

    /** 发布者ID */
    private Long userId;
    
    /** 发布者姓名 */
    private String userName;

    /** 敏感字 */
    private String word;
    
    /** 分类：谩骂脏话、政治 */
    private String type;
    
    /** 影响方式 */
    private SensitiveWordModeEnum mode;
    
    /** 影响范围, 0全部 1动态 2用户 3好友聊天 4群聊天 5游戏 多个以,分隔 */
    private String scope;
    
    /** 替换符 */
    private String repl;
}

2 实体类DTO

@Data
@ApiModel("敏感词DTO")
public class SensitiveWordDTO implements Serializable {

    /** 敏感字词ID */
    private Long id;
    
    /** 敏感字词 */
    private String word;
    
    /** 分类：谩骂脏话、政治 */
    private String type;
    
    /** 影响方式 */
    private SensitiveWordModeEnum mode;
    
    /** 影响范围, 0全部 1动态 2用户 3好友聊天 4群聊天 5游戏 多个以,分隔 */
    private String scope;
    
    /** 替换符 */
    @ApiModelProperty("替换符")
    private String repl;
    
    /** 发布者ID */
    private Long userId;
    
    /** 发布者姓名 */
    private String userName;
    
    /** 创建日期 */
    private LocalDateTime createTime;
}

3 枚举类

@ApiModel(description = "敏感词影响范围")
public enum SensitiveWordModeEnum {
    
    SHIELD("SHIELD", "屏蔽"),

    DST("DST", "脱敏"),

    WARN("WARN", "警告");

    @EnumValue
    @JsonValue
    private String code;
    private String name;
}

4 敏感词处理工具类

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.TimeInterval;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.dfa.FoundWord;
import cn.hutool.dfa.SensitiveProcessor;
import cn.hutool.dfa.WordTree;
import com.alanchen.component.SensitiveDefaultProcessor;
import com.alanchen.component.SensitiveHighlightProcessor;
import com.alanchen.convert.SensitiveWordConvert;
import com.alanchen.entity.SensitiveWord;
import com.alanchen.service.SensitiveWordService;
import com.alanchen.SensitiveWordDTO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
@Component
public class SensitiveWordUtil implements ApplicationRunner {

    @Resource
    private SensitiveWordService sensitiveWordService;

    private static WordTree sensitiveTree = new WordTree();

    private static ConcurrentHashMap<String, SensitiveWordDTO> SENSITIVE_WORDS_MAP = new ConcurrentHashMap<>();

    @Override
    public void run(ApplicationArguments args) {
        List<SensitiveWord> list = sensitiveWordService.list();
        if (list != null || list.size() != 0) {
            for (SensitiveWord sensitiveWord : list) {
                SensitiveWordDTO sw = SensitiveWordConvert.toDTO(sensitiveWord);
                SENSITIVE_WORDS_MAP.put(sw.getWord(), sw);
            }
        }

        this.init(ListUtil.toList(SENSITIVE_WORDS_MAP.keys()), true);
        log.info("初始化敏感词库完毕, 共" + list.size() + "个敏感词");
    }

    /**
     * 初始化敏感词树
     *
     * @param isAsync        是否异步初始化
     * @param sensitiveWords 敏感词列表
     */
    public void init(final Collection<String> sensitiveWords, boolean isAsync) {
        if (isAsync) {
            ThreadUtil.execAsync(() -> {
                init(sensitiveWords);
                return true;
            });
        } else {
            init(sensitiveWords);
        }
    }

    /**
     * 初始化敏感词树
     *
     * @param sensitiveWords 敏感词列表
     */
    public void init(Collection<String> sensitiveWords) {
        sensitiveTree.clear();
        sensitiveTree.addWords(sensitiveWords);
    }

    public static void addSensitiveWord(SensitiveWord sw) {
        SENSITIVE_WORDS_MAP.put(sw.getWord(), SensitiveWordConvert.toDTO(sw));
        sensitiveTree.addWord(sw.getWord());
    }

    public static void removeSensitiveWord(String word) {
        SENSITIVE_WORDS_MAP.remove(word);
        sensitiveTree.clear();
        sensitiveTree.addWords(ListUtil.toList(SENSITIVE_WORDS_MAP.keySet()));
    }

    /**
     * 查找敏感词，返回找到的第一个敏感词
     *
     * @param text 文本
     * @return 敏感词
     * @since 5.5.3
     */
    public static FoundWord getFoundFirstSensitive(String text) {
        return sensitiveTree.matchWord(text);
    }

    /**
     * 查找敏感词，返回找到的所有敏感词
     *
     * @param text 文本
     * @return 敏感词
     */
    public static List<FoundWord> getFoundAllSensitive(String text) {
        return sensitiveTree.matchAllWords(text);
    }

    /**
     * 查找敏感词，返回找到的所有敏感词<br>
     * 密集匹配原则：假如关键词有 ab,b，文本是abab，将匹配 [ab,b,ab]<br>
     * 贪婪匹配（最长匹配）原则：假如关键字a,ab，最长匹配将匹配[a, ab]
     *
     * @param text           文本
     * @param isDensityMatch 是否使用密集匹配原则
     * @param isGreedMatch   是否使用贪婪匹配（最长匹配）原则
     * @return 敏感词
     */
    public static List<FoundWord> getFoundAllSensitive(String text, boolean isDensityMatch, boolean isGreedMatch) {
        return sensitiveTree.matchAllWords(text, -1, isDensityMatch, isGreedMatch);
    }

    /**
     * 处理过滤文本中的敏感词，默认替换成*
     *
     * @param text               文本
     * @param isGreedMatch       贪婪匹配（最长匹配）原则：假如关键字a,ab，最长匹配将匹配[a, ab]
     * @param sensitiveProcessor 敏感词处理器，默认按匹配内容的字符数替换成*
     *                           SensitiveDefaultProcessor、SensitiveHighlightProcessor
     * @return 敏感词过滤处理后的文本
     */
    public static String sensitiveFilter(String text, boolean isGreedMatch, SensitiveProcessor sensitiveProcessor) {
        if (StrUtil.isEmpty(text)) {
            return text;
        }
        TimeInterval timer = DateUtil.timer();
        //敏感词过滤场景下，不需要密集匹配
        List<FoundWord> foundWordList = getFoundAllSensitive(text, false, isGreedMatch);
        if (CollUtil.isEmpty(foundWordList)) {
            return text;
        }

        sensitiveProcessor = sensitiveProcessor == null ? new SensitiveProcessor() {
        } : sensitiveProcessor;

        Map<Integer, FoundWord> foundWordMap = new HashMap<>(foundWordList.size());
        foundWordList.forEach(foundWord -> foundWordMap.put(foundWord.getStartIndex(), foundWord));
        int length = text.length();
        StringBuilder textStringBuilder = new StringBuilder();
        for (int i = 0; i < length; i++) {
            FoundWord fw = foundWordMap.get(i);
            if (fw != null) {
                //只过滤[脱敏]类型的词汇, 非脱敏类型的敏感词直接跳过
                SensitiveWordDTO dto = SENSITIVE_WORDS_MAP.get(fw.getWord());
                if (dto != null) {
                    if (sensitiveProcessor instanceof SensitiveHighlightProcessor) {
                        textStringBuilder.append(((SensitiveHighlightProcessor) sensitiveProcessor).process(fw, dto.getMode()));
                    }
                    if (sensitiveProcessor instanceof SensitiveDefaultProcessor) {
                        textStringBuilder.append(((SensitiveDefaultProcessor) sensitiveProcessor).process(fw));
                    }
                    i = fw.getEndIndex();
                }
            } else {
                textStringBuilder.append(text.charAt(i));
            }
        }
        log.info("过滤敏感词, 耗时: " + timer.intervalMs() + "ms");
        return textStringBuilder.toString();
    }
}

5 自定义敏感词高亮处理器

/**
 * 自定义敏感词高亮处理器
 */
public class SensitiveHighlightProcessor implements SensitiveProcessor {

    private static final String SHIELD_START = "<shield>";
    private static final String SHIELD_END = "</shield>";
    private static final String DST_START = "<dst>";
    private static final String DST_END = "</dst>";
    private static final String WARN_START = "<warn>";
    private static final String WARN_END = "</warn>";

    @Override
    public String process(FoundWord foundWord) {
        String word = foundWord.getFoundWord();
        StringBuilder sb = new StringBuilder();
        sb.append(WARN_START).append(word).append(WARN_END);
        return sb.toString();
    }

    public String process(FoundWord foundWord, SensitiveWordModeEnum mode) {
        String word = foundWord.getFoundWord();
        StringBuilder sb = new StringBuilder();
        if (SensitiveWordModeEnum.SHIELD.equals(mode)) {
            sb.append(SHIELD_START).append(word).append(SHIELD_END);
        } else if (SensitiveWordModeEnum.DST.equals(mode)) {
            sb.append(DST_START).append(word).append(DST_END);
        } else if (SensitiveWordModeEnum.WARN.equals(mode)) {
            sb.append(WARN_START).append(word).append(WARN_END);
        }
        return sb.toString();
    }
}

6 自定义敏感词*号替代处理器

/**
 * 自定义敏感词*号替代处理器
 */
public class SensitiveDefaultProcessor implements SensitiveProcessor {

    @Override
    public String process(FoundWord foundWord) {
        int length = foundWord.getFoundWord().length();
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            sb.append("*");
        }
        return sb.toString();
    }
}

7 Controller代码

   @GetMapping("filtering")
    @ApiOperation("过滤敏感词")
    public Result<String> filtering(String text) {
        String newText = SensitiveWordUtil.sensitiveFilter(text, false, new SensitiveDefaultProcessor());
        return Result.success(newText);
    }

    @GetMapping("highLight")
    @ApiOperation("高亮敏感词")
    public Result<String> highLight(String text) {
        String newText = SensitiveWordUtil.sensitiveFilter(text, false, new SensitiveHighlightProcessor());
        return Result.success(newText);
    }

资料来源：
基于DFA敏感词查询的算法简析

Hutool-dfa文档