DFA有穷自动机敏感词过滤算法

置顶 已于 2024-01-21 08:21:10 修改
阅读量717 收藏 8
点赞数 12
分类专栏： 算法 文章标签： 算法 DFA 敏感词 过滤
于 2024-01-20 10:00:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59798969/article/details/135711472
版权

1.EndType

package com.example.utils.wordfilter;

/**
 * 结束类型定义
 */
public enum EndType {

    /**
     * 有下一个，结束
     */
    HAS_NEXT, IS_END
}

2.WordType

package com.example.utils.wordfilter;

/**
 * 词汇类型
 */
public enum WordType {

    /**
     * 黑名单/白名单
     */
    BLACK, WHITE
}

3.FlagIndex

package com.example.utils.wordfilter;

import java.util.List;

/**
 * 敏感词标记
 */
public class FlagIndex {

    /**
     * 标记结果
     */
    private boolean flag;
    /**
     * 是否黑名单词汇
     */
    private boolean isWhiteWord;
    /**
     * 标记索引
     */
    private List<Integer> index;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public List<Integer> getIndex() {
        return index;
    }

    public void setIndex(List<Integer> index) {
        this.index = index;
    }

    public boolean isWhiteWord() {
        return isWhiteWord;
    }

    public void setWhiteWord(boolean whiteWord) {
        isWhiteWord = whiteWord;
    }
}

4.WordContext

package com.example.utils.wordfilter;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

/**
 * 词库上下文环境
 * 初始化敏感词库，将敏感词加入到HashMap中，构建DFA算法模型
 */
@SuppressWarnings({"rawtypes", "unchecked"})
public class WordContext {

    /**
     * 敏感词字典
     */
    private final Map wordMap = new HashMap();

    /**
     * 是否已初始化
     */
    private boolean init;
    /**
     * 黑名单列表
     */
    private final String blackList;
    /**
     * 白名单列表
     */
    private final String whiteList;

    public WordContext() {
        this.blackList = "/blacklist.txt";
        this.whiteList = "/whitelist.txt";
        initKeyWord();
    }

    public WordContext(String blackList, String whiteList) {
        this.blackList = blackList;
        this.whiteList = whiteList;
        initKeyWord();
    }

    /**
     * 获取初始化的敏感词列表
     *
     * @return 敏感词列表
     */
    public Map getWordMap() {
        return wordMap;
    }

    /**
     * 初始化
     */
    private synchronized void initKeyWord() {
        try {
            if (!init) {
                // 将敏感词库加入到HashMap中
                addWord(readWordFile(blackList), WordType.BLACK);
                // 将非敏感词库也加入到HashMap中
                addWord(readWordFile(whiteList), WordType.WHITE);
            }
            init = true;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：<br>
     * 中 = { isEnd = 0 国 = {<br>
     * isEnd = 1 人 = {isEnd = 0 民 = {isEnd = 1} } 男 = { isEnd = 0 人 = { isEnd = 1 }
     * } } } 五 = { isEnd = 0 星 = { isEnd = 0 红 = { isEnd = 0 旗 = { isEnd = 1 } } } }
     */
    public void addWord(Iterable<String> wordList, WordType wordType) {
        Map nowMap;
        Map<String, String> newWorMap;
        // 迭代keyWordSet
        for (String key : wordList) {
            nowMap = wordMap;
            for (int i = 0; i < key.length(); i++) {
                // 转换成char型
                char keyChar = key.charAt(i);
                // 获取
                Object wordMap = nowMap.get(keyChar);
                // 如果存在该key，直接赋值
                if (wordMap != null) {
                    nowMap = (Map) wordMap;
                } else {
                    // 不存在则构建一个map，同时将isEnd设置为0，因为他不是最后一个
                    newWorMap = new HashMap<>(4);
                    // 不是最后一个
                    newWorMap.put("isEnd", String.valueOf(EndType.HAS_NEXT.ordinal()));
                    nowMap.put(keyChar, newWorMap);
                    nowMap = newWorMap;
                }

                if (i == key.length() - 1) {
                    // 最后一个
                    nowMap.put("isEnd", String.valueOf(EndType.IS_END.ordinal()));
                    nowMap.put("isWhiteWord", String.valueOf(wordType.ordinal()));
                }
            }
        }
    }

    /**
     * 在线删除敏感词
     *
     * @param wordList 敏感词列表
     * @param wordType 黑名单 BLACk，白名单WHITE
     */
    public void removeWord(Iterable<String> wordList, WordType wordType) {
        Map nowMap;
        for (String key : wordList) {
            List<Map> cacheList = new ArrayList<>();
            nowMap = wordMap;
            for (int i = 0; i < key.length(); i++) {
                char keyChar = key.charAt(i);

                Object map = nowMap.get(keyChar);
                if (map != null) {
                    nowMap = (Map) map;
                    cacheList.add(nowMap);
                } else {
                    return;
                }

                if (i == key.length() - 1) {
                    char[] keys = key.toCharArray();
                    boolean cleanable = false;
                    char lastChar = 0;
                    for (int j = cacheList.size() - 1; j >= 0; j--) {
                        Map cacheMap = cacheList.get(j);
                        if (j == cacheList.size() - 1) {
                            if (String.valueOf(WordType.BLACK.ordinal()).equals(cacheMap.get("isWhiteWord"))) {
                                if (wordType == WordType.WHITE) {
                                    return;
                                }
                            }
                            if (String.valueOf(WordType.WHITE.ordinal()).equals(cacheMap.get("isWhiteWord"))) {
                                if (wordType == WordType.BLACK) {
                                    return;
                                }
                            }
                            cacheMap.remove("isWhiteWord");
                            cacheMap.remove("isEnd");
                            if (cacheMap.size() == 0) {
                                cleanable = true;
                                continue;
                            }
                        }
                        if (cleanable) {
                            Object isEnd = cacheMap.get("isEnd");
                            if (String.valueOf(EndType.IS_END.ordinal()).equals(isEnd)) {
                                cleanable = false;
                            }
                            cacheMap.remove(lastChar);
                        }
                        lastChar = keys[j];
                    }

                    if (cleanable) {
                        wordMap.remove(lastChar);
                    }
                }
            }
        }
    }

    /**
     * 读取敏感词库中的内容，将内容添加到set集合中
     */
    private Set<String> readWordFile(String file) throws Exception {
        Set<String> set;
        // 字符编码
        String encoding = "UTF-8";
        try (InputStreamReader read = new InputStreamReader(
                this.getClass().getResourceAsStream(file), encoding)) {
            set = new HashSet<>();
            BufferedReader bufferedReader = new BufferedReader(read);
            String txt;
            // 读取文件，将文件内容放入到set中
            while ((txt = bufferedReader.readLine()) != null) {
                set.add(txt);
            }
        }
        // 关闭文件流
        return set;
    }
}

5.WordFilter

package com.example.utils.wordfilter;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * 敏感词过滤器
 */
@SuppressWarnings("rawtypes")
public class WordFilter {

    /**
     * 敏感词表
     */
    private final Map wordMap;

    /**
     * 构造函数
     */
    public WordFilter(WordContext context) {
        this.wordMap = context.getWordMap();
    }

    /**
     * 替换敏感词
     *
     * @param text 输入文本
     */
    public String replace(final String text) {
        return replace(text, 0, '*');
    }

    /**
     * 替换敏感词
     *
     * @param text   输入文本
     * @param symbol 替换符号
     */
    public String replace(final String text, final char symbol) {
        return replace(text, 0, symbol);
    }

    /**
     * 替换敏感词
     *
     * @param text   输入文本
     * @param skip   文本距离
     * @param symbol 替换符号
     */
    public String replace(final String text, final int skip, final char symbol) {
        char[] charset = text.toCharArray();
        for (int i = 0; i < charset.length; i++) {
            FlagIndex fi = getFlagIndex(charset, i, skip);
            if (fi.isFlag()) {
                if (!fi.isWhiteWord()) {
                    for (int j : fi.getIndex()) {
                        charset[j] = symbol;
                    }
                } else {
                    i += fi.getIndex().size() - 1;
                }
            }
        }
        return new String(charset);
    }

    /**
     * 是否包含敏感词
     *
     * @param text 输入文本
     */
    public boolean include(final String text) {
        return include(text, 0);
    }

    /**
     * 是否包含敏感词
     *
     * @param text 输入文本
     * @param skip 文本距离
     */
    public boolean include(final String text, final int skip) {
        boolean include = false;
        char[] charset = text.toCharArray();
        for (int i = 0; i < charset.length; i++) {
            FlagIndex fi = getFlagIndex(charset, i, skip);
            if(fi.isFlag()) {
                if (fi.isWhiteWord()) {
                    i += fi.getIndex().size() - 1;
                } else {
                    include = true;
                    break;
                }
            }
        }
        return include;
    }

    /**
     * 获取敏感词数量
     *
     * @param text 输入文本
     */
    public int wordCount(final String text) {
        return wordCount(text, 0);
    }

    /**
     * 获取敏感词数量
     *
     * @param text 输入文本
     * @param skip 文本距离
     */
    public int wordCount(final String text, final int skip) {
        int count = 0;
        char[] charset = text.toCharArray();
        for (int i = 0; i < charset.length; i++) {
            FlagIndex fi = getFlagIndex(charset, i, skip);
            if (fi.isFlag()) {
                if(fi.isWhiteWord()) {
                    i += fi.getIndex().size() - 1;
                } else {
                    count++;
                }
            }
        }
        return count;
    }

    /**
     * 获取敏感词列表
     *
     * @param text 输入文本
     */
    public List<String> wordList(final String text) {
        return wordList(text, 0);
    }

    /**
     * 获取敏感词列表
     *
     * @param text 输入文本
     * @param skip 文本距离
     */
    public List<String> wordList(final String text, final int skip) {
        List<String> wordList = new ArrayList<>();
        char[] charset = text.toCharArray();
        for (int i = 0; i < charset.length; i++) {
            FlagIndex fi = getFlagIndex(charset, i, skip);
            if (fi.isFlag()) {
                if(fi.isWhiteWord()) {
                    i += fi.getIndex().size() - 1;
                } else {
                    StringBuilder builder = new StringBuilder();
                    for (int j : fi.getIndex()) {
                        char word = text.charAt(j);
                        builder.append(word);
                    }
                    wordList.add(builder.toString());
                }
            }
        }
        return wordList;
    }

    /**
     * 获取标记索引
     *
     * @param charset 输入文本
     * @param begin   检测起始
     * @param skip    文本距离
     */
    private FlagIndex getFlagIndex(final char[] charset, final int begin, final int skip) {
        FlagIndex fi = new FlagIndex();

        Map current = wordMap;
        boolean flag = false;
        int count = 0;
        List<Integer> index = new ArrayList<>();
        for (int i = begin; i < charset.length; i++) {
            char word = charset[i];
            Map mapTree = (Map) current.get(word);
            if (count > skip || (i == begin && Objects.isNull(mapTree))) {
                break;
            }
            if (Objects.nonNull(mapTree)) {
                current = mapTree;
                count = 0;
                index.add(i);
            } else {
                count++;
                if (flag && count > skip) {
                    break;
                }
            }
            if ("1".equals(current.get("isEnd"))) {
                flag = true;
            }
            if ("1".equals(current.get("isWhiteWord"))) {
                fi.setWhiteWord(true);
                break;
            }
        }

        fi.setFlag(flag);
        fi.setIndex(index);

        return fi;
    }
}

注：Skip距离

程序会跳过不同的距离，查找敏感词，距离越长，过滤越严格，效率越低，开发者可以根据具体需求设置，这里以“紧急”为敏感词举例，以此类推

  • 0 匹配紧急

  • 1 匹配不紧不急，紧x急

  • 2 匹配紧急，紧x急，紧xx急

6.功能测试

package com.example.wordfilter;

import com.example.utils.wordfilter.WordContext;
import com.example.utils.wordfilter.WordFilter;
import com.example.utils.wordfilter.WordType;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Collections;

/**
 * DFA敏感词单元测试用例
 */
@SpringBootTest
public class DFATest {

    /**
     * 词库上下文环境
     */
    private final WordContext context = new WordContext();
    private final WordFilter filter = new WordFilter(context);

    /**
     * 测试替换敏感词
     */
    @Test
    public void replace() {
        String text = "利于上游行业发展的政策逐渐发布";
        System.out.println(filter.replace(text));   //利于上游行业发展的政策逐渐发布
        context.removeWord(Collections.singletonList("上游行业"), WordType.WHITE);
        System.out.println(filter.replace(text));   //利于上**业发展的政策逐渐发布
    }

    /**
     * 测试是否包含敏感词
     */
    @Test
    public void include() {
        String text = "利于上游行业发展的政策逐渐发布";
        System.out.println(filter.include(text));   //false
        context.removeWord(Collections.singletonList("上游行业"), WordType.WHITE);
        System.out.println(filter.include(text));   //true
    }

    /**
     * 获取敏感词数
     */
    @Test
    public void wordCount() {
        String text = "利于上游行业发展的政策逐渐发布";
        System.out.println(filter.wordCount(text));   //0
        context.removeWord(Collections.singletonList("上游行业"), WordType.WHITE);
        System.out.println(filter.wordCount(text));   //1
    }

    /**
     * 获取敏感词列表
     */
    @Test
    public void wordList() {
        String text = "利于上游1行业发展的政策逐渐发布";
        System.out.println(filter.wordList(text));   //[]]
        context.removeWord(Collections.singletonList("上游行业"), WordType.WHITE);
        System.out.println(filter.wordList(text));   //[游行]
    }

    /**
     * 测试替换敏感词
     */
    @Test
    public void replace2() {
        String text = "你是个笨蛋吧";
        System.out.println(filter.replace(text));
    }

    /**
     * 测试替换敏感词
     */
    @Test
    public void replace3() {
        String text = "你是个日本鬼子吧";
        System.out.println(filter.replace(text));
    }

}

7.工程目录

可以点个免费的赞吗！！！   

不知迷踪
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java利用DFA算法实现敏感词过滤功能
08-30
在最近的开发中遇到了敏感词过滤，便去网上查阅了很多敏感词过滤的资料，在这里也和...下面这篇文章主要给大家介绍了关于java利用DFA算法实现敏感词过滤功能的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
java使用DFA算法实现敏感词过滤,替换(txt版)
whatevery的博客
04-20 948
最近在开发过程中遇到了需要添加敏感词的地方，我这个方法是扫描项目目录下的resources下的txt完成敏感词过滤。 该方法只能过滤两个字或者两个字以上的敏感词。 首先是pom.xml文件 <groupId>com.odianyun.util</groupId> <artifactId>sensitive-words</artifactId> <version>1.0.2</version> <build> &lt
DFA算法的简单说明与案例实现以及优化思路
xb565517830的博客
06-08 3929
1.背景 项目中需要对敏感词做一个过滤，首先有几个方案可以选择： a.直接将敏感词组织成String后，利用indexOf方法来查询。 b.传统的敏感词入库后SQL查询。 c.利用Lucene建立分词索引来查询。 d.利用DFA算法来进行。 首先，项目收集到的敏感词有几千条，使用a方案肯定不行。其次，为了方便以后的扩展性尽量减少对数据库的依赖，所以放弃b方案。然后Lucene本身作为本地索引，敏感词增加后需要触发更新索引，并且这里本着轻量原则不想引入更多的库，所以放弃c方案。于是我们选定d方案为
基于确定有穷自动机(DFA算法)实现敏感词过滤
qq_52030824的博客
06-02 874
DFA(Deterministic Finite Automaton) 是一种非递归自动机，也称为确定有穷自动机。它是通过event和当前的state得到nextstate，即event+state=nextstate。确定：状态以及引起状态转换的事件都是可确定的。有穷：状态以及引起状态转换的事件的数量都是可穷举的。我们可以将每个文本片段作为状态，例如“匹配关键词”可拆分为“匹”、“匹配”、“匹配关”、“匹配关键”和“匹配关键词”五个文本片段。
DFA算法 有穷自动机，敏感词过滤，PHP示例，PHP实例
u011152027的博客
03-20 172
DFA算法 有穷自动机，敏感词过滤，PHP示例，PHP实例；1、PHP使用Array实现HashMap类库，2、封装敏感词顾虑逻辑。
模拟DFA有穷自动机的执行过程.zip
03-25
使用Java模拟DFA 有穷自动机的执行过程。给出一个字符，判断是否能够被接受 使用Java模拟DFA 有穷自动机的执行过程。给出一个字符，判断是否能够被接受
js实现敏感词过滤算法及实现逻辑
01-19
最近弄了一个用户发表评论的功能，用户上传了评论，再文章下可以看到自己的评论，但作为社会主义接班人，践行社会主义核心价值观，所以给评论敏感词过滤的功能不可少，在网上找了资料，发现已经有非常成熟的解决方案...
DFA.zip_DFA_有穷自动机
09-14
DFA确定型有穷自动机的相关功能 不用修改直接可用
DFA算法实现敏感词过滤
09-27
已在项目中使用，绝对是你想要的，高效的DFA算法实现的敏感词过滤功能。
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 412
【代码】力扣LCP 08.剧情触发时间。
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 502
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
LeetCode 算法：轮转数组c++
小金牛来了
06-09 694
LeetCode 算法：轮转数组c++
312. 戳气球
qq_35085273的博客
06-09 1015
240609-1 每日一题
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 318
给定二叉树的根节点 root ，返回所有左叶子之和。
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 650
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
16. 《C语言》——【牛客网BC124 —— BC130题目讲解】
一名普通高校生
06-11 810
牛客网BC124 - BC130
04-4.2.4 KMP 算法的进一步优化
G2Esports_NiKo的博客
06-10 331
喜欢《数据结构》部分笔记的小伙伴可以订阅专栏，今后还会不断更新。
刷题记录（240613）
最新发布
weixin_44880995的博客
06-13 321
aliyun0512
dfa敏感词过滤算法怎么实现
04-23
敏感词过滤算法可以分为基于规则的过滤算法和基于机器学习的过滤算法两种。 1. 基于规则的敏感词过滤算法 这种算法适合于敏感词列表较小的场景，它的实现步骤如下： （1）将敏感词列表载入程序中，并按长度排序。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值