JAVA实现敏感词过滤

参考文章 http://blog.csdn.net/chenssy/article/details/26961957

想通过博客把自己在平常工作中用到的东西和感悟记录下来，分享给更多的人。这是我写的第一篇博客，主要是关于java敏感词过滤的。最近做了个基于ssm框架的app服务端的敏感词过滤的功能。一般来说文字过滤第一种想到的是简单的把敏感词放到集合中，获取页面上传文字，然后进行匹配。或者是用正则表达式等进行匹配。但是这样的只能进行简单的效率较低的检索。通过网上查阅资料发现可以使用DFA算法。

DFA简介
在实现文字过滤的算法中，DFA是唯一比较好的实现算法。DFA即Deterministic Finite Automaton，也就是确定有穷自动机，它是是通过event和当前的state得到下一个state，即event+state=nextstate。下图展示了其状态的转换 

在这幅图中大写字母（S、U、V、Q）都是状态，小写字母a、b为动作。通过上图我们可以看到如下关系 
a b b 
S —–> U S —–> V U —–> V 
在实现敏感词过滤的算法中，我们必须要减少运算，而DFA在DFA算法中几乎没有什么计算，有的只是状态的转换。

Java实现DFA算法
在Java中实现敏感词过滤的关键就是DFA算法的实现。首先我们对上图进行剖析。在这过程中我们认为下面这种结构会更加清晰明了。 
 
同时这里没有状态转换，没有动作，有的只是Query（查找）。我们可以认为，通过S query U、V，通过U query V、P，通过V query U P。通过这样的转变我们可以将状态的转换转变为使用Java集合的查找。诚然，加入在我们的敏感词库中存在如下几个敏感词：日本人、日本鬼子、毛.泽.东。那么我需要构建成一个什么样的结构呢？首先：query 日 —> {本}、query 本 —>{人、鬼子}、query 人 —>{null}、query 鬼 —> {子}。形如下结构： 
 
下面我们在对这图进行扩展： 

这样我们就将我们的敏感词库构建成了一个类似与一颗一颗的树，这样我们判断一个词是否为敏感词时就大大减少了检索的匹配范围。比如我们要判断日本人，根据第一个字我们就可以确认需要检索的是那棵树，然后再在这棵树中进行检索。但是如何来判断一个敏感词已经结束了呢？利用标识位来判断。所以对于这个关键是如何来构建一棵棵这样的敏感词树。下面我已Java中的HashMap为例来实现DFA算法。具体过程如下： 
日本人，日本鬼子为例 
1、在hashMap中查询“日”看其是否在hashMap中存在，如果不存在，则证明已“日”开头的敏感词还不存在，则我们直接构建这样的一棵树。跳至3。 
2、如果在hashMap中查找到了，表明存在以“日”开头的敏感词，设置hashMap = hashMap.get(“日”)，跳至1，依次匹配“本”、“人”。 
3、判断该字是否为该词中的最后一个字。若是表示敏感词结束，设置标志位isEnd = 1，否则设置标志位isEnd = 0； 
 
程序实现如下：

 

1.     /** 
2.          * 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：
    
3.          * 中 = { 
4.          *      isEnd = 0 
5.          *      国 = {
    
6.          *           isEnd = 1 
7.          *           人 = {isEnd = 0 
8.          *                民 = {isEnd = 1} 
9.          *                } 
10.          *           男  = { 
11.          *                  isEnd = 0 
12.          *                   人 = { 
13.          *                        isEnd = 1 
14.          *                       } 
15.          *               } 
16.          *           } 
17.          *      } 
18.          *  五 = { 
19.          *      isEnd = 0 
20.          *      星 = { 
21.          *          isEnd = 0 
22.          *          红 = { 
23.          *              isEnd = 0 
24.          *              旗 = { 
25.          *                   isEnd = 1 
26.          *                  } 
27.          *              } 
28.          *          } 
29.          *      }         
30.          * @param keyWordSet  敏感词库        
31.          */  
32.         @SuppressWarnings({ "rawtypes", "unchecked" })  
33.         private void addSensitiveWordToHashMap(Set keyWordSet) {  
34.             sensitiveWordMap = new HashMap(keyWordSet.size());     //初始化敏感词容器，减少扩容操作  
35.             String key = null;    
36.             Map nowMap = null;  
37.             Map newWorMap = null;  
38.             //迭代keyWordSet  
39.             Iterator iterator = keyWordSet.iterator();  
40.             while(iterator.hasNext()){  
41.                 key = iterator.next();    //关键字  
42.                 nowMap = sensitiveWordMap;  
43.                 for(int i = 0 ; i < key.length() ; i++){  
44.                     char keyChar = key.charAt(i);       //转换成char型  
45.                     Object wordMap = nowMap.get(keyChar);       //获取  
46.                     if(wordMap != null){        //如果存在该key，直接赋值  
47.                         nowMap = (Map) wordMap;  
48.                     }  
49.                     else{     //不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个  
50.                         newWorMap = new HashMap();  
51.                         newWorMap.put("isEnd", "0");     //不是最后一个  
52.                         nowMap.put(keyChar, newWorMap);  
53.                         nowMap = newWorMap;  
54.                     }  
55.                     if(i == key.length() - 1){  
56.                         nowMap.put("isEnd", "1");    //最后一个  
57.                     }  
58.                 }  
59.             }  
60.         }  

运行得到的hashMap结构如下：

{五={星={红={isEnd=0, 旗={isEnd=1}}, isEnd=0}, isEnd=0}, 中={isEnd=0, 国={isEnd=0, 人={isEnd=1}, 男={isEnd=0, 人={isEnd=1}}}}}
1
敏感词库我们一个简单的方法给实现了，那么如何实现检索呢？检索过程无非就是hashMap的get实现，找到就证明该词为敏感词，否则不为敏感词。过程如下：假如我们匹配“中国人民万岁”。 
1、第一个字“中”，我们在hashMap中可以找到。得到一个新的map = hashMap.get(“”)。 
2、如果map == null，则不是敏感词。否则跳至3 
3、获取map中的isEnd，通过isEnd是否等于1来判断该词是否为最后一个。如果isEnd == 1表示该词为敏感词，否则跳至1。 
通过这个步骤我们可以判断“中国人民”为敏感词，但是如果我们输入“中国女人”则不是敏感词了。

 

1.     /** 
2.          * 检查文字中是否包含敏感字符，检查规则如下:        
3.          * @param txt 
4.          * @param beginIndex 
5.          * @param matchType 
6.          * @return，如果存在，则返回敏感词字符的长度，不存在返回0 
7.          * @version 1.0 
8.          */  
9.         @SuppressWarnings({ "rawtypes"})  
10.         public int CheckSensitiveWord(String txt,int beginIndex,int matchType){  
11.             boolean  flag = false;    //敏感词结束标识位：用于敏感词只有1位的情况  
12.             int matchFlag = 0;     //匹配标识数默认为0  
13.             char word = 0;  
14.             Map nowMap = sensitiveWordMap;  
15.             for(int i = beginIndex; i < txt.length() ; i++){  
16.                 word = txt.charAt(i);  
17.                 nowMap = (Map) nowMap.get(word);     //获取指定key  
18.                 if(nowMap != null){     //存在，则判断是否为最后一个  
19.                     matchFlag++;     //找到相应key，匹配标识+1   
20.                     if("1".equals(nowMap.get("isEnd"))){       //如果为最后一个匹配规则,结束循环，返回匹配标识数  
21.                         flag = true;       //结束标志位为true     
22.                         if(SensitivewordFilter.minMatchTYpe == matchType){    //最小规则，直接返回,最大规则还需继续查找  
23.                             break;  
24.                         }  
25.                     }  
26.                 }  
27.                 else{     //不存在，直接返回  
28.                     break;  
29.                 }  
30.             }  
31.             if(matchFlag < 2 && !flag){       
32.                 matchFlag = 0;  
33.             }  
34.             return matchFlag;  
35.         }  

以上是参考了其他博主的，下面是我在做app后台接口时进行的代码实现：

1.     /**
2.      * 修改昵称
3.      * 
4.      * @param phone,nickname
5.      * @return
6.      */
7.     @RequestMapping(value = "user/changname", method = RequestMethod.POST)
8.     public String changName(@RequestParam(value = "phone") String phone,
9.             @RequestParam(value = "nickname") String nickname) {
10.         Result result = new Result();
11.         SensitivewordFilter filter = new SensitivewordFilter();// 加载敏感词库
12.         Set set = filter.getSensitiveWord(nickname, 1);// 比对敏感词
13.         // 可以全是数字
14.         String regex = "^[\u4e00-\u9fa5a-zA-Z0-9_\\-]{4,16}$";
15.         if (!nickname.matches(regex)) {
16.             // 正则非法 包含判空 ，判断含有空格情况
17.             result.setCode(500);
18.             result.setData("昵称不符合规范");
19.             result.setMsg("昵称不符合规范");
20.             return GsonUtils.GsonString(result);
21.         }
22.         if (userService.havaName(nickname, phone)) {
23.             // 判断昵称是否已经存在 包括判断自己新名字=旧名字情况
24.             result.setCode(501);
25.             result.setData("此昵称已经存在");
26.             result.setMsg("此昵称已经存在");
27.             return GsonUtils.GsonString(result);
28.         }
29.         if (set.size() > 0) {
30.             result.setCode(502);
31.             result.setData("昵称修改失败请不要有侮辱性词汇");
32.             result.setMsg("昵称修改失败请不要有侮辱性词汇");
33.             return GsonUtils.GsonString(result);
34.         } else {
35.             try {
36.                 userService.changName(phone, nickname);
37.                 result.setCode(200);
38.                 result.setData("昵称修改成功");
39.                 result.setMsg("昵称修改成功");
40.                 return GsonUtils.GsonString(result);
41.             } catch (Exception e) {
42.                 // TODO: handle exception
43.                 result.setCode(400);
44.                 result.setData("修改失败 系统异常");
45.                 result.setMsg("修改失败 系统异常");
46.                 return GsonUtils.GsonString(result);
47.             }
48.         }

接下来是我的service类：

 

1.     public void modifyUserNickName(String oldPhone, String nickName) {
2.     //修改名称
3.         usermapper.modifyUserNickName(oldPhone, nickName);
4.     }
5.     public boolean havaName(String nickname, String phone) {
6.         // 判断昵称是否已经存在
7.         UserVo userVo = usermapper.findNickName(nickname, phone);
8.         if (userVo != null) {
9.             if (userVo.getPhone().equals(phone)) {// 自己新名字和旧的名字一样
10.                 return false;
11.             }
12.             return true;
13.         }
14.         return false;
15.     }

这里是用到的加载敏感词库的工具类：

 

1. /**
2.  *  初始化敏感词库，将敏感词加入到HashMap中，构建DFA算法模型
3.  *  
4.  *  */
5. public class SensitiveWordInit { 
6.      private String ENCODING = "GBK";    //字符编码
7.         @SuppressWarnings("rawtypes")
8.         public HashMap sensitiveWordMap; 
9.         public SensitiveWordInit(){
10.             super();
11.         }  
12.         @SuppressWarnings("rawtypes")
13.         public Map initKeyWord(){
14.             try {
15.                 //读取敏感词库
16.                 Set keyWordSet = readSensitiveWordFile();
17.                 //将敏感词库加入到HashMap中
18.                 addSensitiveWordToHashMap(keyWordSet);
19.                 //spring获取application，然后application.setAttribute("sensitiveWordMap",sensitiveWordMap);
20.             } catch (Exception e) {
21.                 e.printStackTrace();
22.             }
23.             return sensitiveWordMap;
24.         } 
25.         //将得到的敏感词库用一个DFA算法模型放到map中
26.         @SuppressWarnings({ "rawtypes", "unchecked" })
27.         private void addSensitiveWordToHashMap(Set keyWordSet) {
28.             sensitiveWordMap = new HashMap(keyWordSet.size());     //初始化敏感词容器，减少扩容操作
29.             String key = null;  
30.             Map nowMap = null;
31.             Map newWorMap = null;
32.             //迭代keyWordSet
33.             Iterator iterator = keyWordSet.iterator();
34.             while(iterator.hasNext()){
35.                 key = iterator.next();    //关键字
36.                 nowMap = sensitiveWordMap;
37.                 for(int i = 0 ; i < key.length() ; i++){
38.                     char keyChar = key.charAt(i);       //转换成char型
39.                     Object wordMap = nowMap.get(keyChar);       //获取
40.                     if(wordMap != null){        //如果存在该key，直接赋值
41.                         nowMap = (Map) wordMap;
42.                     }
43.                     else{     //不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个
44.                         newWorMap = new HashMap();
45.                         newWorMap.put("isEnd", "0");     //不是最后一个
46.                         nowMap.put(keyChar, newWorMap);
47.                         nowMap = newWorMap;
48.                     }
49.                     if(i == key.length() - 1){
50.                         nowMap.put("isEnd", "1");    //最后一个
51.                     }
52.                 }
53.             }
54.         }
55. //读取敏感词文件 加到set集合中
56.         @SuppressWarnings("resource")
57.         private Set readSensitiveWordFile() throws Exception{
58.             Set set = null; 
59.            File file = new File("D:\\SensitiveWord.txt");    //读取文件 
60.             InputStreamReader read = new InputStreamReader(new FileInputStream(file),ENCODING);
61.             try {
62.                 if(file.isFile() && file.exists()){      //文件流是否存在
63.                     set = new HashSet();
64.                     BufferedReader bufferedReader = new BufferedReader(read);
65.                     String txt = null;
66.                     while((txt = bufferedReader.readLine()) != null){    //读取文件，将文件内容放入到set中
67.                         set.add(txt);
68.                     }
69.                 }
70.                 else{         //不存在抛出异常信息
71.                     throw new Exception("敏感词库文件不存在");
72.                 }
73.             } catch (Exception e) {
74.                 throw e;
75.             }finally{
76.                 read.close();     //关闭文件流
77.             }
78.             return set;
79.         } 
80. }

接下来是对比敏感词库的工具类：

 

1. /**
2.  * 敏感词过滤
3.  * 
4.  * */
5. public class SensitivewordFilter {
6.     @SuppressWarnings("rawtypes")
7.     public Map sensitiveWordMap = null;
8.     public static int minMatchTYpe = 1;      //最小匹配规则
9.     public static int maxMatchType = 2;      //最大匹配规则
10.     /**
11.      * 构造函数，初始化敏感词库
12.      */
13.     public SensitivewordFilter(){
14.         sensitiveWordMap = new SensitiveWordInit().initKeyWord();
15.     }
16.     /**
17.      * 判断文字是否包含敏感字符 
18.      * @param txt  文字
19.      * @param matchType  匹配规则 1：最小匹配规则，2：最大匹配规则
20.      * @return 若包含返回true，否则返回false
21.      * @version 1.0
22.      */
23.     public boolean isContaintSensitiveWord(String txt,int matchType){
24.         boolean flag = false;
25.         for(int i = 0 ; i < txt.length() ; i++){
26.             int matchFlag = this.CheckSensitiveWord(txt, i, matchType); //判断是否包含敏感字符
27.             if(matchFlag > 0){    //大于0存在，返回true
28.                 flag = true;
29.             }
30.         }
31.         return flag;
32.     }
33.     /**
34.      * 检查文字中是否包含敏感字符，检查规则如下：  
35.      * @param txt
36.      * @param beginIndex
37.      * @param matchType
38.      * @return，如果存在，则返回敏感词字符的长度，不存在返回0
39.      * @version 1.0
40.      */
41.     @SuppressWarnings({ "rawtypes"})
42.     public int CheckSensitiveWord(String txt,int beginIndex,int matchType){
43.         boolean  flag = false;    //敏感词结束标识位：用于敏感词只有1位的情况
44.         int matchFlag = 0;     //匹配标识数默认为0
45.         char word = 0;
46.         Map nowMap = sensitiveWordMap;
47.         for(int i = beginIndex; i < txt.length() ; i++){
48.             word = txt.charAt(i);
49.             System.out.println(nowMap);
50.             nowMap = (Map) nowMap.get(word);     //获取指定key
51.             System.out.println(nowMap);
52.             if(nowMap != null){     //存在，则判断是否为最后一个
53.                 matchFlag++;     //找到相应key，匹配标识+1 
54.                 if("1".equals(nowMap.get("isEnd"))){       //如果为最后一个匹配规则,结束循环，返回匹配标识数
55.                     flag = true;       //结束标志位为true   
56.                     if(SensitivewordFilter.minMatchTYpe == matchType){    //最小规则，直接返回,最大规则还需继续查找
57.                         break;
58.                     }
59.                 }
60.             }
61.             else{     //不存在，直接返回
62.                 break;
63.             }
64.         }
65.         if(matchFlag < 2 || !flag){        //长度必须大于等于1，为词 
66.             matchFlag = 0;
67.         }
68.         return matchFlag;
69.     }
70.  
71.     /**
72.      * 获取文字中的敏感词
73.      *  
74.      * @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则
75.      * @return
76.      * @version 1.0
77.      */
78.     public Set getSensitiveWord(String txt , int matchType){
79.         Set sensitiveWordList = new HashSet();
80.         for(int i = 0 ; i < txt.length() ; i++){
81.             int length = CheckSensitiveWord(txt, i, matchType);    //判断是否包含敏感字符
82.             if(length > 0){    //存在,加入list中
83.                 sensitiveWordList.add(txt.substring(i, i+length));
84.                 i = i + length - 1;    //减1的原因，是因为for会自增
85.             }
86.         }
87.         return sensitiveWordList;
88.     }