JavaWeb 敏感词汇过滤器

1，基本功能

        在提交数据时，常常需要检查数据中是否含有敏感词汇，有的话，需要屏蔽敏感词汇

2，实现原理

        我们可以使用Filter过滤器，对数据进行检查与处理，将处理完毕的数据放行。因此，在javaweb中，我们可以先在Filter中，对数据进行处理。可以使用动态代理的方式进行。

动态代理：

        即在内存中形成代理类，可以对真实对象做增强操作。

3，实现步骤

1，对request对象进行加强，增强获取参数相关方法

2，放行，传递代理对象

4，代码实现

1,在src目录下生成 敏感词汇.txt

 2,过滤器代码

先使用流加载敏感词汇的内容，再在动态代理中，对getParameter（），getParameterMap（），

getParameterValues（）三种方法做不同增强。

package Filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.awt.*;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

@WebFilter("/*")
public class SenstiveWordsFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //创建request的代理对象,增强getParameter方法，getParameterMap方法，getParameterValues方法
        ServletRequest proxy_req = (ServletRequest) Proxy.newProxyInstance(servletRequest.getClass().getClassLoader(), servletRequest.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //判断是否是getParameter方法
                if(method.getName().equals("getParameter")){
                    //增强返回值
                    //1，获取返回值
                    String value = (String) method.invoke(servletRequest, args);
                    //判断返回值中是否为空
                    if(value!=null){
                        //判断value中是否有敏感词汇
                        for (String str:list) {
                            if(value.contains(str)){
                                //如果有敏感词汇，将敏感词汇修改成***
                                value=value.replaceAll(str,"***");
                            }
                        }
                    }
                    return value;
                }
                //判断是否是getParameterMap方法
                else if(method.getName().equals("getParameterMap")){
                    //增强返回值
                    //1，获取返回值
                    Map<String,String[]> map= (Map<String,String[]>) method.invoke(servletRequest, args);
                    //遍历map集合，将其中的敏感词汇替换
                    Set<String> set =map.keySet();
                    for (String key:set) {
                        for (String value:map.get(key)) {
                            int i=0;
                            if(value!=null){
                                //判断value中是否有敏感词汇
                                for (String str:list) {
                                    if(value.contains(str)){
                                        //如果有敏感词汇，将敏感词汇修改成***
                                        map.get(key)[i]=value.replaceAll(str,"***");
                                        i++;
                                    }
                                }
                            }
                        }
                    }
                    return map;
                }
                //判断是否是getParameterValues方法
                else if(method.getName().equals("getParameterValues")){
                    //增强返回值
                    //1，获取返回值
                    String[] values=(String[]) method.invoke(servletRequest,args);
                    //2,遍历values数组，替换敏感词汇
                    for (int i=0;i<values.length;i++){
                        if(values[i]!=null){
                            //判断value中是否有敏感词汇
                            for (String str:list) {
                                if(values[i].contains(str)){
                                    //如果有敏感词汇，将敏感词汇修改成***
                                   values[i]=values[i].replaceAll(str,"***");
                                }
                            }
                        }
                    }
                    return values;
                }
                return method.invoke(servletRequest,args);
            }
        });
        filterChain.doFilter(proxy_req,servletResponse);
    }
    //敏感词汇集合
    private List<String> list=new ArrayList<String>();
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        try {
            //1,获取文件真实路径
            ServletContext servletContext = filterConfig.getServletContext();
            String realPath = servletContext.getRealPath("/WEB-INF/classes/敏感词汇.txt");
            //2,读取文件
            //使用BufferdReader字符输入流
            BufferedReader br=new BufferedReader(new FileReader(realPath));
            //3,将文件中的每一行数据加载到list中
            String line=null;
            while ((line=br.readLine())!=null){
                list.add(line);
            }
            //4,关闭流
            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void destroy() {

    }
}