敏感词过滤

Posted 2020-08-28 起个名字好难

原文：http://blog.csdn.net/u011698346/article/details/46350461

 

三步工作

一：敏感词过滤核心算法，参考这篇文章的DFA算法，http://blog.csdn.net/chenssy/article/details/26961957

实现两个类

1. SensitiveWordInit 负责加载初始化敏感词

 

[html] view plain copy

 

1. private String ENCODING = "GBK"; // 字符编码  
2.   
3. @SuppressWarnings("rawtypes")  
4. public HashMap sensitiveWordMap;  
5.   
6. public SensitiveWordInit() {  
7.     super();  
8. }  
9.   
10. @SuppressWarnings("rawtypes")  
11. public Map initKeyWord() {  
12.     try {  
13.         // 读取敏感词库  
14.         Set<String> keyWordSet = readSensitiveWordFile();  
15.         System.out.println("读取到敏感词数：" + keyWordSet.size());  
16.         // 将敏感词库加入到HashMap中  
17.         addSensitiveWordToHashMap(keyWordSet);  
18.     } catch (Exception e) {  
19.         e.printStackTrace();  
20.     }  
21.     return sensitiveWordMap;  
22. }  
23.   
24. /**  
25.  * 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：<br>  
26.  * 中 = { isEnd = 0 国 = {<br>  
27.  * isEnd = 1 人 = {isEnd = 0 民 = {isEnd = 1} } 男 = { isEnd = 0 人 = { isEnd = 1 } } } } 五 = { isEnd = 0 星 = { isEnd =  
28.  * 0 红 = { isEnd = 0 旗 = { isEnd = 1 } } } }  
29.  *   
30.  * @param keyWordSet 敏感词库  
31.  * @version 1.0  
32.  */  
33. @SuppressWarnings({ "rawtypes", "unchecked" })  
34. private void addSensitiveWordToHashMap(Set<String> keyWordSet) {  
35.     sensitiveWordMap = new HashMap(keyWordSet.size()); // 初始化敏感词容器，减少扩容操作  
36.     String key = null;  
37.     Map nowMap = null;  
38.     Map<String, String> newWorMap = null;  
39.     // 迭代keyWordSet  
40.     Iterator<String> iterator = keyWordSet.iterator();  
41.     while (iterator.hasNext()) {  
42.         key = iterator.next(); // 关键字  
43.         nowMap = sensitiveWordMap;  
44.   
45.         for (int i = 0; i < key.length(); i++) {  
46.             char keyChar = key.charAt(i); // 转换成char型  
47.             Object wordMap = nowMap.get(keyChar); // 获取  
48.   
49.             if (wordMap != null) { // 如果存在该key，直接赋值  
50.                 nowMap = (Map) wordMap;  
51.             } else { // 不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个  
52.                 newWorMap = new HashMap<String, String>();  
53.                 newWorMap.put("isEnd", "0"); // 不是最后一个  
54.                 nowMap.put(keyChar, newWorMap);  
55.                 nowMap = newWorMap;  
56.             }  
57.   
58.             if (i == key.length() - 1) {  
59.                 nowMap.put("isEnd", "1"); // 最后一个  
60.             }  
61.   
62.         }  
63.     }  
64.   
65. }  
66.   
67. /**  
68.  * 读取敏感词库中的内容，将内容添加到set集合中  
69.  *   
70.  * @return  
71.  * @version 1.0  
72.  * @throws Exception  
73.  */  
74. private Set<String> readSensitiveWordFile() throws Exception {  
75.     Set<String> set = new HashSet<String>();  
76.     InputStreamReader read = null;  
77.     BufferedReader bufferedReader = null;  
78.   
79.     try {  
80.         String path = getClass().getResource("/SensitiveWord").getPath(); // 敏感词从项目中读取  
81.         // String path = PropertiesUtils.get("sensitiveWordPath"); //敏感词上传到服务器，从服务器中读取  
82.         File file = new File(path); // 读取文件  
83.         if (file.isDirectory()) {  
84.             File[] files = file.listFiles();  
85.             if (null != files && files.length > 0) {  
86.                 for (File sensitivefile : files) {  
87.                     read = new InputStreamReader(new FileInputStream(sensitivefile), ENCODING);  
88.                     bufferedReader = new BufferedReader(read);  
89.   
90.                     String txt = null;  
91.                     while ((txt = bufferedReader.readLine()) != null) { // 读取文件，将文件内容放入到set中  
92.                         set.add(txt.split("\\|")[0]);  
93.                     }  
94.                 }  
95.             } else {  
96.                 throw new Exception("敏感词库文件不存在");  
97.             }  
98.         } else {  
99.             throw new Exception("敏感词库文件不存在");  
100.         }  
101.     } catch (Exception e) {  
102.         throw e;  
103.     } finally {  
104.         if (null != read) {  
105.             read.close(); // 关闭文件流  
106.         }  
107.     }  
108.   
109.     return set;  
110. }  

2. SensitivewordFilter  负责判断是否有敏感词及过滤

 

 

[html] view plain copy

 

1. @SuppressWarnings("rawtypes")  
2. private static Map sensitiveWordMap = null;  
3.   
4. public static int minMatchTYpe = 1; // 最小匹配规则  
5.   
6. public static int maxMatchType = 2; // 最大匹配规则  
7.   
8. /**  
9.  * 构造函数，初始化敏感词库  
10.  */  
11. public SensitivewordFilter() {  
12.     if (null == sensitiveWordMap)  
13.         sensitiveWordMap = new SensitiveWordInit().initKeyWord();  
14. }  
15.   
16. /**  
17.  * 判断文字是否包含敏感字符  
18.  *   
19.  * @param txt 文字  
20.  * @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则  
21.  * @return 若包含返回true，否则返回false  
22.  * @version 1.0  
23.  */  
24. public boolean isContaintSensitiveWord(String txt, int matchType) {  
25.     boolean flag = false;  
26.     for (int i = 0; i < txt.length(); i++) {  
27.         int matchFlag = this.checkSensitiveWord(txt, i, matchType); // 判断是否包含敏感字符  
28.         if (matchFlag > 0) { // 大于0存在，返回true  
29.             flag = true;  
30.         }  
31.     }  
32.     return flag;  
33. }  
34.   
35. /**  
36.  * 获取文字中的敏感词  
37.  *   
38.  * @param txt 文字  
39.  * @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则  
40.  * @return  
41.  * @version 1.0  
42.  */  
43. public Set<String> getSensitiveWord(String txt, int matchType) {  
44.     Set<String> sensitiveWordList = new HashSet<String>();  
45.   
46.     for (int i = 0; i < txt.length(); i++) {  
47.         int length = checkSensitiveWord(txt, i, matchType); // 判断是否包含敏感字符  
48.         if (length > 0) { // 存在,加入list中  
49.             sensitiveWordList.add(txt.substring(i, i + length));  
50.             i = i + length - 1; // 减1的原因，是因为for会自增  
51.         }  
52.     }  
53.   
54.     return sensitiveWordList;  
55. }  
56.   
57. /**  
58.  * 替换敏感字字符  
59.  *   
60.  * @param txt  
61.  * @param matchType  
62.  * @param replaceChar 替换字符，默认*  
63.  * @version 1.0  
64.  */  
65. public String replaceSensitiveWord(String txt, int matchType, String replaceChar) {  
66.     String resultTxt = txt;  
67.     Set<String> set = getSensitiveWord(txt, matchType); // 获取所有的敏感词  
68.     Iterator<String> iterator = set.iterator();  
69.     String word = null;  
70.     String replaceString = null;  
71.     while (iterator.hasNext()) {  
72.         word = iterator.next();  
73.         replaceString = getReplaceChars(replaceChar, word.length());  
74.         resultTxt = resultTxt.replaceAll(word, replaceString);  
75.     }  
76.   
77.     return resultTxt;  
78. }  
79.   
80. /**  
81.  * 获取替换字符串  
82.  *   
83.  * @param replaceChar  
84.  * @param length  
85.  * @return  
86.  * @version 1.0  
87.  */  
88. private String getReplaceChars(String replaceChar, int length) {  
89.     String resultReplace = replaceChar;  
90.     for (int i = 1; i < length; i++) {  
91.         resultReplace += replaceChar;  
92.     }  
93.   
94.     return resultReplace;  
95. }  
96.   
97. /**  
98.  * 检查文字中是否包含敏感字符，检查规则如下：<br>  
99.  *   
100.  * @param txt  
101.  * @param beginIndex  
102.  * @param matchType  
103.  * @return，如果存在，则返回敏感词字符的长度，不存在返回0  
104.  * @version 1.0  
105.  */  
106. @SuppressWarnings({ "rawtypes" })  
107. private int checkSensitiveWord(String txt, int beginIndex, int matchType) {  
108.     boolean flag = false; // 敏感词结束标识位：用于敏感词只有1位的情况  
109.     int matchFlag = 0; // 匹配标识数默认为0  
110.     char word = 0;  
111.     Map nowMap = sensitiveWordMap;  
112.     for (int i = beginIndex; i < txt.length(); i++) {  
113.         word = txt.charAt(i);  
114.         nowMap = (Map) nowMap.get(word); // 获取指定key  
115.   
116.         if (nowMap != null) { // 存在，则判断是否为最后一个  
117.             matchFlag++; // 找到相应key，匹配标识+1  
118.             if ("1".equals(nowMap.get("isEnd"))) { // 如果为最后一个匹配规则,结束循环，返回匹配标识数  
119.                 flag = true; // 结束标志位为true  
120.                 if (SensitivewordFilter.minMatchTYpe == matchType) { // 最小规则，直接返回,最大规则还需继续查找  
121.                     break;  
122.                 }  
123.             }  
124.         } else { // 不存在，直接返回  
125.             break;  
126.         }  
127.     }  
128.     if (matchFlag < 2 || !flag) { // 长度必须大于等于1，为词  
129.         matchFlag = 0;  
130.     }  
131.     return matchFlag;  
132. }  
133.   
134. *   public static void main(String[] args) {  
135.     SensitivewordFilter filter = new SensitivewordFilter();  
136.     System.out.println("敏感词的数量：" + filter.sensitiveWordMap.size());  
137.     String string = "太多的伤感情怀也许只局限于饲养基地 荧幕中的情节，主人公尝试着去用某种方式渐渐的很潇洒地释自杀指南怀那些自己经历的伤感。"  
138.             + "然后法轮 我们的扮演的角色就是跟随着主人公的喜红客联盟 怒哀乐而过于牵强的把自己的情感也附加于银幕情节中，然后感动就流泪，"  
139.             + "难过就躺在某一个人的怀里尽情的阐述心扉或者手机卡复制器一个人一杯红酒一部电影在夜三级片 深人静的晚上，关上电话静静的发呆着。";  
140.     System.out.println("待检测语句字数：" + string.length());  
141.     long beginTime = System.currentTimeMillis();  
142.     Set<String> set = filter.getSensitiveWord(string, 1);  
143.     long endTime = System.currentTimeMillis();  
144.     System.out.println("语句中包含敏感词的个数为：" + set.size() + "。包含：" + set);  
145.     System.out.println("总共消耗时间为：" + (endTime - beginTime));  
146. }*/  

 

二：获取敏感词库，可从网上获取，项目启动的时候加载一次词库，后续调用过滤时不再加载。实现方法为通过监听器来实现，在web.xml中配置一个Listener，在Listener的contextInitialized方法中加载词库

 

[html] view plain copy

 

1. <listener>  
2.     <listener-class>com.xxx.***.listener.SensitiveWordContextListener</listener-class>  
3.    </listener>  

监听类实现如下：

 

 

[html] view plain copy

 

1. public class SensitiveWordContextListener implements ServletContextListener {  
2.   
3.     @Override  
4.     public void contextInitialized(ServletContextEvent sce) {  
5.         System.out.println("====================contextInitialized====================");  
6.         new SensitivewordFilter();  
7.     }  
8.   
9.     @Override  
10.     public void contextDestroyed(ServletContextEvent sce) {  
11.         System.out.println("====================contextDestroyed====================");  
12.     }  
13.   
14. }  

三： 通过过滤器拦截请求中的参数，判断是否包含敏感词及过滤，实现方法为在web.xml中增加Filter配置

 

 

[html] view plain copy

 

1. <filter>  
2.    <filter-name>requestParamFilter</filter-name>  
3.    <filter-class>com.***.***.filter.RequestParamFilter</filter-class>  
4.  </filter>  
5.  <filter-mapping>  
6.    <filter-name>requestParamFilter</filter-name>  
7.    <url-pattern>/*</url-pattern>  
8.  </filter-mapping>  

RequestParamFilter实现如下：在doFilter中实现过滤

 

 

[html] view plain copy

 

1. public class RequestParamFilter implements Filter {  
2.   
3.     @Override  
4.     public void init(FilterConfig filterConfig) throws ServletException {  
5.     }  
6.   
7.     @Override  
8.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {  
9.         HttpServletRequest req = (HttpServletRequest) request;  
10.         if (req.getRequestURI().contains("/addProductQuestion")) {  
11.             chain.doFilter(new HttpServletRequestWrapper(req) {  
12.                 @Override  
13.                 public String[] getParameterValues(String name) {  
14.                     String[] resources = super.getParameterValues(name);  
15.                     if (null != name && "content".equals(name)) {  
16.                         if (null != resources && resources.length > 0) {  
17.                             for (int i = 0; i < resources.length; i++) {  
18.                                 if (null != resources[i] && hasSensitiveWords(resources[i])) {  
19.                                     resources[i] = filterSensitiveWord(resources[i]);  
20.                                 }  
21.                             }  
22.                         }  
23.                     }  
24.                     return resources;  
25.                 }  
26.             }, response);  
27.         } else {  
28.             chain.doFilter(request, response);  
29.         }  
30.     }  
31.   
32.     protected String filterSensitiveWord(String content) {  
33.         SensitivewordFilter filter = new SensitivewordFilter();  
34.         content = filter.replaceSensitiveWord(content, 1, "*");// 替换敏感词  
35.         return content;  
36.     }  
37.   
38.     protected boolean hasSensitiveWords(String content) {  
39.         Boolean flag = false;  
40.         SensitivewordFilter filter = new SensitivewordFilter();  
41.         Set<String> set = filter.getSensitiveWord(content, 1); // 获取敏感词  
42.         if (null != set && set.size() > 0) {  
43.             flag = true;  
44.         }  
45.         return flag;  
46.     }  
47.   
48.     @Override  
49.     public void destroy() {  
50.     }  
51.   
52. }