配置过滤去处理 敏感词

版权声明：本文为博主原创文章，未经博主允许不得转载。

很多网站都需要对于某些关键字或者某些敏感词汇进行过滤替换的功能。比如在输入框中输入些js 脚本，或者输入些政府类型的词汇等都是不允许的，但是你不能限制用户的自由。所以对于网站的过滤功能就显得很有必要了。对于一般的网站使用来说，不需要非常复杂的过滤算法等比较高端的实现。简单的用 filter 和 HttpServletRequestWrapper 就可以实现。

HttpServletRequestWrapper 的实现采用了包装模式，具体介绍请另找资料。直接切入正题。实现思路：首先定义一个 properties文件，在文件中存放需要替换的文字和替换后的文字，比如替换 fuck=** ，政府 =** ，替换 <=< 和 >=> （这样就可以避免文本输入的 js 脚本）。然后定义一个类来继承 HttpServletRequestWrapper 达到包装 request对象的作用，最后用一个 filter 使用包装后的 request 对象（即已经经过了过滤作用）。

keyword.properties文件：

[java]  view plain  copy

1. CNM=**    
2. fuck=**    
3. <=<    
4. >=>  

然后写一个操作properties文件的工具类，PropertiesUtil.java

[java]  view plain  copy

1. package com.lhwl.elt.filter;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.InputStream;  
6. import java.util.Enumeration;  
7. import java.util.HashMap;  
8. import java.util.Iterator;  
9. import java.util.Map;  
10. import java.util.Properties;  
11. import java.util.Set;  
12.   
13. public class PropertiesUtil{  
14.       
15.     public static Map readProperties(String src) {  
16.         Properties props = new Properties();  
17.         Map map = new HashMap();  
18.         try {  
19.             File file=new File(src);  
20.             InputStream in=new FileInputStream(file);  
21.             props.load(in);  
22.             Enumeration en = props.propertyNames();  
23.             while (en.hasMoreElements()) {  
24.                 String key = (String) en.nextElement();  
25.                 String value = props.getProperty(key);  
26.                 map.put(key, value);//把properties文件中的key-value存放到一个map中  
27.             }  
28.             return map;  
29.         } catch (Exception e) {  
30.             e.printStackTrace();  
31.         }  
32.         return null;  
33.     }  
34.   
35.     public static String replaceCheck(Map map,String name) {  
36.         Set<String> keys = map.keySet();  
37.         Iterator<String> iter = keys.iterator();  
38.         while (iter.hasNext()) {  
39.             String key = iter.next();  
40.             String value = (String) map.get(key);  
41.             if (name.contains(key)) {  
42.                 name=name.replace(key, value);//对于符合map中的key值实现替换功能  
43.                   
44.             }  
45.         }  
46.         return name;  
47.     }  
48.   
49. }  

这里我把从properties文件中读取的key--value的形式都存放到一个map对象中，方法都用static关键字，方便调用。
    然后写了个KeyWordRequestWrapper来继承HttpServletRequestWrapper，实现包装request对象的作用。

[java]  view plain  copy

1. package com.lhwl.elt.filter;  
2.   
3. import java.util.Iterator;  
4. import java.util.Map;  
5. import java.util.Set;  
6.   
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletRequestWrapper;  
9.   
10. public final class KeyWordRequestWrapper extends HttpServletRequestWrapper{  
11.       
12.     public Map keyMap;  
13.       
14.     public KeyWordRequestWrapper(HttpServletRequest servletRequest,Map keyMap){  
15.         super(servletRequest);  
16.         this.keyMap = keyMap;  
17.     }  
18.    /*   
19.     @Override  
20.     public Map getParameterMap() {  
21.         super.getContextPath();  
22.         Map<String,String[]> map = super.getParameterMap();  
23.         if(!map.isEmpty()){  
24.             Set<String> keySet = map.keySet();  
25.             Iterator<String> keyIt = keySet.iterator();  
26.             while(keyIt.hasNext()){  
27.                 String key = keyIt.next();  
28. //              String value = map.get(key)[0];  
29. //              map.get(key)[0] = this.replaceParam(value);  
30.                 //这边实现对整个数组的判断。  
31.                 String[] values=map.get(key);  
32.                 for(int i=0;i<values.length;i++){  
33.                     map.get(key)[i]=this.replaceParam(values[i]);  
34.                 }  
35.             }  
36.         }  
37.         return map;  
38.     }  
39.   
40.       */
41.  @Override 
42.     public String[] getParameterValues(String name) { 
43.         // TODO Auto-generated method stub 
44.         String[] resources = super.getParameterValues(name);  
45.         if (resources == null)  
46.         return null;  
47.         int count = resources.length;  
48.         String[] results = new String[count];  
49.         for (int i = 0; i < count; i++) {  
50.             results[i] = this.replaceParam(resources[i]);  
51.         }  
52.         return results;  
53.     } 
54.   
55.     public String replaceParam(String name){  
56.         return PropertiesUtil.replaceCheck(keyMap,name);  
57.     }  
58. }  

   还剩个filter来实现了，先看具体的filter代码：

[java]  view plain  copy

1. package com.lhwl.elt.filter;  
2.   
3. import java.io.IOException;  
4. import java.util.HashMap;  
5.   
6. import javax.servlet.Filter;  
7. import javax.servlet.FilterChain;  
8. import javax.servlet.FilterConfig;  
9. import javax.servlet.ServletException;  
10. import javax.servlet.ServletRequest;  
11. import javax.servlet.ServletResponse;  
12. import javax.servlet.http.HttpServletRequest;  
13.   
14. public class KeyWordFilter implements Filter{  
15.     private FilterConfig filterConfig;  
16.       
17.     public static HashMap keyMap = null;  
18.     public static String path;  
19.       
20.     @Override  
21.     public void init(FilterConfig filterConfig) throws ServletException {  
22.         this.filterConfig=filterConfig;  
23.         String keyWordPath = filterConfig.getInitParameter("key");  
24.         path = filterConfig.getServletContext().getRealPath(keyWordPath);  
25.           
26.     }  
27.       
28.     @Override  
29.     public void doFilter(ServletRequest request, ServletResponse response,   
30.             FilterChain chain) throws IOException, ServletException {  
31.         HttpServletRequest req = (HttpServletRequest)request;  
32.         if(keyMap == null){  
33.                 keyMap = (HashMap)PropertiesUtil.readProperties(path);  
34.         }  
35.         if(req.getMethod().equals("POST")){  
36.             chain.doFilter(new KeyWordRequestWrapper(req,keyMap), response);  
37.         }else{  
38.             chain.doFilter(request, response);  
39.         }  
40.     }  
41.   
42.     @Override  
43.     public void destroy() {  
44.         this.filterConfig = null;   
45.     }  
46.   
47. }  

这里在filter初始化的时候，就获得项目的真实路径，然后把最先定义的keyword.properties文件放到WEB-INF目录下，定义一个 keyWordPath，然后就可以通过在web.xml文件中配置init-param来注入。这里把keyMap和path都定义为static，这 样只需要在加载的时候一次初始化就好了。chain.doFilter(new KeyWordRequestWrapper(req,keyMap), response);对于需要过滤的内容进行处理关键字，敏感字等，其他的则正常chain.doFilter(request, response); 最后再web.xml中配置这个filter就可以，注意配置的顺序不要和其他filter冲突就行。web.xml配置：

[java]  view plain  copy

1. <!-- 配置过滤关键字 -->    
2.     <filter>    
3.         <filter-name>keyWordFilter</filter-name>    
4.         <filter-class>com.lhwl.elt.filter.KeyWordFilter</filter-class>    
5.         <init-param>    
6.             <param-name>key</param-name>    
7.             <param-value>/WEB-INF/keyword.properties</param-value>    
8.         </init-param>    
9.     </filter>     
10.         
11.     <filter-mapping>    
12.         <filter-name>keyWordFilter</filter-name>    
13.         <url-pattern>/*</url-pattern>    
14.     </filter-mapping>    

OK，现在只要输入些properties文件中定义好要替换的内容，则自动的实现了替换功能。比如输入fuck，提交显示出来的就变成了**，对输入的一些js脚本也能够当成文本显示出来了。