JavaWeb开发与代码的编写(十八)

阿里云国内75折回扣微信号：monov8

阿里云国际，腾讯云国际，低至75折。AWS 93折免费开户实名账号代冲值优惠多多微信号：monov8 飞机：@monov6

JavaWeb开发与代码的编写(十八)

Filter(过滤器)

　　Filter也称之为过滤器，它是Servlet技术中最激动人心的技术，WEB开发人员通过Filter技术，对web服务器管理的所有web资源：例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截，从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。
　　Servlet API中提供了一个Filter接口，开发web应用时，如果编写的Java类实现了这个接口，则把这个java类称之为过滤器Filter。通过Filter技术，开发人员可以实现用户在访问某个目标资源之前，对访问的请求和响应进行拦截，如下所示：

JavaWeb开发与代码的编写(十八)_java

Filter是如何实现拦截的？

　　Filter接口中有一个doFilter方法，当我们编写好Filter，并配置对哪个web资源进行拦截后，WEB服务器每次在调用web资源的service方法之前，都会先调用一下filter的doFilter方法，因此，在该方法内编写代码可达到如下目的：

调用目标资源之前，让一段代码执行。
是否调用目标资源（即是否让用户访问web资源）。
调用目标资源之后，让一段代码执行。

　　web服务器在调用doFilter方法时，会传递一个filterChain对象进来，filterChain对象是filter接口中最重要的一个对象，它也提供了一个doFilter方法，开发人员可以根据需求决定是否调用此方法，调用该方法，则web服务器就会调用web资源的service方法，即web资源就会被访问，否则web资源不会被访问。

Filter开发入门

Filter开发步骤

　　Filter开发分为二个步骤：

编写java类实现Filter接口，并实现其doFilter方法。
在 web.xml 文件中使用<filter>和<filter-mapping>元素对编写的filter类进行注册，并设置它所能拦截的资源。

　　过滤器范例：

package me.gacl.web.filter;
 
 import java.io.IOException;
 
 import javax.servlet.Filter;
 import javax.servlet.FilterChain;
 import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 
 /**
 * @ClassName: FilterDemo01
 * @Description:filter的三种典型应用：
 *                     1、可以在filter中根据条件决定是否调用chain.doFilter(request, response)方法，
 *                        即是否让目标资源执行
 *                     2、在让目标资源执行之前，可以对request\response作预处理，再让目标资源执行
 *                     3、在目标资源执行之后，可以捕获目标资源的执行结果，从而实现一些特殊的功能
 */ 
 public class FilterDemo01 implements Filter {

     @Override
     public void init(FilterConfig filterConfig) throws ServletException {
         System.out.println("----过滤器初始化----");
     }
 
    @Override
     public void doFilter(ServletRequest request, ServletResponse response,
             FilterChain chain) throws IOException, ServletException {
         
         //对request和response进行一些预处理
         request.setCharacterEncoding("UTF-8");
         response.setCharacterEncoding("UTF-8");
         response.setContentType("text/html;charset=UTF-8");
         
         System.out.println("FilterDemo01执行前！！！");
         chain.doFilter(request, response);  //让目标资源执行，放行
         System.out.println("FilterDemo01执行后！！！");
     }
 
     @Override
     public void destroy() {
         System.out.println("----过滤器销毁----");
     }
 }

　　在web. xml中配置过滤器：

<?xml version="1.0" encoding="UTF-8"?>
  <web-app version="3.0" 
      xmlns="http://java.sun.com/xml/ns/javaee" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
      xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
      http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <display-name></display-name>    
    <welcome-file-list>
      <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <!--配置过滤器-->
   <filter>
       <filter-name>FilterDemo01</filter-name>
       <filter-class>me.gacl.web.filter.FilterDemo01</filter-class>
   </filter>
   
   <!--映射过滤器-->
   <filter-mapping>
      <filter-name>FilterDemo01</filter-name>
      <!--“/*”表示拦截所有的请求 -->
       <url-pattern>/*</url-pattern>
   </filter-mapping>
   
 </web-app>

Filter链

　　在一个web应用中，可以开发编写多个Filter，这些Filter组合起来称之为一个Filter链。
　　web服务器根据Filter在web.xml文件中的注册顺序，决定先调用哪个Filter，当第一个Filter的doFilter方法被调用时，web服务器会创建一个代表Filter链的FilterChain对象传递给该方法。在doFilter方法中，开发人员如果调用了FilterChain对象的doFilter方法，则web服务器会检查FilterChain对象中是否还有filter，如果有，则调用第2个filter，如果没有，则调用目标资源。

Filter的生命周期

Filter的创建

　　Filter的创建和销毁由WEB服务器负责。 web 应用程序启动时，web 服务器将创建Filter 的实例对象，并调用其init方法，完成对象的初始化功能，从而为后续的用户请求作好拦截的准备工作，filter对象只会创建一次，init方法也只会执行一次。通过init方法的参数，可获得代表当前filter配置信息的FilterConfig对象。

Filter的销毁

　　Web容器调用destroy方法销毁Filter。destroy方法在Filter的生命周期中仅执行一次。在destroy方法中，可以释放过滤器使用的资源。

FilterConfig接口

　　用户在配置filter时，可以使用<init-param>为filter配置一些初始化参数，当web容器实例化Filter对象，调用其init方法时，会把封装了filter初始化参数的filterConfig对象传递进来。因此开发人员在编写filter时，通过filterConfig对象的方法，就可获得：
　　String getFilterName()：得到filter的名称。
　　String getInitParameter(String name)：返回在部署描述中指定名称的初始化参数的值。如果不存在返回null.
　　Enumeration getInitParameterNames()：返回过滤器的所有初始化参数的名字的枚举集合。
　　public ServletContext getServletContext()：返回Servlet上下文对象的引用。
范例：利用FilterConfig得到filter配置信息

1 package me.gacl.web.filter;
 2 
 3 import java.io.IOException;
 4 import java.util.Enumeration;
 5 import javax.servlet.Filter;
 6 import javax.servlet.FilterChain;
 7 import javax.servlet.FilterConfig;
 8 import javax.servlet.ServletException;
 9 import javax.servlet.ServletRequest;
10 import javax.servlet.ServletResponse;
11 
12 public class FilterDemo02 implements Filter {
13 
14     /* 过滤器初始化
15      * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
16      */
17     @Override
18     public void init(FilterConfig filterConfig) throws ServletException {
19         System.out.println("----过滤器初始化----");
20         /**
21          *  <filter>
22                   <filter-name>FilterDemo02</filter-name>
23                   <filter-class>me.gacl.web.filter.FilterDemo02</filter-class>
24                   <!--配置FilterDemo02过滤器的初始化参数-->
25                   <init-param>
26                       <description>配置FilterDemo02过滤器的初始化参数</description>
27                       <param-name>name</param-name>
28                       <param-value>gacl</param-value>
29                   </init-param>
30                   <init-param>
31                       <description>配置FilterDemo02过滤器的初始化参数</description>
32                       <param-name>like</param-name>
33                       <param-value>java</param-value>
34                   </init-param>
35             </filter>
36             
37              <filter-mapping>
38                   <filter-name>FilterDemo02</filter-name>
39                   <!--“/*”表示拦截所有的请求 -->
40                   <url-pattern>/*</url-pattern>
41              </filter-mapping>
42          */
43         //得到过滤器的名字
44         String filterName = filterConfig.getFilterName();
45         //得到在web.xml文件中配置的初始化参数
46         String initParam1 = filterConfig.getInitParameter("name");
47         String initParam2 = filterConfig.getInitParameter("like");
48         //返回过滤器的所有初始化参数的名字的枚举集合。
49         Enumeration<String> initParameterNames = filterConfig.getInitParameterNames();
50         
51         System.out.println(filterName);
52         System.out.println(initParam1);
53         System.out.println(initParam2);
54         while (initParameterNames.hasMoreElements()) {
55             String paramName = (String) initParameterNames.nextElement();
56             System.out.println(paramName);
57         }
58     }
59 
60     @Override
61     public void doFilter(ServletRequest request, ServletResponse response,
62             FilterChain chain) throws IOException, ServletException {
63         System.out.println("FilterDemo02执行前！！！");
64         chain.doFilter(request, response);  //让目标资源执行，放行
65         System.out.println("FilterDemo02执行后！！！");
66     }
67 
68     @Override
69     public void destroy() {
70         System.out.println("----过滤器销毁----");
71     }
72 }

Filter的部署

　　Filter的部署分为两个步骤：

　　1、注册Filter

　　2、映射Filter

注册Filter

　　开发好Filter之后，需要在web.xml文件中进行注册，这样才能够被web服务器调用

　　在web.xml文件中注册Filter范例：

<filter>
           <description>FilterDemo02过滤器</description>
           <filter-name>FilterDemo02</filter-name>
           <filter-class>me.gacl.web.filter.FilterDemo02</filter-class>
           <!--配置FilterDemo02过滤器的初始化参数-->
           <init-param>
               <description>配置FilterDemo02过滤器的初始化参数</description>
               <param-name>name</param-name>
               <param-value>gacl</param-value>
           </init-param>
           <init-param>
               <description>配置FilterDemo02过滤器的初始化参数</description>
               <param-name>like</param-name>
               <param-value>java</param-value>
           </init-param>
 </filter>

　　<description>用于添加描述信息，该元素的内容可为空，<description>可以不配置。

　　<filter-name>用于为过滤器指定一个名字，该元素的内容不能为空。
　　<filter-class>元素用于指定过滤器的完整的限定类名。
　　<init-param>元素用于为过滤器指定初始化参数，它的子元素<param-name>指定参数的名字，<param-value>指定参数的值。在过滤器中，可以使用FilterConfig接口对象来访问初始化参数。如果过滤器不需要指定初始化参数，那么<init-param>元素可以不配置。

映射Filter

　　在web.xml文件中注册了Filter之后，还要在web.xml文件中映射Filter

<!--映射过滤器-->
   <filter-mapping>
       <filter-name>FilterDemo02</filter-name>
       <!--“/*”表示拦截所有的请求 -->
       <url-pattern>/*</url-pattern>
   </filter-mapping>

　　<filter-mapping>元素用于设置一个 Filter 所负责拦截的资源。一个Filter拦截的资源可通过两种方式来指定：Servlet 名称和资源访问的请求路径
　　<filter-name>子元素用于设置filter的注册名称。该值必须是在<filter>元素中声明过的过滤器的名字
　　<url-pattern>设置 filter 所拦截的请求路径(过滤器关联的URL样式)
　　<servlet-name>指定过滤器所拦截的Servlet名称。
　　<dispatcher>指定过滤器所拦截的资源被 Servlet 容器调用的方式，可以是REQUEST,INCLUDE,FORWARD和ERROR之一，默认REQUEST。用户可以设置多个<dispatcher> 子元素用来指定 Filter 对资源的多种调用方式进行拦截。如下：

<filter-mapping>
     <filter-name>testFilter</filter-name>
    <url-pattern>/index.jsp</url-pattern>
    <dispatcher>REQUEST</dispatcher>
   <dispatcher>FORWARD</dispatcher>
 </filter-mapping>

<dispatcher> 子元素可以设置的值及其意义：

REQUEST：当用户直接访问页面时，Web容器将会调用过滤器。如果目标资源是通过RequestDispatcher的include()或forward()方法访问时，那么该过滤器就不会被调用。
INCLUDE：如果目标资源是通过RequestDispatcher的include()方法访问时，那么该过滤器将被调用。除此之外，该过滤器不会被调用。
FORWARD：如果目标资源是通过RequestDispatcher的forward()方法访问时，那么该过滤器将被调用，除此之外，该过滤器不会被调用。
ERROR：如果目标资源是通过声明式异常处理机制调用时，那么该过滤器将被调用。除此之外，过滤器不会被调用。

Decorator设计模式

Decorator设计模式介绍

　　当某个对象的方法不适应业务需求时，通常有2种方式可以对方法进行增强：

编写子类，覆盖需增强的方法。
使用Decorator设计模式对方法进行增强。

　　在阎宏博士的《JAVA与模式》一书中开头是这样描述装饰（Decorator）模式的：装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

　　那么在实际应用中遇到需增强对象的方法时，到底选用哪种方式比较好呢？这个没有具体的定式，只能是根据具体的需求来采用具体的方式，不过有一种情况下，必须使用Decorator设计模式：即被增强的对象，开发人员只能得到它的对象，无法得到它的class文件。比如request、response对象，开发人员之所以在servlet中能通过sun公司定义的HttpServletRequest\response接口去操作这些对象，是因为Tomcat服务器厂商编写了request、response接口的实现类。web服务器在调用servlet时，会用这些接口的实现类创建出对象，然后传递给servlet程序。此种情况下，由于开发人员根本不知道服务器厂商编写的request、response接口的实现类是哪个？在程序中只能拿到服务器厂商提供的对象，因此就只能采用Decorator设计模式对这些对象进行增强。

Decorator设计模式的实现

　　1.首先看需要被增强对象继承了什么接口或父类，编写一个类也去继承这些接口或父类。
　　2.在类中定义一个变量，变量类型即需增强对象的类型。
　　3.在类中定义一个构造函数，接收需增强的对象。
　　4.覆盖需增强的方法，编写增强的代码。

使用Decorator设计模式增强request对象

　　Servlet API 中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper，HttpServletRequestWrapper 类实现了request 接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 request 对象的对应方法，以避免用户在对request对象进行增强时需要实现request接口中的所有方法。

使用Decorator模式包装request对象解决get和post请求方式下的中文乱码问题

　　编写一个用于处理中文乱码的过滤器CharacterEncodingFilter，代码如下：

1 package me.gacl.web.filter;
  2 
  3 import java.io.IOException;
  4 
  5 import javax.servlet.Filter;
  6 import javax.servlet.FilterChain;
  7 import javax.servlet.FilterConfig;
  8 import javax.servlet.ServletException;
  9 import javax.servlet.ServletRequest;
 10 import javax.servlet.ServletResponse;
 11 import javax.servlet.http.HttpServletRequest;
 12 import javax.servlet.http.HttpServletRequestWrapper;
 13 import javax.servlet.http.HttpServletResponse;
 14 
 15 /**
 16 * @ClassName: CharacterEncodingFilter
 17 * @Description: 此过滤器用来解决解决get、post请求方式下的中文乱码问题
 20 *
 21 */ 
 22 public class CharacterEncodingFilter implements Filter {
 23 
 24     private FilterConfig filterConfig = null;
 25     //设置默认的字符编码
 26     private String defaultCharset = "UTF-8";
 27 
 28     public void doFilter(ServletRequest req, ServletResponse resp,
 29             FilterChain chain) throws IOException, ServletException {
 30         
 31         HttpServletRequest request = (HttpServletRequest) req;
 32         HttpServletResponse response = (HttpServletResponse) resp;
 33         //得到在web.xml中配置的字符编码
 34         String charset = filterConfig.getInitParameter("charset");
 35         if(charset==null){
 36             charset = defaultCharset;
 37         }
 38         request.setCharacterEncoding(charset);
 39         response.setCharacterEncoding(charset);
 40         response.setContentType("text/html;charset="+charset);
 41         
 42         MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);
 43         chain.doFilter(requestWrapper, response);
 44     }
 45 
 46     public void init(FilterConfig filterConfig) throws ServletException {
 47         //得到过滤器的初始化配置信息
 48         this.filterConfig = filterConfig;
 49     }
 50     
 51     public void destroy() {
 52 
 53     }
 54 }
 55 
 56 /**
 57 * @ClassName: MyCharacterEncodingRequest
 58 * @Description: Servlet API中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper,
 59 * (HttpServletRequestWrapper类实现了request接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 request对象的对应方法)
 60 * 以避免用户在对request对象进行增强时需要实现request接口中的所有方法。
 61 * 所以当需要增强request对象时，只需要写一个类继承HttpServletRequestWrapper类，然后在重写需要增强的方法即可
 64 *     1.实现与被增强对象相同的接口 
 65     2、定义一个变量记住被增强对象
 66     3、定义一个构造函数，接收被增强对象
 67     4、覆盖需要增强的方法
 68     5、对于不想增强的方法，直接调用被增强对象（目标对象）的方法
 69 */ 
 70 class MyCharacterEncodingRequest extends HttpServletRequestWrapper{
 71     //定义一个变量记住被增强对象(request对象是需要被增强的对象)
 72     private HttpServletRequest request;
 73     //定义一个构造函数，接收被增强对象
 74     public MyCharacterEncodingRequest(HttpServletRequest request) {
 75         super(request);
 76         this.request = request;
 77     }
 78     /* 覆盖需要增强的getParameter方法
 79      * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
 80      */
 81     @Override
 82     public String getParameter(String name) {
 83         try{
 84             //获取参数的值
 85             String value= this.request.getParameter(name);
 86             if(value==null){
 87                 return null;
 88             }
 89             //如果不是以get方式提交数据的，就直接返回获取到的值
 90             if(!this.request.getMethod().equalsIgnoreCase("get")) {
 91                 return value;
 92             }else{
 93                 //如果是以get方式提交数据的，就对获取到的值进行转码处理
 94                 value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
 95                 return value;
 96             }
 97         }catch (Exception e) {
 98             throw new RuntimeException(e);
 99         }
100     }
101 }

　在web.xml文件中配置CharacterEncodingFilter

<!--配置字符过滤器，解决get、post请求方式下的中文乱码问题-->
   <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
       <filter-class>me.gacl.web.filter.CharacterEncodingFilter</filter-class>
    </filter>
    
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
  </filter-mapping>

　编写jsp测试页面，如下：

<%@ page language="java" pageEncoding="UTF-8"%>
 <%--引入jstl标签库 --%>
 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
 <!DOCTYPE HTML>
 <html>
   <head>
     <title>使用字符过滤器解决解决get、post请求方式下的中文乱码问题</title>
   </head>
   
   <body>
        <%--使用c:url标签构建url，构建好的url存储在servletDemo1变量中--%>
        <c:url value="/servlet/ServletDemo1" scope="page" var="servletDemo1">
            <%--构建的url的附带的中文参数 ，参数名是：username，值是：孤傲苍狼--%>
            <c:param name="username" value="孤傲苍狼"></c:param>
        </c:url>
       <%--使用get的方式访问 --%>
        <a href="${servletDemo1}">超链接(get方式请求)</a>
        <hr/>
        <%--使用post方式提交表单 --%>
        <form action="${pageContext.request.contextPath}/servlet/ServletDemo1" method="post">
            用户名：<input type="text" name="username" value="孤傲苍狼" />
            <input type="submit" value="post方式提交">
        </form>
        
   </body>
 </html>

　编写处理用户请求的ServletDemo1

package me.gacl.web.controller;
 
 import java.io.IOException;
 import java.io.PrintWriter;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 public class ServletDemo1 extends HttpServlet {
 
     public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        //接收参数
         String username = request.getParameter("username");
         //获取请求方式
         String method = request.getMethod();
         //获取输出流
        PrintWriter out = response.getWriter();
         out.write("请求的方式："+method);
         out.write("<br/>");
         out.write("接收到的参数："+username);
     }
 
     public void doPost(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
        doGet(request, response);
    }
 
 }

　　测试结果如下：

JavaWeb开发与代码的编写(十八)_java_02

　　从运行结果中可以看到，无论是get请求方式还是post请求方式，中文乱码问题都可以完美解决了。

使用Decorator模式包装request对象实现html标签转义功能

　　编写一个html转义过滤器，代码如下：

1 package me.gacl.web.filter;
  2 
  3 import java.io.IOException;
  4 
  5 import javax.servlet.Filter;
  6 import javax.servlet.FilterChain;
  7 import javax.servlet.FilterConfig;
  8 import javax.servlet.ServletException;
  9 import javax.servlet.ServletRequest;
 10 import javax.servlet.ServletResponse;
 11 import javax.servlet.http.HttpServletRequest;
 12 import javax.servlet.http.HttpServletRequestWrapper;
 13 import javax.servlet.http.HttpServletResponse;
 14 
 15 /**
 16 * @ClassName: HtmlFilter
 17 * @Description: html转义过滤器
 21 */ 
 22 public class HtmlFilter implements Filter {
 23 
 24     public void doFilter(ServletRequest req, ServletResponse resp,
 25             FilterChain chain) throws IOException, ServletException {
 26         
 27         HttpServletRequest request = (HttpServletRequest) req;
 28         HttpServletResponse response = (HttpServletResponse) resp;
 29 
 30         MyHtmlRequest myrequest = new MyHtmlRequest(request);
 31         chain.doFilter(myrequest, response);
 32         
 33     }
 34 
 35     
 36     public void destroy() {
 37         
 38     }
 39 
 40     
 41     public void init(FilterConfig filterConfig) throws ServletException {
 42         
 43     }
 44 }
 45 
 46 /**
 47 * @ClassName: MyHtmlRequest
 48 * @Description: 使用Decorator模式包装request对象，实现html标签转义功能
 52 */ 
 53 class MyHtmlRequest extends HttpServletRequestWrapper {
 54 
 55     private HttpServletRequest request;
 56 
 57     public MyHtmlRequest(HttpServletRequest request) {
 58         super(request);
 59         this.request = request;
 60     }
 61 
 62     /* 覆盖需要增强的getParameter方法
 63      * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
 64      */
 65     @Override
 66     public String getParameter(String name) {
 67         String value = this.request.getParameter(name);
 68         if (value == null) {
 69             return null;
 70         }
 71         //调用filter转义value中的html标签
 72         return filter(value);
 73     }
 74 
 75     /**
 76     * @Method: filter
 77     * @Description: 过滤内容中的html标签
 79     * @param message
 80     * @return
 81     */ 
 82     public String filter(String message) {
 83         if (message == null){
 84             return null;
 85         }
 86         char content[] = new char[message.length()];
 87         message.getChars(0, message.length(), content, 0);
 88         StringBuffer result = new StringBuffer(content.length + 50);
 89         for (int i = 0; i < content.length; i++) {
 90             switch (content[i]) {
 91             case '<':
 92                 result.append("<");
 93                 break;
 94             case '>':
 95                 result.append(">");
 96                 break;
 97             case '&':
 98                 result.append("&");
 99                 break;
100             case '"':
101                 result.append(""");
102                 break;
103             default:
104                 result.append(content[i]);
105             }
106         }
107         return result.toString();
108     }
109 }

　　在web.xml文件中配置HtmlFilter

<!--配置Html过滤器，转义内容中的html标签-->
   <filter>
       <filter-name>HtmlFilter</filter-name>
       <filter-class>me.gacl.web.filter.HtmlFilter</filter-class>
   </filter>
   
   <filter-mapping>
       <filter-name>HtmlFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

　　编写jsp测试页面，如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  <!DOCTYPE HTML>
   <html>
   <head>
      <title>html过滤器测试</title>
    </head>
    
   <body>
         <form action="${pageContext.request.contextPath}/servlet/ServletDemo2" method="post">
            留言:
            <textarea rows="8" cols="70" name="message">
            <script type="text/javascript">
            while(true){
                alert("死循环了，我会不停地弹出了");
            }
            </script>
         <a href=">访问博客园</a>
            </textarea>
            <input type="submit" value="发表">
        </form>
  </body>
 </html>

　　编写处理用户请求的ServletDemo2

package me.gacl.web.controller;
 
 import java.io.IOException;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
public class ServletDemo2 extends HttpServlet {
 
     public void doGet(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         //获取用户输入的内容
         String message = request.getParameter("message");
         response.getWriter().write("您上次的留言是：<br/>" + message);
     }
 
     public void doPost(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         doGet(request, response);
     }
 }

测试结果如下：

JavaWeb开发与代码的编写(十八)_System_03

　　从运行结果中可以看到，所有的html标签都被转义输出了。

使用Decorator模式包装request对象实现敏感字符过滤功能

　　编写一个敏感字符过滤器，代码如下：

1 package me.gacl.web.filter;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.IOException;
  5 import java.io.InputStream;
  6 import java.io.InputStreamReader;
  7 import java.io.UnsupportedEncodingException;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 import javax.servlet.Filter;
 11 import javax.servlet.FilterChain;
 12 import javax.servlet.FilterConfig;
 13 import javax.servlet.ServletException;
 14 import javax.servlet.ServletRequest;
 15 import javax.servlet.ServletResponse;
 16 import javax.servlet.http.HttpServletRequest;
 17 import javax.servlet.http.HttpServletRequestWrapper;
 18 import javax.servlet.http.HttpServletResponse;
 19 
 20 /**
 21 * @ClassName: DirtyFilter
 22 * @Description: 敏感词过滤器
 25 *
 26 */ 
 27 public class DirtyFilter implements Filter {
 28 
 29     private FilterConfig config = null;
 30     
 31     @Override
 32     public void init(FilterConfig filterConfig) throws ServletException {
 33         this.config = filterConfig;
 34     }
 35 
 36     @Override
 37     public void doFilter(ServletRequest req, ServletResponse resp,
 38             FilterChain chain) throws IOException, ServletException {
 39         
 40         HttpServletRequest request = (HttpServletRequest) req;
 41         HttpServletResponse response = (HttpServletResponse) resp;
 42         DirtyRequest dirtyrequest = new DirtyRequest(request);
 43         
 44         chain.doFilter(dirtyrequest, response);
 45     }
 46 
 47     @Override
 48     public void destroy() {
 49 
 50     }
 51     
 52     /**
 53     * @Method: getDirtyWords
 54     * @Description: 获取敏感字符
 56     *
 57     * @return
 58     */ 
 59     private List<String> getDirtyWords(){
 60         List<String> dirtyWords = new ArrayList<String>();
 61         String dirtyWordPath = config.getInitParameter("dirtyWord");
 62         InputStream inputStream = config.getServletContext().getResourceAsStream(dirtyWordPath);
 63         InputStreamReader is = null;
 64         try {
 65             is = new InputStreamReader(inputStream,"UTF-8");
 66         } catch (UnsupportedEncodingException e2) {
 67             e2.printStackTrace();
 68         }
 69         BufferedReader reader = new BufferedReader(is);
 70         String line;
 71         try {
 72             while ((line = reader.readLine())!= null) {//如果 line为空说明读完了
 73                 dirtyWords.add(line);
 74             }
 75         } catch (IOException e) {
 76             e.printStackTrace();
 77         } 
 78         return dirtyWords;
 79     }
 80     
 81     /**
 82     * @ClassName: DirtyRequest
 83     * @Description: 使用Decorator模式包装request对象，实现敏感字符过滤功能
 86     *
 87     */ 
 88     class DirtyRequest extends HttpServletRequestWrapper{
 89 
 90         private List<String> dirtyWords = getDirtyWords();
 91         private HttpServletRequest request;
 92         public DirtyRequest(HttpServletRequest request) {
 93             super(request);
 94             this.request = request;
 95         }
 96         /* 重写getParameter方法，实现对敏感字符的过滤
 97          * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
 98          */
 99         @Override
100         public String getParameter(String name) {
101             
102             String value = this.request.getParameter(name);
103             if(value==null){
104                 return null;
105             }
106             
107             for(String dirtyWord : dirtyWords){
108                 if(value.contains(dirtyWord)){
109                     System.out.println("内容中包含敏感词："+dirtyWord+"，将会被替换成****");
110                     //替换敏感字符
111                     value = value.replace(dirtyWord, "****");
112                 }
113             }
114             return value;
115         }
116     }
117 }

　　在web.xml文件中配置DirtyFilter

<!--配置敏感字符过滤器-->
  <filter>
       <filter-name>DirtyFilter</filter-name>
       <filter-class>me.gacl.web.filter.DirtyFilter</filter-class>
       <!-- 配置要过滤的敏感字符文件 -->
       <init-param>
          <param-name>dirtyWord</param-name>    
          <param-value>/WEB-INF/DirtyWord.txt</param-value>
     </init-param>
   </filter>
   
   <filter-mapping>
       <filter-name>DirtyFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

　　当用户填写的内容包含一些敏感字符时，在DirtyFilter过滤器中就会将这些敏感字符替换掉。

　　我们如果将上述的CharacterEncodingFilter、HtmlFilter、DirtyFilter这三个过滤器联合起来使用，那么就相当于是把request对象包装了3次，request对象的getParameter方法经过3次重写，使得getParameter方法的功能大大增强，可以同时解决中文乱码，html标签转义，敏感字符过滤这些需求。

　　在实际开发中完全可以将上述的三个过滤器合并成一个，让合并后的过滤器具有解决中文乱码，html标签转义，敏感字符过滤这些功能，例如：

1 package me.gacl.web.filter;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.IOException;
  5 import java.io.InputStream;
  6 import java.io.InputStreamReader;
  7 import java.io.UnsupportedEncodingException;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 
 11 import javax.servlet.Filter;
 12 import javax.servlet.FilterChain;
 13 import javax.servlet.FilterConfig;
 14 import javax.servlet.ServletException;
 15 import javax.servlet.ServletRequest;
 16 import javax.servlet.ServletResponse;
 17 import javax.servlet.http.HttpServletRequest;
 18 import javax.servlet.http.HttpServletRequestWrapper;
 19 import javax.servlet.http.HttpServletResponse;
 20 
 21 /**
 22 * @ClassName: AdvancedFilter
 23 * @Description: 这个过滤器是用来解决中文乱码，转义内容中的html标签，过滤内容中的敏感字符的
 26 *
 27 */ 
 28 public class AdvancedFilter implements Filter {
 29 
 30     private FilterConfig filterConfig = null;
 31     //设置默认的字符编码
 32     private String defaultCharset = "UTF-8";
 33     
 34     @Override
 35     public void init(FilterConfig filterConfig) throws ServletException {
 36         //得到过滤器的初始化配置信息
 37         this.filterConfig = filterConfig;
 38     }
 39 
 40     @Override
 41     public void doFilter(ServletRequest req, ServletResponse resp,
 42             FilterChain chain) throws IOException, ServletException {
 43         HttpServletRequest request = (HttpServletRequest) req;
 44         HttpServletResponse response = (HttpServletResponse) resp;
 45         //得到在web.xml中配置的字符编码
 46         String charset = filterConfig.getInitParameter("charset");
 47         if(charset==null){
 48             charset = defaultCharset;
 49         }
 50         request.setCharacterEncoding(charset);
 51         response.setCharacterEncoding(charset);
 52         response.setContentType("text/html;charset="+charset);
 53         
 54         AdvancedRequest requestWrapper = new AdvancedRequest(request);
 55         chain.doFilter(requestWrapper, response);
 56     }
 57 
 58     @Override
 59     public void destroy() {
 60 
 61     }
 62 
 63     class AdvancedRequest extends HttpServletRequestWrapper{
 64         
 65         private List<String> dirtyWords = getDirtyWords();
 66         
 67         //定义一个变量记住被增强对象(request对象是需要被增强的对象)
 68         private HttpServletRequest request;
 69         //定义一个构造函数，接收被增强对象
 70         public AdvancedRequest(HttpServletRequest request) {
 71             super(request);
 72             this.request = request;
 73         }
 74         /* 覆盖需要增强的getParameter方法
 75          * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
 76          */
 77         @Override
 78         public String getParameter(String name) {
 79             try{
 80                 //获取参数的值
 81                 String value= this.request.getParameter(name);
 82                 if(value==null){
 83                     return null;
 84                 }
 85                 //如果不是以get方式提交数据的，就直接返回获取到的值
 86                 if(!this.request.getMethod().equalsIgnoreCase("get")) {
 87                     //调用filter转义value中的html标签
 88                     value= filter(value);
 89                 }else{
 90                     //如果是以get方式提交数据的，就对获取到的值进行转码处理
 91                     value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
 92                     //调用filter转义value中的html标签
 93                     value= filter(value);
 94                 }
 95                 
 96                 for(String dirtyWord : dirtyWords){
 97                     if(value.contains(dirtyWord)){
 98                         System.out.println("内容中包含敏感词："+dirtyWord+"，将会被替换成****");
 99                         //替换敏感字符
100                         value = value.replace(dirtyWord, "****");
101                     }
102                 }
103                 return value;
104             }catch (Exception e) {
105                 throw new RuntimeException(e);
106             }
107         }
108     }
109 
110     /**
111     * @Method: filter
112     * @Description: 过滤内容中的html标签
114     * @param value
115     * @return
116     */ 
117     public String filter(String value) {
118         if (value == null){
119             return null;
120         }
121         char content[] = new char[value.length()];
122         value.getChars(0, value.length(), content, 0);
123         StringBuffer result = new StringBuffer(content.length + 50);
124         for (int i = 0; i < content.length; i++) {
125             switch (content[i]) {
126             case '<':
127                 result.append("<");
128                 break;
129             case '>':
130                 result.append(">");
131                 break;
132             case '&':
133                 result.append("&");
134                 break;
135             case '"':
136                 result.append(""");
137                 break;
138             default:
139                 result.append(content[i]);
140             }
141         }
142         return (result.toString());
143     }
144     
145     /**
146     * @Method: getDirtyWords
147     * @Description: 获取敏感字符
149     *
150     * @return
151     */ 
152     private List<String> getDirtyWords(){
153         List<String> dirtyWords = new ArrayList<String>();
154         String dirtyWordPath = filterConfig.getInitParameter("dirtyWord");
155         InputStream inputStream = filterConfig.getServletContext().getResourceAsStream(dirtyWordPath);
156         InputStreamReader is = null;
157         try {
158             is = new InputStreamReader(inputStream,defaultCharset);
159         } catch (UnsupportedEncodingException e2) {
160             e2.printStackTrace();
161         }
162         BufferedReader reader = new BufferedReader(is);
163         String line;
164         try {
165             while ((line = reader.readLine())!= null) {//如果 line为空说明读完了
166                 dirtyWords.add(line);
167             }
168         } catch (IOException e) {
169             e.printStackTrace();
170         } 
171         return dirtyWords;
172     }
173 }

　在web.xml文件中配置AdvancedFilter

<filter>
       <filter-name>AdvancedFilter</filter-name>
       <filter-class>me.gacl.web.filter.AdvancedFilter</filter-class>
       <init-param>
          <param-name>charset</param-name>    
          <param-value>UTF-8</param-value>
     </init-param>
       <init-param>
           <param-name>dirtyWord</param-name>    
          <param-value>/WEB-INF/DirtyWord.txt</param-value>
     </init-param>
  </filter>
  
  <filter-mapping>
      <filter-name>AdvancedFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

　AdvancedFilter过滤器同时具有解决中文乱码，转义内容中的html标签，过滤内容中的敏感字符这些功能。

使用Decorator设计模式增强response对象

　　Servlet API 中提供了response对象的Decorator设计模式的默认实现类HttpServletResponseWrapper ，HttpServletResponseWrapper类实现了response接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 response对象的对应方法，以避免用户在对response对象进行增强时需要实现response接口中的所有方法。

response增强案例——压缩响应正文内容

　　应用HttpServletResponseWrapper对象，压缩响应正文内容。

　　具体思路:通过filter向目标页面传递一个自定义的response对象。在自定义的response对象中，重写getOutputStream方法和getWriter方法，使目标资源调用此方法输出页面内容时，获得的是我们自定义的ServletOutputStream对象。在我们自定义的ServletOuputStream对象中，重写write方法，使写出的数据写出到一个buffer中。当页面完成输出后，在filter中就可得到页面写出的数据，从而我们可以调用GzipOuputStream对数据进行压缩后再写出给浏览器，以此完成响应正文件压缩功能。

　　编写压缩过滤器，代码如下：

1 package me.gacl.web.filter;
  2 
  3 import java.io.ByteArrayOutputStream;
  4 import java.io.IOException;
  5 import java.io.OutputStreamWriter;
  6 import java.io.PrintWriter;
  7 import java.util.zip.GZIPOutputStream;
  8 
  9 import javax.servlet.Filter;
 10 import javax.servlet.FilterChain;
 11 import javax.servlet.FilterConfig;
 12 import javax.servlet.ServletException;
 13 import javax.servlet.ServletOutputStream;
 14 import javax.servlet.ServletRequest;
 15 import javax.servlet.ServletResponse;
 16 import javax.servlet.http.HttpServletRequest;
 17 import javax.servlet.http.HttpServletResponse;
 18 import javax.servlet.http.HttpServletResponseWrapper;
 19 
 20 /**
 21 * @ClassName: GzipFilter
 22 * @Description: 压缩过滤器，将web应用中的文本都经过压缩后再输出到浏览器
 25 *
 26 */ 
 27 public class GzipFilter implements Filter {
 28 
 29     public void doFilter(ServletRequest req, ServletResponse resp,
 30             FilterChain chain) throws IOException, ServletException {
 31         
 32         HttpServletRequest request = (HttpServletRequest) req;
 33         HttpServletResponse response = (HttpServletResponse) resp;
 34         
 35         BufferResponse myresponse = new BufferResponse(response);
 36         chain.doFilter(request, myresponse);
 37         //拿出缓存中的数据，压缩后再打给浏览器
 38         byte out[] = myresponse.getBuffer();
 39         System.out.println("原始大小:" + out.length);
 40         
 41         ByteArrayOutputStream bout = new ByteArrayOutputStream();
 42         //压缩输出流中的数据
 43         GZIPOutputStream gout = new GZIPOutputStream(bout);
 44         gout.write(out);
 45         gout.close();
 46         
 47         byte gzip[] = bout.toByteArray();
 48         System.out.println("压缩后的大小:" + gzip.length);
 49         
 50         response.setHeader("content-encoding", "gzip");
 51         response.setContentLength(gzip.length);
 52         response.getOutputStream().write(gzip);
 53     }
 54     
 55     public void destroy() {
 56         
 57     }
 58 
 59     public void init(FilterConfig filterConfig) throws ServletException {
 60         
 61     }
 62 }
 63 
 64 class BufferResponse extends HttpServletResponseWrapper{
 65 
 66     private ByteArrayOutputStream bout = new ByteArrayOutputStream();
 67     private PrintWriter pw;
 68     private HttpServletResponse response;
 69     public BufferResponse(HttpServletResponse response) {
 70         super(response);
 71         this.response = response;
 72     }
 73     @Override
 74     public ServletOutputStream getOutputStream() throws IOException {
 75         return new MyServletOutputStream(bout);
 76     }
 77     @Override
 78     public PrintWriter getWriter() throws IOException {
 79         pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
 80         return pw;
 81     }
 82     
 83     public byte[] getBuffer(){
 84         try{
 85             if(pw!=null){
 86                 pw.close();
 87             }
 88             if(bout!=null){
 89                 bout.flush();
 90                 return bout.toByteArray();
 91             }
 92             
 93             
 94             return null;
 95         }catch (Exception e) {
 96             throw new RuntimeException(e);
 97         }
 98     }
 99 }
100 
101 class MyServletOutputStream extends ServletOutputStream{
102 
103     private ByteArrayOutputStream bout;
104     public MyServletOutputStream(ByteArrayOutputStream bout){
105         this.bout = bout;
106     }
107     
108     @Override
109     public void write(int b) throws IOException {
110         this.bout.write(b);
111     }
112 }

　　在web.xml中配置压缩过滤器

<filter>
       <description>配置压缩过滤器</description>
       <filter-name>GzipFilter</filter-name>
       <filter-class>me.gacl.web.filter.GzipFilter</filter-class>
   </filter>
   
   <!--jsp文件的输出的内容都经过压缩过滤器压缩后才输出 -->
   <filter-mapping>
       <filter-name>GzipFilter</filter-name>
       <url-pattern>*.jsp</url-pattern>
       <!-- 配置过滤器的拦截方式-->
       <!-- 对于在Servlet中通过
           request.getRequestDispatcher("jsp页面路径").forward(request, response) 
       方式访问的Jsp页面的要进行拦截 -->
       <dispatcher>FORWARD</dispatcher>
       <!--对于直接以URL方式访问的jsp页面进行拦截，过滤器的拦截方式默认就是 REQUEST-->
      <dispatcher>REQUEST</dispatcher>
   </filter-mapping>
   <!--js文件的输出的内容都经过压缩过滤器压缩后才输出 -->
   <filter-mapping>
       <filter-name>GzipFilter</filter-name>
       <url-pattern>*.js</url-pattern>
   </filter-mapping>
   <!--css文件的输出的内容都经过压缩过滤器压缩后才输出 -->
   <filter-mapping>
       <filter-name>GzipFilter</filter-name>
       <url-pattern>*.css</url-pattern>
   </filter-mapping>
   <!--html文件的输出的内容都经过压缩过滤器压缩后才输出 -->
   <filter-mapping>
       <filter-name>GzipFilter</filter-name>
       <url-pattern>*.html</url-pattern>
   </filter-mapping>

response增强案例——缓存数据到内存

　　对于页面中很少更新的数据，例如商品分类，为避免每次都要从数据库查询分类数据，因此可把分类数据缓存在内存或文件中，以此来减轻数据库压力，提高系统响应速度。

　　编写缓存数据的过滤器，代码如下：

1 package me.gacl.web.filter;
  2 
  3 import java.io.ByteArrayOutputStream;
  4 import java.io.IOException;
  5 import java.io.OutputStreamWriter;
  6 import java.io.PrintWriter;
  7 import java.util.HashMap;
  8 import java.util.Map;
  9 
 10 import javax.servlet.Filter;
 11 import javax.servlet.FilterChain;
 12 import javax.servlet.FilterConfig;
 13 import javax.servlet.ServletException;
 14 import javax.servlet.ServletOutputStream;
 15 import javax.servlet.ServletRequest;
 16 import javax.servlet.ServletResponse;
 17 import javax.servlet.http.HttpServletRequest;
 18 import javax.servlet.http.HttpServletResponse;
 19 import javax.servlet.http.HttpServletResponseWrapper;
 20 
 21 /**
 22 * @ClassName: WebResourceCachedFilter
 23 * @Description: Web资源缓存过滤器
 26 *
 27 */ 
 28 public class WebResourceCachedFilter implements Filter {
 29     /**
 30     * @Field: map
 31     *          缓存Web资源的Map容器
 32     */ 
 33     private Map<String,byte[]> map = new HashMap<String,byte[]>();
 34     
 35     @Override
 36     public void init(FilterConfig filterConfig) throws ServletException {
 37 
 38     }
 39 
 40     @Override
 41     public void doFilter(ServletRequest req, ServletResponse resp,
 42             FilterChain chain) throws IOException, ServletException {
 43         HttpServletRequest request = (HttpServletRequest) req;
 44         HttpServletResponse response = (HttpServletResponse) resp;
 45         //1.得到用户请求的uri
 46         String uri = request.getRequestURI();
 47         //2.看缓存中有没有uri对应的数据
 48         byte b[] = map.get(uri);
 49         //3.如果缓存中有，直接拿缓存的数据打给浏览器，程序返回
 50         if(b!=null){
 51             //根据字节数组和指定的字符编码构建字符串
 52             String webResourceHtmlStr = new String(b,response.getCharacterEncoding());
 53             System.out.println(webResourceHtmlStr);
 54             response.getOutputStream().write(b);
 55             return;
 56         }
 57         //4.如果缓存没有，让目标资源执行，并捕获目标资源的输出
 58         BufferResponse myresponse = new BufferResponse(response);
 59         chain.doFilter(request, myresponse);
 60         //获取缓冲流中的内容的字节数组
 61         byte out[] = myresponse.getBuffer();
 62         //5.把资源的数据以用户请求的uri为关键字保存到缓存中
 63         map.put(uri, out);
 64         //6.把数据打给浏览器
 65         response.getOutputStream().write(out);
 66     }
 67 
 68     @Override
 69     public void destroy() {
 70 
 71     }
 72 
 73     class BufferResponse extends HttpServletResponseWrapper{
 74         private ByteArrayOutputStream bout = new ByteArrayOutputStream();  //捕获输出的缓存
 75         private PrintWriter pw;
 76         private HttpServletResponse response;
 77         public BufferResponse(HttpServletResponse response) {
 78             super(response);
 79             this.response = response;
 80         }
 81         @Override
 82         public ServletOutputStream getOutputStream() throws IOException {
 83             return new MyServletOutputStream(bout);
 84         }
 85         @Override
 86         public PrintWriter getWriter() throws IOException {
 87             pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
 88             return pw;
 89         }
 90         
 91         public byte[] getBuffer(){
 92             try{
 93                 if(pw!=null){
 94                     pw.close();
 95                 }
 96                 return bout.toByteArray();
 97             }catch (Exception e) {
 98                 throw new RuntimeException(e);
 99             }
100         }
101     }
102 
103     class MyServletOutputStream extends ServletOutputStream{
104         private ByteArrayOutputStream bout;
105         public MyServletOutputStream(ByteArrayOutputStream bout){  //接收数据写到哪里
106             this.bout = bout;
107         }
108         @Override
109         public void write(int b) throws IOException {
110             bout.write(b);
111         }
112     }
113 }

　　在web.xml中配置Web资源缓存过滤器

<filter>
        <description>Web资源缓存过滤器</description>
     <filter-name>WebResourceCachedFilter</filter-name>
       <filter-class>me.gacl.web.filter.WebResourceCachedFilter</filter-class>
   </filter>
   
   <filter-mapping>
       <filter-name>WebResourceCachedFilter</filter-name>
       <!-- 映射需要缓存输出的JSP页面，这几个页面都只是单纯作为输入UI，不会有太多的变化，因此可以缓存输出 -->
       <url-pattern>/login.jsp</url-pattern>
       <url-pattern>/test.jsp</url-pattern>
      <url-pattern>/test2.jsp</url-pattern>
   </filter-mapping>

Filter(过滤器)常见应用

统一全站字符编码

　　通过配置参数charset指明使用何种字符编码,以处理Html Form请求参数的中文问题

1 package me.gacl.web.filter;
 2 
 3 import java.io.IOException;
 4 import javax.servlet.Filter;
 5 import javax.servlet.FilterChain;
 6 import javax.servlet.FilterConfig;
 7 import javax.servlet.ServletException;
 8 import javax.servlet.ServletRequest;
 9 import javax.servlet.ServletResponse;
10 import javax.servlet.http.HttpServletRequest;
11 import javax.servlet.http.HttpServletRequestWrapper;
12 import javax.servlet.http.HttpServletResponse;
13 
14 /**
15 * @ClassName: CharacterEncodingFilter
16 * @Description: 此过滤器用来解决全站中文乱码问题
19 *
20 */ 
21 public class CharacterEncodingFilter implements Filter {
22 
23     private FilterConfig filterConfig = null;
24     //设置默认的字符编码
25     private String defaultCharset = "UTF-8";
26 
27     public void doFilter(ServletRequest req, ServletResponse resp,
28             FilterChain chain) throws IOException, ServletException {
29         
30         HttpServletRequest request = (HttpServletRequest) req;
31         HttpServletResponse response = (HttpServletResponse) resp;
32         String charset = filterConfig.getInitParameter("charset");
33         if(charset==null){
34             charset = defaultCharset;
35         }
36         request.setCharacterEncoding(charset);
37         response.setCharacterEncoding(charset);
38         response.setContentType("text/html;charset="+charset);
39         
40         MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);
41         chain.doFilter(requestWrapper, response);
42     }
43 
44     public void init(FilterConfig filterConfig) throws ServletException {
45         //得到过滤器的初始化配置信息
46         this.filterConfig = filterConfig;
47     }
48     
49     public void destroy() {
50 
51     }
52 }
53 
54 /*
55 1.实现与被增强对象相同的接口 
56 2、定义一个变量记住被增强对象
57 3、定义一个构造器，接收被增强对象
58 4、覆盖需要增强的方法
59 5、对于不想增强的方法，直接调用被增强对象（目标对象）的方法
60  */
61  
62 class MyCharacterEncodingRequest extends HttpServletRequestWrapper{
63     
64     private HttpServletRequest request;
65     public MyCharacterEncodingRequest(HttpServletRequest request) {
66         super(request);
67         this.request = request;
68     }
69     /* 重写getParameter方法
70      * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
71      */
72     @Override
73     public String getParameter(String name) {
74         
75         try{
76             //获取参数的值
77             String value= this.request.getParameter(name);
78             if(value==null){
79                 return null;
80             }
81             //如果不是以get方式提交数据的，就直接返回获取到的值
82             if(!this.request.getMethod().equalsIgnoreCase("get")) {
83                 return value;
84             }else{
85                 //如果是以get方式提交数据的，就对获取到的值进行转码处理
86                 value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
87                 return value;
88             }
89         }catch (Exception e) {
90             throw new RuntimeException(e);
91         }
92     }
93 }

　　web.xml文件中的配置如下：

<filter>
       <filter-name>CharacterEncodingFilter</filter-name>
       <filter-class>me.gacl.web.filter.CharacterEncodingFilter</filter-class>
       <init-param>
           <param-name>charset</param-name>
           <param-value>UTF-8</param-value>
       </init-param>
   </filter>
   
   <filter-mapping>
       <filter-name>CharacterEncodingFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

禁止浏览器缓存所有动态页面

　　有3 个HTTP 响应头字段都可以禁止浏览器缓存当前页面，它们在 Servlet 中的示例代码如下：

response.setDateHeader("Expires",-1);
response.setHeader("Cache-Control","no-cache");
response.setHeader("Pragma","no-cache");

　并不是所有的浏览器都能完全支持上面的三个响应头，因此最好是同时使用上面的三个响应头。

Expires数据头：值为GMT时间值，为-1指浏览器不要缓存页面
Cache-Control响应头有两个常用值：
no-cache指浏览器不要缓存当前页面。
max-age:xxx指浏览器缓存页面xxx秒。

package me.gacl.web.filter;
 
 import java.io.IOException;
 
 import javax.servlet.Filter;
 import javax.servlet.FilterChain;
 import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 /**
 * @ClassName: NoCacheFilter
 * @Description: 禁止浏览器缓存所有动态页面
*
 */ 
 public class NoCacheFilter implements Filter {
 
 
     public void doFilter(ServletRequest req, ServletResponse resp,
             FilterChain chain) throws IOException, ServletException {
         //把ServletRequest强转成HttpServletRequest
         HttpServletRequest request = (HttpServletRequest) req;
         //把ServletResponse强转成HttpServletResponse
         HttpServletResponse response = (HttpServletResponse) resp;
         //禁止浏览器缓存所有动态页面
         response.setDateHeader("Expires", -1);
         response.setHeader("Cache-Control", "no-cache");
         response.setHeader("Pragma", "no-cache");
         
         chain.doFilter(request, response);
     }
 
     public void init(FilterConfig filterConfig) throws ServletException {
 
     }
     
     public void destroy() {
         
    }
 }

　web.xml文件中的配置如下：

<filter>
       <filter-name>NoCacheFilter</filter-name>
       <filter-class>me.gacl.web.filter.NoCacheFilter</filter-class>
   </filter>
  
   <filter-mapping>
       <filter-name>NoCacheFilter</filter-name>
         <!--只拦截Jsp请求-->
       <servlet-name>*.jsp</servlet-name>
   </filter-mapping>

控制浏览器缓存页面中的静态资源

　　有些动态页面中引用了一些图片或css文件以修饰页面效果，这些图片和css文件经常是不变化的，所以为减轻服务器的压力，可以使用filter控制浏览器缓存这些文件，以提升服务器的性能。

package me.gacl.web.filter;
 
 import java.io.IOException;
 
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
 /**
 * @ClassName: CacheFilter
 * @Description: 控制缓存的filter
 *
 */ 
 public class CacheFilter implements Filter {
 
     private FilterConfig filterConfig;
 
     public void doFilter(ServletRequest req, ServletResponse resp,
             FilterChain chain) throws IOException, ServletException {
     
         HttpServletRequest request = (HttpServletRequest) req;
         HttpServletResponse response = (HttpServletResponse) resp;
         
        //1.获取用户想访问的资源
         String uri = request.getRequestURI(); 
         
        //2.得到用户想访问的资源的后缀名
         String ext = uri.substring(uri.lastIndexOf(".")+1);
         
         //得到资源需要缓存的时间
         String time = filterConfig.getInitParameter(ext);
         if(time!=null){
             long t = Long.parseLong(time)*3600*1000;
             //设置缓存
             response.setDateHeader("expires", System.currentTimeMillis() + t);
         }
         
         chain.doFilter(request, response);
 
     }
 
    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
    }
    
     public void destroy() {
         
    }
}

　　web.xml文件中的配置如下：

<!-- 配置缓存过滤器 -->
    <filter>
       <filter-name>CacheFilter</filter-name>
       <filter-class>me.gacl.web.filter.CacheFilter</filter-class>
        <!-- 配置要缓存的web资源以及缓存时间，以小时为单位 -->
       <init-param>
           <param-name>css</param-name>
           <param-value>4</param-value>
       </init-param>
       <init-param>
           <param-name>jpg</param-name>
           <param-value>1</param-value>
       </init-param>
       <init-param>
           <param-name>js</param-name>
           <param-value>4</param-value>
       </init-param>
       <init-param>
           <param-name>png</param-name>
           <param-value>4</param-value>
      </init-param>
   </filter>
   <!-- 配置要缓存的web资源的后缀-->
   <filter-mapping>
       <filter-name>CacheFilter</filter-name>
       <url-pattern>*.jpg</url-pattern>
   </filter-mapping>
   
   <filter-mapping>
       <filter-name>CacheFilter</filter-name>
       <url-pattern>*.css</url-pattern>
   </filter-mapping>
   
   <filter-mapping>
       <filter-name>CacheFilter</filter-name>
       <url-pattern>*.js</url-pattern>
  </filter-mapping>
    <filter-mapping>
       <filter-name>CacheFilter</filter-name>
       <url-pattern>*.png</url-pattern>
   </filter-mapping>

实现用户自动登陆

　　思路是这样的：

　　1、在用户登陆成功后，发送一个名称为user的cookie给客户端，cookie的值为用户名和md5加密后的密码。
　　2、编写一个AutoLoginFilter，这个filter检查用户是否带有名称为user的cookie来，如果有，则调用dao查询cookie的用户名和密码是否和数据库匹配，匹配则向session中存入user对象（即用户登陆标记），以实现程序完成自动登陆。

　　核心代码如下：

　　处理用户登录的控制器：LoginServlet

package me.gacl.web.controller;
 
 import java.io.IOException;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.Cookie;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import me.gacl.dao.UserDao;
 import me.gacl.domain.User;
 import me.gacl.util.WebUtils;
 
 public class LoginServlet extends HttpServlet {
 
     public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
         String username = request.getParameter("username");
         String password = request.getParameter("password");
         
         UserDao dao = new UserDao();
         User user = dao.find(username, password);
         if(user==null){
             request.setAttribute("message", "用户名或密码不对！！");
             request.getRequestDispatcher("/message.jsp").forward(request, response);
             return;
         }
         request.getSession().setAttribute("user", user);
         //发送自动登陆cookie给客户端浏览器进行存储
         sendAutoLoginCookie(request,response,user);
         request.getRequestDispatcher("/index.jsp").forward(request, response);
     }
 
     /**
     * @Method: sendAutoLoginCookie
    * @Description: 发送自动登录cookie给客户端浏览器
     *
     * @param request
     * @param response
     * @param user
     */ 
    private void sendAutoLoginCookie(HttpServletRequest request, HttpServletResponse response, User user) {
         if (request.getParameter("logintime")!=null) {
            int logintime = Integer.parseInt(request.getParameter("logintime"));
             //创建cookie,cookie的名字是autologin，值是用户登录的用户名和密码，用户名和密码之间使用.进行分割，密码经过md5加密处理
            Cookie cookie = new Cookie("autologin",user.getUsername() + "." + WebUtils.md5(user.getPassword()));
             //设置cookie的有效期
             cookie.setMaxAge(logintime);
             //设置cookie的有效路径
             cookie.setPath(request.getContextPath());
             //将cookie写入到客户端浏览器
             response.addCookie(cookie);
         }
     }
     
     public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
         doGet(request, response);
     }
 
 }

　　处理用户自动登录的过滤器：AutoLoginFilter

package me.gacl.web.filter;
 
 import java.io.IOException;
 
 import javax.servlet.Filter;
 import javax.servlet.FilterChain;
 import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.http.Cookie;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import me.gacl.dao.UserDao;
 import me.gacl.domain.User;
 import me.gacl.util.WebUtils;
 
public class AutoLoginFilter implements Filter {
 
     public void doFilter(ServletRequest req, ServletResponse resp,
             FilterChain chain) throws IOException, ServletException {
         
         HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
         //如果已经登录了，就直接chain.doFilter(request, response)放行
         if(request.getSession().getAttribute("user")!=null){
             chain.doFilter(request, response);
             return;
        }
         
         //1.得到用户带过来的authlogin的cookie
         String value = null;
         Cookie cookies[] = request.getCookies();
         for(int i=0;cookies!=null && i<cookies.length;i++){
             if(cookies[i].getName().equals("autologin")){
                 value = cookies[i].getValue();
             }
         }
         
         //2.得到 cookie中的用户名和密码 
         if(value!=null){
             String username = value.split("\\.")[0];
             String password = value.split("\\.")[1];
             
             //3.调用dao获取用户对应的密码
             UserDao dao = new UserDao();
             User user = dao.find(username);
             String dbpassword = user.getPassword();
             
             //4.检查用户带过来的md5的密码和数据库中的密码是否匹配,如匹配则自动登陆
             if(password.equals(WebUtils.md5(dbpassword))){
                 request.getSession().setAttribute("user", user);
             }
         }
         
         chain.doFilter(request, response);
     }
     
     public void destroy() {
         
     }
 
     public void init(FilterConfig filterConfig) throws ServletException {
 
     }
 }

　　如果想取消自动登录，那么可以在用户注销时删除自动登录cookie，核心代码如下：

package me.gacl.web.controller;
 
 import java.io.IOException;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.Cookie;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 public class CancelAutoLoginServlet extends HttpServlet {
 
     public void doGet(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         //移除存储在session中的user
         request.getSession().removeAttribute("user");
         //移除自动登录的cookie
         removeAutoLoginCookie(request,response);
         //注销用户后跳转到登录页面
         request.getRequestDispatcher("/login.jsp").forward(request, response);
     }
 
     /**
     * @Method: removeAutoLoginCookie
     * @Description: 删除自动登录cookie，
     *     JavaWeb中删除cookie的方式就是新创建一个cookie，新创建的cookie与要删除的cookie同名，
     *     设置新创建的cookie的cookie的有效期设置为0，有效路径与要删除的cookie的有效路径相同
     * @param request
     * @param response
     */ 
     private void removeAutoLoginCookie(HttpServletRequest request, HttpServletResponse response) {
         //创建一个名字为autologin的cookie
         Cookie cookie = new Cookie("autologin","");
          //将cookie的有效期设置为0，命令浏览器删除该cookie
         cookie.setMaxAge(0);
         //设置要删除的cookie的path
         cookie.setPath(request.getContextPath());
         response.addCookie(cookie);
     }
     
     public void doPost(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         doGet(request, response);
     }
 }

　　以上就是过滤器的几个常见应用场景。

阿里云国内75折回扣微信号：monov8

阿里云国际，腾讯云国际，低至75折。AWS 93折免费开户实名账号代冲值优惠多多微信号：monov8 飞机：@monov6

标签: Java