Java实现DFA算法敏感词过滤

已于 2024-02-23 10:18:09 修改
阅读量5.3k 收藏 43
点赞数 8
分类专栏： java 文章标签： java DFA算法 敏感词
于 2022-03-02 16:50:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imVainiycos/article/details/123234477
版权

Java实现DFA算法敏感词过滤。

文章目录

一. 应用场景

模拟非法词汇自动替换成*字符，且敏感词汇支持动态调整。

效果如下，若配置了敏感词：今天，则当用户在输入：今天，天气真不错。实际应该输出：**，天气真不错

二. 实现思路

  • 使用MySQL作为敏感词库
  • 使用DFA算法实现文字过滤

Q：什么是DFA？

DFA全称为：Deterministic Finite Automaton,即确定有穷自动机。其特征为：有一个有限状态集合和一些从一个状态通向另一个状态的边，每条边上标记有一个符号，其中一个状态是初态，某些状态是终态。但不同于不确定的有限自动机，DFA中不会有从同一状态出发的两条边标志有相同的符号。
确定：状态以及引起状态转换的事件都是可确定的，不存在“意外”。
有穷：状态以及事件的数量都是可穷举的。

DFA算法模型如下：

state_event_dict = {
    "匹": {
        "配": {
            "算": {
                "法": {
                    "is_end": True
                },
                "is_end": False
            },
            "关": {
                "键": {
                    "词": {
                        "is_end": True
                    },
                    "is_end": False
                },
                "is_end": False
            },
            "is_end": False
        },
        "is_end": False
    },
    "信": {
        "息": {
            "抽": {
                "取": {
                    "is_end": True
                },
                "is_end": False
            },
            "is_end": False
        },
        "is_end": False
    }
}

用通俗易懂的话来解释，就是将数据库中的敏感词进行建立树结构，举个例子，数据库的敏感词汇有三个，分别是：今天，今天很好，今天真烦。

建立树结构，并且标记好三个词汇的非叶子节点和叶子节点（即最后一个字符是叶子节点），并且制定好匹配规则，只有碰到叶子节点才算一次过滤：

image-20220302161408777

模拟用户输入以下一句话：

我觉得今天还行。

接下来我们将这句话逐个字拆分并将每一个字代入到上面的树状结构图中。

前面三个字不在敏感词树中直接可以跳过，直到遇到了今这个字，发现匹配上了敏感词树，接下来看树状结构发现只有下一个字是天才能被捕获，继续往下走果然发现天这个字也匹配到了；

再接着走发现在树结构中天这个字的下一个字只有匹配到很或者真才能继续匹配，而用户输入的下一个字是还，第一步判断当前已经走到了叶子节点，故先将今天置为敏感词，然后将还这个字从Top顶节点中重新继续流转，发现无法匹配。

过滤结束，且当前的节点是叶子节点，故这句话仅仅被敏感词过滤了今天这两个字，最终的过滤结果应该是：

我觉得**还行

要注意的是只有完整的碰到过一次叶子节点才算一次过滤，且一句话可以被多次过滤。以上就是针对DFA算法的简单说明。

三. 源码实现

理论知识加身，接下来就该实干了。Talk is cheap, show me the code：

import java.util.HashMap;
import java.util.Map;

/**
 * @author: Vainycos
 * @description 敏感字树生成器
 * @date: 2021/12/4 12:45
 */
public class TreeGenerator {

    /**
     * 将指定的词分成字构建到一棵树中。
     *
     * @param tree
     *            字树
     * @param sensitiveWord
     *            敏感词词
     * @return
     */
    public static void addWord2Tree(Map<String, Map> tree, String sensitiveWord) {
        addWord2Tree(tree, sensitiveWord, 0);
    }

    private static Map<String, Map> addWord2Tree(Map<String, Map> tree,
                                                 String word, int index) {
        if (index == word.length()) {
            tree.put(Finder.TREE_END_KEY, generateWordMap(word));
            return tree;
        }
        String next = word.substring(index, index + 1);
        Map<String, Map> subTree = tree.get(next);
        if (subTree == null) {
            subTree = new HashMap<String, Map>();
        }
        tree.put(next, addWord2Tree(subTree, word, index + 1));
        return tree;
    }

    private static Map<String, Object> generateWordMap(String word) {
        Map<String, Object> wordMap = new HashMap<String, Object>();
        wordMap.put(Finder.WORD_VALUE, word);
        wordMap.put(Finder.WORD_LENGTH, word.length());
        return wordMap;
    }
}

public class TextAnalysis {

	/**
	 * 
	 * 分析文本，返回搜寻到的所有敏感字
	 * 
	 * @author hymer
	 * @param tree
	 *            敏感字树
	 * @param text
	 *            待分析的文本
	 * @return
	 */
	public Set<String> analysis(Map<String, Map> tree, String text) {
		Set<String> words = new LinkedHashSet<String>();
		if (text != null && text.trim().length() > 0) {
			analysis(tree, text, words);
		}
		return words;
	}

	/**
	 * 替换文本中的敏感词
	 * 
	 * @param tree
	 *            敏感字树
	 * @param text
	 *            待分析的文本
	 * @param replacement
	 *            替换字符
	 * @return
	 */
	public String replace(Map<String, Map> tree, String text,
			Character replacement) {
		if (replacement == null) {
			replacement = Finder.DEFAULT_REPLACEMENT;
		}
		if (text != null && text.trim().length() > 0) {
			StringBuffer sb = new StringBuffer("");
			replace(tree, text, 0, replacement, sb);
			return sb.toString();
		}
		return text;
	}

	/**
	 * 
	 * 标记文本中的敏感词
	 * 
	 * @author hymer
	 * @param tree
	 *            敏感字树
	 * @param text
	 *            待分析的文本
	 * @param startTag
	 *            开始标记
	 * @param endTag
	 *            结束标记
	 * @return
	 */
	public String mark(Map<String, Map> tree, String text, String startTag,
			String endTag) {
		if (text != null && text.trim().length() > 0) {
			StringBuffer sb = new StringBuffer("");
			mark(tree, text, 0, startTag, endTag, sb);
			return sb.toString();
		}
		return text;
	}

	private void mark(Map<String, Map> tree, String text, int index,
			String startTag, String endTag, StringBuffer sb) {
		int last = 0;
		int textLen = text.length();
		while (index < textLen) {
			String tmp = text.substring(index, index + 1);
			String nexts = text.substring(index);
			String word = "";
			word = findMaxWord(tree, nexts, 0, word);
			if (!"".equals(word)) {
				int wordLen = word.length();
				if (index >= last) {
					sb.append(startTag + word + endTag);
				} else {
					if (last < index + wordLen) {
						sb.insert(sb.length() - endTag.length(),
								text.substring(last, index + wordLen));
					}
				}
				last = index + wordLen;
			} else {
				if (index >= last) {
					sb.append(tmp);
				}
			}
			index++;
		}
	}

	private String findMaxWord(Map<String, Map> tree, String text, int index,
			String word) {
		Map<String, Map> subTree = tree.get(text.substring(index, index + 1));
		if (subTree != null) {
			Map<String, Object> end = subTree.get(Finder.TREE_END_KEY);
			if (end != null) {
				String sensitiveWord = (String) end.get(Finder.WORD_VALUE);
				if (word.length() < sensitiveWord.length()) {
					word = sensitiveWord;
				}
			}
			if ((index + 1) < text.length()
					&& (end == null || subTree.size() > 1)) {
				return findMaxWord(subTree, text, index + 1, word);
			}
		}
		return word;
	}

	private void analysis(Map<String, Map> tree, String text, Set<String> words) {
		int index = 0;
		while (index < text.length()) {
			findWord(tree, text, index, words);
			index++;
		}
	}

	private void findWord(Map<String, Map> tree, String text, int index,
			Set<String> words) {
		Map<String, Map> subTree = tree.get(text.substring(index, index + 1));
		if (subTree != null) {
			Map<String, Object> end = subTree.get(Finder.TREE_END_KEY);
			if (end != null) {
				words.add((String) end.get(Finder.WORD_VALUE));
			}
			if ((index + 1) < text.length()
					&& (end == null || subTree.size() > 1)) {
				findWord(subTree, text, index + 1, words);
			}
		}
	}

	private void replace(Map<String, Map> tree, String text, int index,
			char replacement, StringBuffer sb) {
		int last = 0;
		int textLen = text.length();
		while (index < textLen) {
			String tmp = text.substring(index, index + 1);
			String nexts = text.substring(index);
			String word = "";
			word = findMaxWord(tree, nexts, 0, word);
			if (!"".equals(word)) {
				int replaceLen = 0;
				int wordLen = word.length();
				if (index >= last) {
					replaceLen = wordLen;
				} else {
					replaceLen = index + wordLen - last;
				}
				while (replaceLen > 0) {
					sb.append(replacement);
					replaceLen--;
				}
				last = index + wordLen;
			} else {
				if (index >= last) {
					sb.append(tmp);
				}
			}
			index++;
		}
	}

}

import lombok.extern.slf4j.Slf4j;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 
 * 敏感词过滤
 * 
 */
@Slf4j
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Finder {
	// 敏感词
	private static Set<String> WORDS = new HashSet<String>();
	// 由敏感词生成的字树
	private static Map<String, Map> TREE = new ConcurrentHashMap<String, Map>();
	// 默认敏感词分割符
	public static final String DEFAULT_SEPARATOR = ",";
	/* 在树当中标志一个词的结束 */
	public static final String TREE_END_KEY = "^";
	// 敏感词value标记
	public static final String WORD_VALUE = "v";
	// 敏感词长度标记
	public static final String WORD_LENGTH = "l";
	// 默认替换符
	public static final char DEFAULT_REPLACEMENT = '*';
	// 默认起始标记
	public static final String DEFAULT_START_TAG = "<font color=\"red\">";
	// 默认结束标记
	public static final String DEFAULT_END_TAG = "</font>";

	public Finder(String[] words) {
		addSensitiveWords(words);
	}

	/**
	 * 删除所有敏感词
	 */
	public static void clearSensitiveWords() {
		WORDS.clear();
		TREE.clear();
	}

	/**
	 * 
	 * 添加敏感词
	 * 
	 * @author hymer
	 * @param words
	 */
	public static void addSensitiveWords(String[] words) {
		if (words == null || words.length == 0) {
			return;
		}
		check(words);
		addWords(words);
	}

	/**
	 * 
	 * 添加敏感词
	 * 
	 * @author hymer
	 * @param words
	 * @param separator
	 */
	public static void addSensitiveWords(String words, String separator) {
		if (words != null && !"".equals(words.trim())) {
			check(words);
			String[] sensitiveWords = words.split(separator);
			addWords(sensitiveWords);
		}
	}

	/**
	 * 
	 * 添加敏感词，默认使用,分割
	 * 
	 * @author hymer
	 * @param words
	 */
	public static void addSensitiveWords(String words) {
		check(words);
		addSensitiveWords(words, DEFAULT_SEPARATOR);
	}

	/**
	 * 删除敏感词
	 * 
	 * @param words
	 */
	public static void removeSensitiveWords(String words) {
		check(words);
		removeSensitiveWords(words, DEFAULT_SEPARATOR);
	}

	/**
	 * 删除敏感词
	 * 
	 * @param words
	 */
	public static void removeSensitiveWords(String words, String separator) {
		if (words != null && !"".equals(words.trim())) {
			check(words);
			String[] sensitiveWords = words.split(separator);
			removeWords(sensitiveWords);
		}
	}

	/**
	 * 删除敏感词
	 * 
	 * @param words
	 */
	public static void removeSensitiveWords(String[] words) {
		if (words == null || words.length == 0) {
			return;
		}
		check(words);
		removeWords(words);
	}

	/**
	 * 
	 * 找出文本中的敏感词
	 * 
	 * @author hymer
	 * @param text
	 * @return
	 */
	public static Set<String> find(String text) {
		return new TextAnalysis().analysis(TREE, text);
	}

	/**
	 * 替换文本中的敏感词
	 * 
	 * @param text
	 *            含敏感词的文本
	 * @return
	 */
	public static String replace(String text) {
		return new TextAnalysis().replace(TREE, text, DEFAULT_REPLACEMENT);
	}

	/**
	 * 替换文本中的敏感词
	 * 
	 * @param text
	 *            含敏感词的文本
	 * @param replacement
	 *            替换字符
	 * @return
	 */
	public static String replace(String text, Character replacement) {
		return new TextAnalysis().replace(TREE, text, replacement);
	}

	/**
	 * 
	 * 过滤文本，并标记出敏感词，默认使用HTML中红色font标记
	 * 
	 * @author hymer
	 * @param text
	 * @return
	 */
	public static String filter(String text) {
		return new TextAnalysis().mark(TREE, text, DEFAULT_START_TAG, DEFAULT_END_TAG);
	}

	/**
	 * 
	 * 过滤文本，并标记出敏感词
	 * 
	 * @author hymer
	 * @param text
	 * @param startTag
	 * @param endTag
	 * @return
	 */
	public static String filter(String text, String startTag, String endTag) {
		return new TextAnalysis().mark(TREE, text, startTag, endTag);
	}

	private static void check(String... words) {
		for (String word : words) {
			if (word != null && word.contains(TREE_END_KEY)) {
				throw new RuntimeException("包含非法字符：" + TREE_END_KEY);
			}
		}
	}

	private static void addWords(String... sensitiveWords) {
		for (String word : sensitiveWords) {
			if (word != null && !word.trim().equals("")) {
				word = word.trim();
				int len = word.length();
				if (len > 1024) {
					throw new RuntimeException("敏感词太长[最长1024]!");
				}
				// 添加该词，如果未重复，则添加到tree
				if (WORDS.add(word)) {
					TreeGenerator.addWord2Tree(TREE, word);
				}
			}
		}
		log.info("当前敏感词数量：", WORDS.size());
	}

	private static void removeWords(String... sensitiveWords) {
		for (String word : sensitiveWords) {
			if (word != null && !word.trim().equals("")) {
				word = word.trim();
				WORDS.remove(word);
			}
		}
		TREE.clear();
		addWords(WORDS.toArray(new String[WORDS.size()]));
	}

	@SuppressWarnings("unused")
	private static void printTree(Map<String, Map> wordTree, int level) {
		if (wordTree == null || wordTree.isEmpty()) {
			return;
		}
		Iterator<String> it = wordTree.keySet().iterator();
		while (it.hasNext()) {
			String next = it.next();
			Object tmp = wordTree.get(next);
			if (tmp instanceof Map) {
				printTree((Map) tmp, level + 1);
			}
		}
	}

}

以上就是关键代码，接下来我们测试一下效果：

public static void main(String[] args) {
    String content = "我觉得今天还行。";
    // 定义敏感词库 后续可以对接数据库
    String[] sensitiveWords = {"今天", "今天很好", "今天真烦"};
    // 设置敏感词库
    Finder.addSensitiveWords(sensitiveWords);
    // 敏感词过滤替换字符为*
    String replace = Finder.replace(content, '*');
    // 输出结果：我觉得**还行。
    System.out.println(replace);
}

发现效果还不错。至此，一个简单的DFA算法实现敏感词过滤功能就实现了。
详情参考：https://github.com/hymer/sensitivewords

四. 扩展

提供一个专门实现的封装java库：

<dependency>
    <groupId>com.github.houbb</groupId>
    <artifactId>sensitive-word</artifactId>
    <version>0.13.0</version>
</dependency>

详情参考：https://github.com/houbb/sensitive-word

参考资料：

Vainycos
关注
  • 8
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
高效敏感词过滤JAVA实现（DFA算法） 5000字2ms
05-01
高效敏感词过滤JAVA实现（DFA算法） 5000字2ms 节点 + 2进制标识（节省空间/提高查询效率） 附源码、注释，附带专业敏感词库（3396个敏感词） 看得上就拿去用，替换下一两处util方法、改个路径即可 不求什么，用得好的话，记得有那么一个人提供就够了。 如遇问题，欢迎交流。 QQ 463550192 普通PC测试结果： 2015-5-1 加载时间 : 41542826ns 加载时间 : 41ms 解析字数 : 5000 解析时间 : 2295131ns 解析时间 : 2ms
java敏感词过滤功能
04-20
java敏感词过滤功能
DFA敏感词过滤算法详解
java_eiji的博客
10-16 1284
DFA敏感词过滤算法详解
基于DFA算法的敏感词检测算法
最新发布
My52Hz
02-01 563
敏感词检测，几乎是所有博客、文章、日志等这类公开性发表的以文字形式记录的作品都绕不过去的产品需求，那么，是否有一些比较高效的方法来检测文章的敏感词呢？`DFA算法`，全称为确定性有限状态自动机算法，是一种常见的字符串匹配算法。它通过构建一个状态转移来表现字符串匹配，具有高效、快速的特点。在实际应用中，DFA算法尝尝被用于词法分析、字符串匹配等领域。除了DFA算法，还有其他的自动机算法，比如KMP算法、BM算法等。这些算法在不同的场景下有着不同的应用，需要根据具体情况来选择那种算法。
敏感词之 DFA 算法
廖金龙的博客
02-19 1176
DFA（deterministic finite automaton） 确定有限状态自动机或确定有限自动机，其由一个有限状态集合和一些从一个状态通向另一个状态的边，每条边上标记有一个符号，其中一个状态是初态，某些状态是终态。
算法总结：DFA（自动机）算法是什么，怎么用
dauiwsbd的博客
07-31 5826
算法总结：高手们常说的DFA（自动机）算法是什么简介一：从一个C++语言程序开始1.基础C语言解法2.DFA（自动机）算法思想3.自动机编程题解二：Leetcode实战注 简介 自动机编程（英语：Automata-based programming） 是编程典范中的一种，是指程式或其中的部份是以有限状态机（FSM）为模型的程式，有些程式则会用其他型式（也更复杂）的自动机为其模型。自动机程序在每个时刻有一个状态 s，每次经过一个行动 f，转移到下一个状态 s’。这样，只需要建立一个覆盖所有情况的从 s 与 f
铭感词过滤工具类
bagonghui3635的博客
07-31 175
编写SensitiveWordInit 类 package com.JUtils.sensitiveword; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.InputStreamReader; import...
Java敏感词过滤
qq_40618664的博客
01-21 5141
方案一：使用String类的contains() contains()方法用于判断字符串中是否包含指定的字符或字符串。 public static void main(String[] args) { String a = "敏感词"; String b = "我的敏感词"; System.out.println(b.contains(a)); if (b.contains(a)) { System.out.pri
java敏感词过滤
m0_59096111的博客
03-18 3940
运用于内容敏感词过滤打码。
java实现对指定的敏感词汇进行过滤
qq_44727672的博客
09-15 1013
首先将每个词的第一个字符作为key，value则是另一个HashMap，value对应的HashMap的key为第二个字符，如果还有第三个字符，则存储到以第二个字符为key的value中，当然这个value还是一个HashMap，以此类推下去，直到最后一个字符，当然最后一个字符对应的value也是HashMap，只不过这个HashMap只需要存储一个结束标志就行了，像上述的例子中，我们就存了一个{“isEnd”,“Y”}的HashMap，来表示这个value对应的key是敏感词的最后一个字符。
Java过滤敏感词（String法/前缀树法）
qq_56610467的博客
06-24 569
两种代码对敏感词过滤，代码运行在SpringBoot项目下版本2.1.5,部分POM依赖。
java利用DFA算法实现敏感词过滤功能
08-30
在最近的开发中遇到了敏感词过滤，便去网上查阅了很多敏感词过滤的资料，在这里也和大家分享一下自己的理解。下面这篇文章主要给大家介绍了关于java利用DFA算法实现敏感词过滤功能的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
java。dfa算法实现敏感词过滤
06-17
java。dfa算法实现敏感词过滤
Java实现DFA算法对敏感词、广告词过滤功能示例
08-28
本篇文章主要介绍了Java实现DFA算法对敏感词、广告词过滤功能示例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java中DFA算法过滤敏感词
10-18
DFA全称为：Deterministic Finite Automaton,即确定有穷自动机。其特征为：有一个有限状态集合和一些从一个状态通向另一个状态的边，每条边上标记有一个符号，其中一个状态是初态，某些状态是终态。但不同于不确定的有限自动机，DFA中不会有从同一状态出发的两条边标志有相同的符号。
常见的敏感词过滤方案汇总以及高效工具sensitive-word快速实践！
qq_59622162的博客
01-18 1812
本文主要对目前常见的敏感词过滤方案进行汇总以及对GitHub热门开源sensitive-word项目介绍以及快速上手
@DateTimeFormat与@JsonFormat详解
热门推荐
imVainiycos的博客
10-23 4万+
前后端进行时间类型的传值经常会遇到各种问题，并且对于java中的Date类也有util包与sql包的区别，在本文中我将会围绕实际业务进行展开解释。 一、时间传值 前端时间控件，一般情况下直接会传一个yyyy-MM-dd的日期字符串到后台。这个时候如果我们直接用java.util.Date类型就无法正确接收到。或者我们从数据库里查到DateTime类型并且用java的Date类型接收并返回给前台...
排查生产环境：MySQLTransactionRollbackException数据库死锁
imVainiycos的博客
08-02 8104
至此，本次MySQL线上死锁问题就已结束排查。由于线上问题一般都比较复杂或者比较难复现，所以排查线上问题首先需要分析日志，这个时候就要求我们程序的日志要尽可能做到完善。然后就是大胆猜测，小心验证，其中不免会经历多次推到重来的历程。此后该问题再次出现就不会再成为你的问题。记一次生产环境Java服务synchronized死锁的处理过程注意Synchronized与@Transactional不能在同一方法上使用的bug@transactional和synchronized同时使用不能同步的问题。......
IDEA中对于JSON字符串的处理（使用内置支持+插件提高效率）
imVainiycos的博客
08-21 7580
在Java语言中，字符串由双引号里的内容组成，例如String name = “Vainycos”。而JSON字符串则是一种最常见的数据格式串，通常格式模板为:[{“name”:“Vainycos”}]。如果我们想要在Java中使用JSON字符串，则需要在字符串的双引号中间加许多转义符来达到效果，即最终结果应该是String jsonName = “[{/“name/”：/“Vainycos/”...
dfa敏感词过滤算法怎么实现
04-23
敏感词过滤算法可以分为基于规则的过滤算法和基于机器学习的过滤算法两种。 1. 基于规则的敏感词过滤算法 这种算法适合于敏感词列表较小的场景，它的实现步骤如下： （1）将敏感词列表载入程序中，并按长度排序。 （2）遍历处理待检测的文本。 （3）对于每个字符作为开头的子串，从大到小遍历敏感词列表，查找对应的敏感词。 （4）如检测到敏感词，则进行敏感词替换或者标记等处理。 2. 基于机器学习的敏感词过滤算法 这种算法需要先进行模型训练，适用于敏感词列表较长且复杂的场景，实现步骤如下： （1）收集大量的带有敏感词的文本数据，并进行标注。 （2）利用标注数据训练模型，得到敏感词分类器。 （3）读入待检测文本数据，利用分类器进行预测和处理。 以上是两种常用的敏感词过滤算法，具体应根据不同的场景和需求选择合适的算法实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值