ssm实现敏感词过滤
首先引入工具类：SensitiveWordsUtil
该工具类采用DFA算法，速度还是蛮快的，比我手写的快多了。
package com.kz.utils;
import java.io.IOException;
import java.util.*;
public class SensitiveWordsUtil {
/**
* 最小匹配规则，如：敏感词库["中国","中国人"]，语句："我是中国人"，匹配结果：我是[中国]人
*/
public static final int MinMatchTYpe = 1;
/**
* 最大匹配规则，如：敏感词库["中国","中国人"]，语句："我是中国人"，匹配结果：我是[中国人]
*/
public static final int MaxMatchType = 2;
/**
* 敏感词集合
*/
public static HashMap sensitiveWordMap;
/**
* 初始化敏感词库，构建DFA算法模型
*
* @param sensitiveWordSet 敏感词库
*/
public static synchronized void init(Set sensitiveWordSet) {
initSensitiveWordMap(sensitiveWordSet);
}
/**
* 初始化敏感词库，构建DFA算法模型
*
* @param sensitiveWordSet 敏感词库
*/
private static void initSensitiveWordMap(Set sensitiveWordSet) {
//初始化敏感词容器，减少扩容操作
sensitiveWordMap = new HashMap(sensitiveWordSet.size());
String key;
Map nowMap;
Map newWorMap;
//迭代sensitiveWordSet
Iterator iterator = sensitiveWordSet.iterator();
while (iterator.hasNext()) {
//关键字
key = iterator.next();
nowMap = sensitiveWordMap;
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<>();
//不是最后一个
newWorMap.put("isEnd", "0");
nowMap.put(keyChar, newWorMap);
nowMap = newWorMap;
}
if (i == key.length() - 1) {
//最后一个
nowMap.put("isEnd", "1");
}
}
}
}
/**
* 判断文字是否包含敏感字符
*
* @param txt 文字
* @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则
* @return 若包含返回true，否则返回false
*/
public static boolean contains(String txt, int matchType) {
boolean flag = false;
for (int i = 0; i < txt.length(); i++) {
//判断是否包含敏感字符
int matchFlag = checkSensitiveWord(txt, i, matchType);
//大于0存在，返回true
if (matchFlag > 0) {
flag = true;
}
}
return flag;
}
/**
* 判断文字是否包含敏感字符
*
* @param txt 文字
* @return 若包含返回true，否则返回false
*/
public static boolean contains(String txt) {
return contains(txt, MaxMatchType);
}
/**
* 获取文字中的敏感词
*
* @param txt 文字
* @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则
* @return
*/
public static Set getSensitiveWord(String txt, int matchType) {
Set sensitiveWordList = new HashSet<>();
for (int i = 0; i < txt.length(); i++) {
//判断是否包含敏感字符
int length = checkSensitiveWord(txt, i, matchType);
//存在,加入list中
if (length > 0) {
sensitiveWordList.add(txt.substring(i, i + length));
//减1的原因，是因为for会自增
i = i + length - 1;
}
}
return sensitiveWordList;
}
/**
* 获取文字中的敏感词
*
* @param txt 文字
* @return
*/
public static Set getSensitiveWord(String txt) {
return getSensitiveWord(txt, MaxMatchType);
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceChar 替换的字符，匹配的敏感词以字符逐个替换，如 语句：我爱中国人 敏感词：中国人，替换字符：*， 替换结果：我爱***
* @param matchType 敏感词匹配规则
* @return
*/
public static String replaceSensitiveWord(String txt, char replaceChar, int matchType) {
String resultTxt = txt;
//获取所有的敏感词
Set set = getSensitiveWord(txt, matchType);
Iterator iterator = set.iterator();
String word;
String replaceString;
while (iterator.hasNext()) {
word = iterator.next();
replaceString = getReplaceChars(replaceChar, word.length());
resultTxt = resultTxt.replaceAll(word, replaceString);
}
return resultTxt;
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceChar 替换的字符，匹配的敏感词以字符逐个替换，如 语句：我爱中国人 敏感词：中国人，替换字符：*， 替换结果：我爱***
* @return
*/
public static String replaceSensitiveWord(String txt, char replaceChar) {
return replaceSensitiveWord(txt, replaceChar, MaxMatchType);
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceStr 替换的字符串，匹配的敏感词以字符逐个替换，如 语句：我爱中国人 敏感词：中国人，替换字符串：[屏蔽]，替换结果：我爱[屏蔽]
* @param matchType 敏感词匹配规则
* @return
*/
public static String replaceSensitiveWord(String txt, String replaceStr, int matchType) {
String resultTxt = txt;
//获取所有的敏感词
Set set = getSensitiveWord(txt, matchType);
Iterator iterator = set.iterator();
String word;
while (iterator.hasNext()) {
word = iterator.next();
resultTxt = resultTxt.replaceAll(word, replaceStr);
}
return resultTxt;
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceStr 替换的字符串，匹配的敏感词以字符逐个替换，如 语句：我爱中国人 敏感词：中国人，替换字符串：[屏蔽]，替换结果：我爱[屏蔽]
* @return
*/
public static String replaceSensitiveWord(String txt, String replaceStr) {
return replaceSensitiveWord(txt, replaceStr, MaxMatchType);
}
/**
* 获取替换字符串
*
* @param replaceChar
* @param length
* @return
*/
private static String getReplaceChars(char replaceChar, int length) {
String resultReplace = String.valueOf(replaceChar);
for (int i = 1; i < length; i++) {
resultReplace += replaceChar;
}
return resultReplace;
}
/**
* 检查文字中是否包含敏感字符，检查规则如下：
*
* @param txt
* @param beginIndex
* @param matchType
* @return 如果存在，则返回敏感词字符的长度，不存在返回0
*/
private static int checkSensitiveWord(String txt, int beginIndex, int matchType) {
//敏感词结束标识位：用于敏感词只有1位的情况
boolean flag = false;
//匹配标识数默认为0
int matchFlag = 0;
char word;
Map nowMap = sensitiveWordMap;
for (int i = beginIndex; i < txt.length(); i++) {
word = txt.charAt(i);
//获取指定key
nowMap = (Map) nowMap.get(word);
//存在，则判断是否为最后一个
if (nowMap != null) {
//找到相应key，匹配标识+1
matchFlag++;
//如果为最后一个匹配规则,结束循环，返回匹配标识数
if ("1".equals(nowMap.get("isEnd"))) {
//结束标志位为true
flag = true;
//最小规则，直接返回,最大规则还需继续查找
if (MinMatchTYpe == matchType) {
break;
}
}
} else {//不存在，直接返回
break;
}
}
//长度必须大于等于1，为词
if (matchFlag < 2 || !flag) {
matchFlag = 0;
}
return matchFlag;
}
/**
* 敏感词替换工具方法（对外方法）
*
* @param string
* @return
* @exception IOException 读写文件异常
*/
public static String sensitiveHelper(String string, Set sensitiveWords) throws IOException {
//初始化敏感词库
SensitiveWordsUtil.init(sensitiveWords);
//判断是否包含敏感词库
if (contains(string)){
//若包含返回替换后的字符
String str = SensitiveWordsUtil.replaceSensitiveWord(string, "**");
return str;
}
//不包含返回原本字符
return string;
}
}
jsp代码
<script>
//敏感词过滤
$("#seachButton").on("click", function () {
var search = $.trim($("#search").val());
if (search != "" || search.length != 0) {
console.log(search);
$.ajax({
url:"${path}/home/validateContent",
data:{"content":search},
success:function (data) {
if (data.result != "allow"){
alert("输入框中包含敏感词汇：" + data.sensWords);
$("#search").val(data.result);
} else {
location.href='${path}/searchInfo?search='+search;
}
}
})
}
})
</script>
控制器代码：KeywordController
package com.kz.controller;
import com.kz.service.KeywordService;
import com.kz.utils.SensitiveWordsUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
@Controller
public class KeywordController {
@Autowired
private KeywordService service;
@RequestMapping({"register/validateContent", "login/validateContent","home/validateContent"})
@ResponseBody
public Map validateContent(HttpServletRequest request) {
Map map = new HashMap();
String content = request.getParameter("content").trim();
Set keywords = service.selectAll();
if (keywords.size() != 0) {
SensitiveWordsUtil.init(keywords);
boolean flag = SensitiveWordsUtil.contains(content);
if (flag) {
String replaceContent = SensitiveWordsUtil.replaceSensitiveWord(content, "**");
Set sensWords = SensitiveWordsUtil.getSensitiveWord(content);
map.put("result", replaceContent);
map.put("sensWords", sensWords);
} else {
map.put("result", "allow");
}
return map;
}
return map;
}
}
目前只能对单一指定的url进行过滤，这样如果输入框比较多，就比较麻烦。
需求是要对所有输入框进行敏感词过滤，本来是想采用filter过滤器的，但是发现无法注入service,网上找了解决办法，但是最终好像没有过滤所有的url,即使使用了注解@WebFilter(value="/*"),自己在慢慢探索吧。