敏感词过滤的算法原理之DFA算法

敏感词、文字过滤是一个网站必不可少的功能，如何设计一个好的、高效的过滤算法是非常有必要的。前段时间我一个朋友（马上毕业，接触编程不久）要我帮他看一个文字过滤的东西，它说检索效率非常慢。我把它程序拿过来一看，整个过程如下：读取敏感词库、如果HashSet集合中，获取页面上传文字，然后进行匹配。我就想这个过程肯定是非常慢的。对于他这个没有接触的人来说我想也只能想到这个，更高级点就是正则表达式。但是非常遗憾，这两种方法都是不可行的。当然，在我意识里没有我也没有认知到那个算法可以解决问题，但是Google知道！

 

        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算法中几乎没有什么计算，有的只是状态的转换。

         参考文献：http://www.iteye.com/topic/336577

 

         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；

 

 

         程序实现如下：

 

[java] view plain copy

 

1. /** 
2.      * 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：<br> 
3.      * 中 = { 
4.      *      isEnd = 0 
5.      *      国 = {<br> 
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.      * @author chenming  
31.      * @date 2014年4月20日 下午3:04:20 
32.      * @param keyWordSet  敏感词库 
33.      * @version 1.0 
34.      */  
35.     @SuppressWarnings({ "rawtypes", "unchecked" })  
36.     private void addSensitiveWordToHashMap(Set<String> keyWordSet) {  
37.         sensitiveWordMap = new HashMap(keyWordSet.size());     //初始化敏感词容器，减少扩容操作  
38.         String key = null;    
39.         Map nowMap = null;  
40.         Map<String, String> newWorMap = null;  
41.         //迭代keyWordSet  
42.         Iterator<String> iterator = keyWordSet.iterator();  
43.         while(iterator.hasNext()){  
44.             key = iterator.next();    //关键字  
45.             nowMap = sensitiveWordMap;  
46.             for(int i = 0 ; i < key.length() ; i++){  
47.                 char keyChar = key.charAt(i);       //转换成char型  
48.                 Object wordMap = nowMap.get(keyChar);       //获取  
49.                   
50.                 if(wordMap != null){        //如果存在该key，直接赋值  
51.                     nowMap = (Map) wordMap;  
52.                 }  
53.                 else{     //不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个  
54.                     newWorMap = new HashMap<String,String>();  
55.                     newWorMap.put("isEnd", "0");     //不是最后一个  
56.                     nowMap.put(keyChar, newWorMap);  
57.                     nowMap = newWorMap;  
58.                 }  
59.                   
60.                 if(i == key.length() - 1){  
61.                     nowMap.put("isEnd", "1");    //最后一个  
62.                 }  
63.             }  
64.         }  
65.     }  

         运行得到的hashMap结构如下：

{五={星={红={isEnd=0, 旗={isEnd=1}}, isEnd=0}, isEnd=0}, 中={isEnd=0, 国={isEnd=0, 人={isEnd=1}, 男={isEnd=0, 人={isEnd=1}}}}}

         敏感词库我们一个简单的方法给实现了，那么如何实现检索呢？检索过程无非就是hashMap的get实现，找到就证明该词为敏感词，否则不为敏感词。过程如下：假如我们匹配“中国人民万岁”。

         1、第一个字“中”，我们在hashMap中可以找到。得到一个新的map = hashMap.get("")。

         2、如果map == null，则不是敏感词。否则跳至3

         3、获取map中的isEnd，通过isEnd是否等于1来判断该词是否为最后一个。如果isEnd == 1表示该词为敏感词，否则跳至1。

         通过这个步骤我们可以判断“中国人民”为敏感词，但是如果我们输入“中国女人”则不是敏感词了。

 

[java] view plain copy

 

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

         在文章末尾我提供了利用Java实现敏感词过滤的文件下载。下面是一个测试类来证明这个算法的效率和可靠性。

 

[java] view plain copy

 

1. public static void main(String[] args) {  
2.         SensitivewordFilter filter = new SensitivewordFilter();  
3.         System.out.println("敏感词的数量：" + filter.sensitiveWordMap.size());  
4.         String string = "太多的伤感情怀也许只局限于饲养基地 荧幕中的情节，主人公尝试着去用某种方式渐渐的很潇洒地释自杀指南怀那些自己经历的伤感。"  
5.                         + "然后法.轮.功 我们的扮演的角色就是跟随着主人公的喜红客联盟 怒哀乐而过于牵强的把自己的情感也附加于银幕情节中，然后感动就流泪，"  
6.                         + "难过就躺在某一个人的怀里尽情的阐述心扉或者手机卡复制器一个人一杯红酒一部电影在夜三.级.片 深人静的晚上，关上电话静静的发呆着。";  
7.         System.out.println("待检测语句字数：" + string.length());  
8.         long beginTime = System.currentTimeMillis();  
9.         Set<String> set = filter.getSensitiveWord(string, 1);  
10.         long endTime = System.currentTimeMillis();  
11.         System.out.println("语句中包含敏感词的个数为：" + set.size() + "。包含：" + set);  
12.         System.out.println("总共消耗时间为：" + (endTime - beginTime));  
13.     }  

         运行结果：

         从上面的结果可以看出，敏感词库有771个，检测语句长度为184个字符，查出6个敏感词。总共耗时1毫秒。可见速度还是非常可观的。

 

转载自：https://blog.csdn.net/chenssy/article/details/26961957

来源：https://www.cnblogs.com/twoheads/p/11349541.html