Java进阶学习第十一天（过滤器）

一、过滤器

1、过滤器的设计执行流程
① 用户访问服务器
② 过滤器： 对Servlet请求进行拦截
③ 先进入过滤器， 过滤器处理
④ 过滤器处理完后， 在放行， 此时，请求到达Servlet/JSP
⑤ Servlet处理
⑥ Servlet处理完后，再回到过滤器, 最后在由tomcat服务器响应用户

2、开发步骤
① 写一个普通java类，实现Filter接口Javax.servlet.*;
② 配置过滤器

3、过滤器相关API
① interface Filter ：过滤器核心接口
◆ Void init(filterConfig);：初始化方法，在服务器启动时候执行
◆ Void doFilter(request,response,filterChain);：过滤器拦截的业务处理方法
◆ Void destroy();：销毁过滤器实例时候调用
② interface FilterConfig 获取初始化参数信息
◆ String getInitParameter(java.lang.String name)
◆ Enumeration getInitParameterNames()
③ interface FilterChain 过滤器链参数；一个个过滤器形成一个执行链
◆ void doFilter(ServletRequest request, ServletResponse response) ;：执行下一个过滤器或放行

4、过滤器的HelloWorld案例

/**
 * Servlet:处理用户http request
 */
public class IndexServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
        // 设置POST提交的请求的编码
        request.setCharacterEncoding("UTF-8");
        // 设置相应体的编码
        response.setCharacterEncoding("UTF-8");
        // 设置页面打开时候时候的编码格式、 设置相应体的编码
        response.setContentType("text/html;charset=UTF-8");
        // GET提交中文
        String str = request.getParameter("");
        str = new String(str.getBytes("ISO8859-1"),"UTF-8");
        response.sendRedirect(request.getContextPath() + "/servletTest");
        //request.getRequestDispatcher("/servletTest").forward(request, response);
    }
}

/**
 * 过滤器，测试
 */
public class HelloFilter implements Filter{
    // 创建实例
    public HelloFilter(){
        System.out.println("1. 创建过滤器实例");
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("2. 执行过滤器初始化方法");
        // 获取过滤器在web.xml中配置的初始化参数
        String encoding = filterConfig.getInitParameter("encoding");
        System.out.println(encoding);   
        // 获取过滤器在web.xml中配置的初始化参数的名称
        Enumeration<String> enums =  filterConfig.getInitParameterNames();
        while (enums.hasMoreElements()){
            // 获取所有参数名称：encoding、path
            String name = enums.nextElement();
            // 获取名称对应的值
            String value = filterConfig.getInitParameter(name);
            System.out.println(name + "\t" + value);
        }
    }
    // 过滤器业务处理方法： 在请求到达servlet之前先进入此方法处理公用的业务逻辑操作
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.out.println("3. 执行过滤器业务处理方法");
        // 放行 (去到Servlet)
        // 如果有下一个过滤器，进入下一个过滤器，否则就执行访问servlet
        chain.doFilter(request, response);
        System.out.println("5. Servlet处理完成，又回到过滤器");
    }
    @Override
    public void destroy() {
        System.out.println("6. 销毁过滤器实例");
    }
}

<!-- 过滤器配置 -->
    <filter>
        <!-- 配置初始化参数 -->
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>path</param-name>
            <param-value>c:/...</param-value>
        </init-param>
        <!-- 内部名称 -->
        <filter-name>hello_filter</filter-name>
        <!-- 过滤器类的全名 -->
        <filter-class>cn.itcast.a_filter_hello.HelloFilter</filter-class>
    </filter>

    <filter-mapping>
        <!-- filter内部名称 -->
        <filter-name>hello_filter</filter-name>
        <!-- 拦截所有资源 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

<!-- 配置第二个过滤器 -->
    <!-- 演示： 拦截指定的请求 -->
    <filter>
        <filter-name>hello_filter2</filter-name>
        <filter-class>cn.itcast.a_filter_hello.HelloFilter2</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>hello_filter2</filter-name>
        <!-- 1. 拦截所有
        <url-pattern>/*</url-pattern>
         -->         
         <!-- 2. 拦截指定的jsp 
         <url-pattern>/index.jsp</url-pattern>
         <url-pattern>/list.jsp</url-pattern>
         -->
         <!-- 拦截所有的jsp
         <url-pattern>*.jsp</url-pattern>
          -->
         <!-- 3. 根据servlet的内部名称拦截
         <servlet-name>IndexServlet</servlet-name>
          -->
         <!-- 拦截指定的servlet 
         <url-pattern>/index</url-pattern>
         -->  
         <!-- 4. 指定拦截指定的类型 -->
         <url-pattern>/*</url-pattern>
         <dispatcher>REQUEST</dispatcher> //默认拦截的类型：(直接访问或者重定向)
         <dispatcher>FORWARD</dispatcher> //拦截转发 
         <dispatcher>INCLUDE</dispatcher>//拦截包含的页面(RequestDispatcher.include(/page.jsp);对page.jsp也执行拦截)
         <dispatcher>ERROR</dispatcher> //拦截声明式异常信息
    </filter-mapping>

5、共性问题：
① 过滤器：方法参数没有自动命名，说明没有关联源码
关联tomcat或servlet源代码
② 连接池： 多刷新几次，报错！
◆ 连接没关：

QueryRunner qr = new QueryRunner();
qr.update(con,sql);// 这里con一定要关闭

◆ 注意：dataSource 确定一个项目创建一次
QueryRunner qr = new QueryRunner(dataSource);
◆ 修改连接池参数配置
③ 编码

// 设置POST提交的请求的编码
request.setCharacterEncoding("UTF-8");
// 设置相应体的编码
response.setCharacterEncoding("UTF-8");
// 设置页面打开时候时候的编码格式、设置相应体的编码
response.setContentType("text/html;charset=UTF-8");

开发中：工作区间编码、项目编码、request/response、数据库编码一致！

6、案例：编码统一处理
几乎每一个Servlet都要涉及编码处理：处理请求数据中文问题！每个servlet都要做这些操作，把公用的代码抽取-过滤器实现！

/**
 * 编码处理统一写到这里(servlet中不需要再处理编码)
 */
public class EncodingFilter implements Filter {
    // 过滤器业务处理方法：处理的公用的业务逻辑操作
    @Override
    public void doFilter(ServletRequest req, ServletResponse res,
            FilterChain chain) throws IOException, ServletException {   
        // 转型
        final HttpServletRequest request = (HttpServletRequest) req;    
        HttpServletResponse response = (HttpServletResponse) res;
        // 一、处理公用业务
        request.setCharacterEncoding("UTF-8");// POST提交有效
        response.setContentType("text/html;charset=UTF-8");
        /*
         * 出现GET中文乱码，是因为在request.getParameter方法内部没有进行提交方式判断并处理。
         * String name = request.getParameter("userName");
         * 
         * 解决：对指定接口的某一个方法进行功能扩展，可以使用代理!
         *      对request对象(目标对象)，创建代理对象！
         */
        HttpServletRequest proxy =  (HttpServletRequest) Proxy.newProxyInstance(
                request.getClass().getClassLoader(), // 指定当前使用的累加载器
                new Class[]{HttpServletRequest.class}, // 对目标对象实现的接口类型
                new InvocationHandler() {   // 事件处理器
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        // 定义方法返回值
                        Object returnValue = null;
                        // 获取方法名
                        String methodName = method.getName();
                        // 判断：对getParameter方法进行GET提交中文处理
                        if ("getParameter".equals(methodName)) {
                            // 获取请求数据值【 <input type="text" name="userName">】
                            String value = request.getParameter(args[0].toString());    // 调用目标对象的方法
                            // 获取提交方式
                            String methodSubmit = request.getMethod(); // 直接调用目标对象的方法
                            // 判断如果是GET提交，需要对数据进行处理  (POST提交已经处理过了)
                            if ("GET".equals(methodSubmit)) {
                                if (value != null && !"".equals(value.trim())){
                                    // 处理GET中文
                                    value = new String(value.getBytes("ISO8859-1"),"UTF-8");
                                }
                            } 
                            return value;
                        }
                        else {
                            // 执行request对象的其他方法
                            returnValue = method.invoke(request, args);
                        }
                        return returnValue;
                    }
                });
        // 二、放行 (执行下一个过滤器或者servlet)
        chain.doFilter(proxy, response);// 传入代理对象
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void destroy() { 
    }
}

过滤器配置：

<!-- 编码处理过滤器配置 -->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>cn.itcast.a_loginFilter.EncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

Servlet：

public class LoginServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 获取请求数据 
        String name = request.getParameter("userName");
        System.out.println("用户：" + name);
    }

6、案例：无效数据过滤
模拟：论坛过滤敏感词汇！

JSP引入ckeditor组件：客户端组件，便于用户输入内容！
JSP：

<!-- 引入ckeditor组件(给用户输入提供方便) --> 
    <script src="${pageContext.request.contextPath }/ckeditor/ckeditor.js"></script>
    <link rel="stylesheet" href="${pageContext.request.contextPath }/ckeditor/samples/sample.css">
<body>
    ${requestScope.content }
    <form name="frmDis" action="${pageContext.request.contextPath }/dis" method="post">
      发表评论: <textarea class="ckeditor" rows="6" cols="30" name="content"></textarea> 
      <br/>
      <input type="submit" value="评论" >
    </form>
  </body>

Filter：
在上个过滤器案例的基础上，增加如下代码：

// 中文数据已经处理完： 下面进行无效数据过滤   
//【如何value中出现dirtyData中数据，用****替换】  
for (String data : dirtyData) {
    // 判断当前输入数据(value), 是否包含无效数据
    if (value.contains(data)){
            value = value.replace(data, "*****");
    }
}

7、案例：登录验证
分析：
① 先指定放行的资源，哪些资源不需要拦截：
② 获取session，从session中获取登陆用户
③ 判断是否为空：
◆ 为空， 说明没有登陆， 跳转到登陆
◆不为空， 已经登陆，放行！

/**
 * 登陆验证过滤器
 * 
 *  http://localhost:8080/emp_sys/login.jsp   可以直接访问
 *  http://localhost:8080/emp_sys/login      可以直接访问
 *  http://localhost:8080/emp_sys/index   不能直接访问
 *  http://localhost:8080/emp_sys/list.jsp   不能直接访问
 */
public class LoginFilter implements Filter {
    private String uri;
    @Override
    public void doFilter(ServletRequest req, ServletResponse res,
            FilterChain chain) throws IOException, ServletException {
        //0. 转换
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;
        //1. 获取请求资源，截取  
        String uri = request.getRequestURI();   // /emp_sys/login.jsp
        // 截取 【login.jsp或login】
        String requestPath = uri.substring(uri.lastIndexOf("/") + 1, uri.length());  

        //2. 判断： 先放行一些资源：/login.jsp、/login
        if ("login".equals(requestPath) || "login.jsp".equals(requestPath)) {
            // 放行
            chain.doFilter(request, response);
        }
        else {
            //3. 对其他资源进行拦截
            //3.1 先获取Session、获取session中的登陆用户(loginInfo)
            HttpSession session = request.getSession(false);
            // 判断
            if (session != null) {
                Object obj = session.getAttribute("loginInfo");
                //3.2如果获取的内容不为空，说明已经登陆，放行
                if (obj != null) {
                    // 放行
                    chain.doFilter(request, response);
                } else {
                    //3.3如果获取的内容为空，说明没有登陆； 跳转到登陆
                    uri = "/login.jsp";
                }   
            } else {
                // 肯定没有登陆
                uri = "/login.jsp";
            }
            request.getRequestDispatcher(uri).forward(request, response);
        }
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void destroy() {
    }
}