JAVA 生成内容带脏词？上线前的敏感词过滤与正则清理策略
大家好，今天我们来聊聊Java应用程序中，生成内容包含脏词的问题，以及上线前如何进行有效的敏感词过滤和正则清理。这是一个非常重要的话题，尤其是在互联网内容日益丰富的今天，保证内容的合规性和安全性至关重要。
一、脏词产生的根源与危害
脏词的产生可能来源于多种渠道，比如：
- 用户输入： 用户在评论、留言、发布帖子时，可能会有意或无意地输入敏感词。
- 数据抓取： 从网络抓取的数据可能包含未经处理的敏感内容。
- 机器生成： 一些算法在生成内容时，可能会因为训练数据的问题，产生包含敏感词的结果。
- 疏忽大意： 开发人员在编写代码或配置数据时，可能因为疏忽，引入包含敏感词的内容。
脏词的危害不容小觑：
- 法律风险： 包含敏感词的内容可能违反相关法律法规，导致严重的法律后果。
- 品牌形象受损： 敏感内容会损害品牌形象，降低用户信任度。
- 用户体验下降： 敏感内容会影响用户体验，导致用户流失。
- 社会责任： 企业有义务维护网络环境的健康，避免传播不良信息。
二、敏感词过滤的核心技术
敏感词过滤的核心在于高效、准确地识别文本中的敏感词。常见的技术包括：
- 基于关键词匹配： 这是最基础的方法，维护一个敏感词库，通过字符串匹配算法在文本中查找敏感词。
- 基于DFA算法： DFA（Deterministic Finite Automaton，确定性有限状态自动机）算法是一种高效的字符串匹配算法，可以快速判断文本中是否包含敏感词。
- 基于AC自动机算法： AC自动机算法是多模式匹配算法，可以在一次扫描中查找多个敏感词。
- 基于深度学习： 利用深度学习模型（例如，循环神经网络、Transformer）进行敏感词识别，可以处理一些变种的敏感词，例如谐音、拆字等。
三、敏感词过滤的实现方案
我们重点讨论基于DFA算法的实现方案，因为它在效率和准确性之间取得了较好的平衡。
1. DFA算法原理
DFA算法的核心思想是构建一个状态转移图。每个节点代表一个状态，每条边代表一个字符。从初始状态开始，根据输入的字符进行状态转移。如果最终到达一个终止状态，则表示文本中包含敏感词。
2. 构建DFA树
首先，我们需要一个敏感词库。假设我们的敏感词库如下：
["傻逼", "sb", "共产党"]根据这个敏感词库，我们可以构建如下的DFA树：
root
├── 傻
│ └── 逼 (isEnd = true)
├── s
│ └── b (isEnd = true)
└── 共
└── 产
└── 党 (isEnd = true)
每个节点都有一个isEnd属性，表示是否是一个敏感词的结尾。
3. Java代码实现
import java.util.HashMap;
import java.util.Map;
public class DFASensitiveWordsFilter {
private Map<String, Object> sensitiveWordMap;
/**
* 初始化敏感词库，构建DFA算法模型
*
* @param sensitiveWordSet 敏感词库
*/
public void init(String[] sensitiveWordSet) {
sensitiveWordMap = new HashMap<>(sensitiveWordSet.length);
for (String key : sensitiveWordSet) {
Map<String, Object> nowMap = sensitiveWordMap;
for (int i = 0; i < key.length(); i++) {
char keyChar = key.charAt(i);
Object wordMap = nowMap.get(String.valueOf(keyChar));
if (wordMap != null) {
nowMap = (Map<String, Object>) wordMap;
} else {
Map<String, Object> newWordMap = new HashMap<>();
newWordMap.put("isEnd", "0");
nowMap.put(String.valueOf(keyChar), newWordMap);
nowMap = newWordMap;
}
if (i == key.length() - 1) {
nowMap.put("isEnd", "1");
}
}
}
}
/**
* 检查文本中是否包含敏感词
*
* @param txt 文本内容
* @param matchType 匹配类型 1：最小匹配规则，2：最大匹配规则
* @return boolean 若包含返回true，否则返回false
*/
public boolean containsSensitiveWord(String txt, int matchType) {
boolean flag = false;
for (int i = 0; i < txt.length(); i++) {
int matchFlag = checkSensitiveWord(txt, i, matchType); //判断是否包含敏感词
if (matchFlag > 0) { //大于0表示有敏感词
flag = true;
}
}
return flag;
}
/**
* 替换文本中的敏感词
*
* @param txt 文本内容
* @param replaceChar 替换字符，例如'*'
* @param matchType 匹配类型 1：最小匹配规则，2：最大匹配规则
* @return 替换后的文本
*/
public String replaceSensitiveWord(String txt, char replaceChar, int matchType) {
StringBuilder resultTxt = new StringBuilder(txt);
for (int i = 0; i < txt.length(); i++) {
int matchFlag = checkSensitiveWord(txt, i, matchType); //判断是否包含敏感词
if (matchFlag > 0) { //大于0表示有敏感词
resultTxt.replace(i, i + matchFlag, generateReplaceAll(replaceChar, matchFlag));
i = i + matchFlag - 1;
}
}
return resultTxt.toString();
}
/**
* 获取文本中的敏感词
*
* @param txt 文本内容
* @param matchType 匹配类型 1：最小匹配规则，2：最大匹配规则
* @return 敏感词列表
*/
public String getSensitiveWord(String txt, int matchType) {
StringBuilder sensitiveWord = new StringBuilder();
for (int i = 0; i < txt.length(); i++) {
int matchFlag = checkSensitiveWord(txt, i, matchType); //判断是否包含敏感词
if (matchFlag > 0) { //大于0表示有敏感词
sensitiveWord.append(txt.substring(i, i + matchFlag)).append(",");
i = i + matchFlag - 1;
}
}
if (sensitiveWord.length() > 0) {
sensitiveWord.deleteCharAt(sensitiveWord.length() - 1);
}
return sensitiveWord.toString();
}
/**
* 检查是否包含敏感词，如果存在，则返回敏感词字符的长度，不存在返回0
*
* @param txt 文本内容
* @param beginIndex 开始索引
* @param matchType 匹配类型 1：最小匹配规则，2：最大匹配规则
* @return int 如果存在，则返回敏感词字符的长度，不存在返回0
*/
private int checkSensitiveWord(String txt, int beginIndex, int matchType) {
boolean flag = false; //敏感词结束标识位：用于敏感词只有1位的情况
int matchFlag = 0; //匹配标识数默认为0
Map<String, Object> nowMap = sensitiveWordMap;
for (int i = beginIndex; i < txt.length(); i++) {
char word = txt.charAt(i);
nowMap = (Map<String, Object>) nowMap.get(String.valueOf(word));
if (nowMap != null) { //存在，则判断是否为最后一个
matchFlag++; //找到相应key，匹配标识+1
if ("1".equals(nowMap.get("isEnd"))) { //如果为最后一个匹配规则,结束循环，返回匹配标识数
flag = true; //结束标志位为true
if (1 == matchType) { //最小规则，直接返回,最大规则需要继续查询
break;
}
}
} else { //不存在，直接返回
break;
}
}
if (matchFlag < 2 || !flag) { //长度必须大于等于1，为词
matchFlag = 0;
}
return matchFlag;
}
/**
* 生成替换字符串
*
* @param replaceChar 替换字符
* @param length 替换长度
* @return 替换字符串
*/
private String generateReplaceAll(char replaceChar, int length) {
StringBuilder result = new StringBuilder(length);
for (int i = 0; i < length; i++) {
result.append(replaceChar);
}
return result.toString();
}
public static void main(String[] args) {
String[] sensitiveWords = {"傻逼", "sb", "共产党"};
DFASensitiveWordsFilter filter = new DFASensitiveWordsFilter();
filter.init(sensitiveWords);
String text = "今天天气不错，但是有些人就是喜欢说傻逼，真是sb。中国共产党万岁！";
System.out.println("原始文本：" + text);
// 检查是否包含敏感词
boolean contains = filter.containsSensitiveWord(text, 1);
System.out.println("是否包含敏感词：" + contains);
// 替换敏感词
String replacedText = filter.replaceSensitiveWord(text, '*', 1);
System.out.println("替换后的文本：" + replacedText);
// 获取敏感词
String sensitiveWord = filter.getSensitiveWord(text, 1);
System.out.println("敏感词：" + sensitiveWord);
}
}4. 代码解释
init(String[] sensitiveWordSet): 初始化方法，用于构建DFA树。containsSensitiveWord(String txt, int matchType): 检查文本中是否包含敏感词。replaceSensitiveWord(String txt, char replaceChar, int matchType): 替换文本中的敏感词。getSensitiveWord(String txt, int matchType): 获取文本中的敏感词。checkSensitiveWord(String txt, int beginIndex, int matchType): 核心方法，用于检查从指定索引开始的文本是否包含敏感词。matchType: 匹配类型，1表示最小匹配，2表示最大匹配。例如，对于敏感词"共产党"，最小匹配会匹配到"共"，而最大匹配会匹配到"共产党"。
四、敏感词库的维护与更新
敏感词库的维护与更新是保证过滤效果的关键。
- 定期更新： 敏感词会随着社会发展而变化，因此需要定期更新敏感词库。
- 人工审核： 定期人工审核过滤结果，发现新的敏感词并添加到词库中。
- 用户举报： 允许用户举报敏感内容，并将举报信息用于更新词库。
- 数据来源： 可以从公开的敏感词库、行业标准、以及自身业务积累中获取敏感词。
五、正则清理策略
除了敏感词过滤，正则清理也是上线前必不可少的一步。正则清理可以用于：
- 去除HTML标签： 防止XSS攻击，提高安全性。
- 去除特殊字符： 例如，换行符、制表符等，保持内容格式统一。
- 规范文本格式： 例如，统一日期格式、电话号码格式等。
1. 常见的正则表达式
| 正则表达式 | 描述 |
|---|---|
<[^>]+> |
匹配HTML标签 |
s+ |
匹配一个或多个空白字符 |
|
匹配HTML空格实体 |
d{3}-d{8}|d{4}-d{7} |
匹配电话号码 |
d{4}-d{2}-d{2} |
匹配日期格式（YYYY-MM-DD） |
2. Java代码实现
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexCleaner {
/**
* 去除HTML标签
*
* @param htmlStr HTML字符串
* @return 去除HTML标签后的字符串
*/
public static String removeHtmlTag(String htmlStr) {
String regEx_script = "<script[^>]*?>[\s\S]*?</script>"; // 定义script的正则表达式
String regEx_style = "<style[^>]*?>[\s\S]*?</style>"; // 定义style的正则表达式
String regEx_html = "<[^>]+>"; // 定义HTML标签的正则表达式
Pattern p_script = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE);
Matcher m_script = p_script.matcher(htmlStr);
htmlStr = m_script.replaceAll(""); // 过滤script标签
Pattern p_style = Pattern.compile(regEx_style, Pattern.CASE_INSENSITIVE);
Matcher m_style = p_style.matcher(htmlStr);
htmlStr = m_style.replaceAll(""); // 过滤style标签
Pattern p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);
Matcher m_html = p_html.matcher(htmlStr);
htmlStr = m_html.replaceAll(""); // 过滤html标签
return htmlStr.trim(); // 返回文本字符串
}
/**
* 去除空格、回车、换行符
*
* @param str 字符串
* @return 去除空格后的字符串
*/
public static String replaceBlank(String str) {
String dest = "";
if (str != null) {
Pattern p = Pattern.compile("\s*|t|r|n");
Matcher m = p.matcher(str);
dest = m.replaceAll("");
}
return dest;
}
/**
* 格式化电话号码
*
* @param phone 电话号码
* @return 格式化后的电话号码
*/
public static String formatPhone(String phone) {
Pattern p = Pattern.compile("(\d{3})(\d{4})(\d{4})");
Matcher m = p.matcher(phone);
return m.replaceAll("$1-$2-$3");
}
public static void main(String[] args) {
String html = "<p>This is a <b>test</b> string.</p><script>alert('XSS');</script>";
String text = " Hello, world! n This is a test. rt";
String phone = "13800138000";
System.out.println("原始HTML：" + html);
System.out.println("去除HTML标签后的字符串：" + removeHtmlTag(html));
System.out.println("原始文本：" + text);
System.out.println("去除空格后的字符串：" + replaceBlank(text));
System.out.println("原始电话号码：" + phone);
System.out.println("格式化后的电话号码：" + formatPhone(phone));
}
}六、上线前的检查清单
在应用程序上线前，务必进行以下检查：
- 敏感词过滤： 确保所有用户输入和机器生成的内容都经过敏感词过滤。
- 正则清理： 确保所有内容都经过正则清理，去除不必要的HTML标签和特殊字符。
- 数据验证： 确保所有数据都经过验证，防止恶意输入。
- 安全审计： 进行安全审计，发现潜在的安全漏洞。
- 压力测试： 进行压力测试，确保应用程序在高负载下也能正常运行。
- 监控报警： 设置监控报警，及时发现和处理异常情况。
七、性能优化
敏感词过滤和正则清理可能会影响应用程序的性能，因此需要进行性能优化。
- 缓存： 缓存敏感词库和正则规则，避免重复加载。
- 并行处理： 使用多线程或异步处理，提高处理速度。
- 优化算法： 选择高效的字符串匹配算法和正则表达式引擎。
- 数据库优化： 优化数据库查询，减少数据库访问次数。
八、特殊情况处理
- 图片和视频： 对于图片和视频，可以使用图像识别和视频分析技术进行敏感内容检测。
- 语音： 对于语音内容，可以使用语音识别技术将语音转换为文本，然后进行敏感词过滤。
- 多语言： 对于多语言内容，需要维护多语言的敏感词库。
九、更高级的策略
- 语境分析： 某些词单独出现可能不是敏感词，但在特定语境下就变成了敏感词。进行语境分析可以提高敏感词识别的准确率。例如，“草”这个字本身没有问题，但如果出现在“草泥马”这个词语中，就变成了敏感词。
- 模糊匹配： 允许一定程度的拼写错误或变形。例如，可以使用编辑距离算法来判断两个字符串的相似度，如果相似度超过某个阈值，就认为它们是同一个词。
- 用户画像： 根据用户的行为和属性，判断用户发布敏感内容的可能性。例如，如果一个用户经常发布敏感内容，就可以对其进行限制或警告。
十、总结：保障内容安全，构建健康生态
总而言之，敏感词过滤和正则清理是保证Java应用程序内容安全的重要手段。我们需要选择合适的过滤算法，维护完善的敏感词库，并定期进行安全审计，才能构建一个健康、安全的网络环境。在选择技术方案的时候，要综合考虑效率、准确率、以及维护成本，选择最适合自己业务场景的方案。