11、JavaEEFilter

Filter

Filter也称之为过滤器，它是Servlet技术中最激动人心的技术，WEB开发人员通过Filter技术，对web服务器管理的所有web资源：例如Jsp, Servlet, 静态图片文件

或静态 html 文件等进行拦截，从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。

Servlet API中提供了一个Filter接口，开发web应用时，如果编写的Java类实现了这个接口，则把这个java类称之为过滤器Filter。通过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开发分为二个步骤：

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

注意：使用Filter需要导入servlet-api.jar包。

范例：Filter的简单使用

/**
* @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的创建和销毁由WEB服务器负责。 web 应用程序启动时，web 服务器将创建Filter 的实例对象，并调用其init方法，完成对象的初始化功能，从而为后续的用户

请求作好拦截的准备工作，filter对象只会创建一次，init方法也只会执行一次。通过init方法的参数，可获得代表当前filter配置信息的FilterConfig对象。

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

FilterConfig接口

用户在配置filter时，可以使用为filter配置一些初始化参数，当web容器实例化Filter对象，调用其init方法时，会把封装了filter初始化参数的filterConfig

对象传递进来。因此开发人员在编写filter时，通过filterConfig对象的方法，就可获得：

名称	描述
String getFilterName()	得到filter的名称。
String getInitParameter(String name)	返回在部署描述中指定名称的初始化参数的值。不存在返回null。
Enumeration getInitParameterNames()	返回过滤器的所有初始化参数的名字的枚举集合。
public ServletContext getServletContext()	返回Servlet上下文对象的引用。

范例：利用FilterConfig得到filter配置信息

public class FilterDemo02 implements Filter {
    /* 过滤器初始化
     * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("----过滤器初始化----");
        //得到过滤器的名字
        String filterName = filterConfig.getFilterName();
        //得到在web.xml文件中配置的初始化参数
        String initParam1 = filterConfig.getInitParameter("name");
        String initParam2 = filterConfig.getInitParameter("like");
        //返回过滤器的所有初始化参数的名字的枚举集合。
        Enumeration<String> initParameterNames = filterConfig.getInitParameterNames();
        
        System.out.println(filterName);
        System.out.println(initParam1);
        System.out.println(initParam2);
        while (initParameterNames.hasMoreElements()) {
            String paramName = (String) initParameterNames.nextElement();
            System.out.println(paramName);
        }
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.out.println("FilterDemo02执行前！！！");
        chain.doFilter(request, response);  //让目标资源执行，放行
        System.out.println("FilterDemo02执行后！！！");
    }
    @Override
    public void destroy() {
        System.out.println("----过滤器销毁----");
    }
}

web.xml中的配置：

<filter>
      <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>legend</param-value>
      </init-param>
      <init-param>
          <description>配置FilterDemo02过滤器的初始化参数</description>
          <param-name>like</param-name>
          <param-value>java</param-value>
      </init-param>
</filter>
 <filter-mapping>
      <filter-name>FilterDemo02</filter-name>
      <!--“/*”表示拦截所有的请求 -->
      <url-pattern>/*</url-pattern>
 </filter-mapping>

Filter部署

Filter的部署分为两个步骤：注册Filter和部署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>

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

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

Filter高级开发

　在filter中可以得到代表用户请求和响应的request、response对象，因此在编程中可以使用Decorator(装饰器)模式对request、response对象进行包装，再把包装对象传给

目标资源，从而实现一些特殊需求。

装饰设计模式

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

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

装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。装饰模式是在不必改变原类文件和使用继承的情况下，动态的

扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

装饰模式的实现步骤如下：

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

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

Servlet API 中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper，HttpServletRequestWrapper 类实现了request 接口中的所有方法，

但这些方法的内部实现都是仅仅调用了一下所包装的的 request 对象的对应方法，以避免用户在对request对象进行增强时需要实现request接口中的所有方法。

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

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

public class CharacterEncodingFilter implements Filter {
    private String mDefaultCharset="UTF-8";
    private FilterConfig mFilterConfig;
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        this.mFilterConfig = filterConfig;
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        String charset = mFilterConfig.getInitParameter("charset");
        if (charset == null) {
            charset = mDefaultCharset;
        }
        request.setCharacterEncoding(charset);
        response.setCharacterEncoding(charset);
        response.setContentType("text/html;charset=" + charset);
        MyCharacterEncodingRequest myCharacterEncodingRequest = new MyCharacterEncodingRequest(request);
        filterChain.doFilter(myCharacterEncodingRequest, response);
    }
    @Override
    public void destroy() {
    }
    // 装饰模式类
    class MyCharacterEncodingRequest extends HttpServletRequestWrapper {
        private HttpServletRequest mRequest;
        public MyCharacterEncodingRequest(HttpServletRequest request) {
            super(request);
            this.mRequest = request;
        }
        // 覆盖需要增强的方法
        @Override
        public String getParameter(String name) {
            try {
                // 获取参数值
                String value = mRequest.getParameter(name);
                if (value == null) {
                    return null;
                }
                // 如果不是以get提交数据的话，就直接返回获取到的值
                if (!this.mRequest.getMethod().equalsIgnoreCase("get")) {
                    return value;
                }else {
                    // 如果是get方式提交数据的话，就对数据的值进行转换处理
                    value = new String(value.getBytes("ISO8859-1"), mRequest.getCharacterEncoding());
                    return value;
                }
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

在web.xml文件中配置CharacterEncodingFilter 和 ServletDemo1

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

编写处理用户请求的ServletDemo1

public class ServletDemo1 extends HttpServlet {
    protected void doPost(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);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doPost(request, response);
    }
}

编写jsp测试页面，如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
    <head>
        <title>使用字符过滤器解决解决get、post请求方式下的中文乱码问题</title>
    </head>
    <body>
        <c:url value="/ServletDemo1" scope="page" var="servletDemo1">
            <c:param name="username" value="legend"></c:param>
        </c:url>
    <a href="${servletDemo1}">超链接(get方式)</a>
    <hr/>
    <form action="${pageContext.request.contextPath}/ServletDemo1" method="post">
        用户名：<input type="text" name="username" value="legend">
        <input type="submit" value="post提交">
    </form>
    </body>
</html>

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

请求的方式：POST
接到的参数：legend

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

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

public class HtmlFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        MyHtmlRequest myHtmlRequest = new MyHtmlRequest(request);
        filterChain.doFilter(myHtmlRequest, response);
    }
    @Override
    public void destroy() {
    }
    // 装饰模式
    class MyHtmlRequest extends HttpServletRequestWrapper {
        private HttpServletRequest mRequest;
        public MyHtmlRequest(HttpServletRequest request) {
            super(request);
            mRequest = request;
        }
        // 覆盖需要增强 的getParameter
        @Override
        public String getParameter(String name) {
            String value = mRequest.getParameter(name);
            if (value == null) {
                return null;
            }
            // 调用Filter转义value中的html标签
            return filter(value);
        }
        private String filter(String message) {
            char[] content = new char[message.length()];
            message.getChars(0, message.length(), content, 0);
            StringBuffer sb = new StringBuffer(content.length + 50);
            for (int i = 0; i < content.length; i++) {
                switch (content[i]) {
                    case '<':
                        sb.append("&lt");
                        break;
                    case '>':
                        sb.append("&gt");
                        break;
                    case '&':
                        sb.append("&amp");
                        break;
                    case '"':
                        sb.append("&quot");
                        break;
                    default:
                        sb.append(content[i]);
                }
            }
            return sb.toString();
        }
    }
}

　在web.xml文件中配置HtmlFilter 和 ServletDemo2

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

编写jsp测试页面，如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>html过滤器测试</title>
    </head>
    <body>
        <form action="${pageContext.request.contextPath}/ServletDemo2" method="post">
            留言：
            <textarea rows="8" cols="70" name="message">
                <script type="text/javascript">
                    alert("我是一个对话框，一个对话框！");
                </script>
                <a href="http://www.baidu.com">访问百度</a>
            </textarea>
            <input type="submit" value="发表">
        </form>
    </body>
</html>

输出结果：

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

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

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

public class DirtyFilter implements Filter {
    private FilterConfig mConfig = null;
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        this.mConfig = filterConfig;
        System.out.println("---初始化敏感词过滤器---");
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        DityRequest dityRequest = new DityRequest(request);
        filterChain.doFilter(dityRequest, response);
    }
    @Override
    public void destroy() {
    }
    private List<String> getDirtyWords() {
        List<String> dirtyWords = new ArrayList<String>();
        String dirtyWordPath = mConfig.getInitParameter("dirty_word");
        InputStream in = mConfig.getServletContext().getResourceAsStream(dirtyWordPath);
        InputStreamReader reader = null;
        try {
            reader = new InputStreamReader(in, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        BufferedReader buf = new BufferedReader(reader);
        String line;
        try {
            while ((line = buf.readLine())!= null) {
                dirtyWords.add(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return dirtyWords;
    }
    class DityRequest  extends HttpServletRequestWrapper {
        private HttpServletRequest mRequest;
        private List<String> dirtyWords = getDirtyWords();
        public DityRequest(HttpServletRequest request) {
            super(request);
            this.mRequest = request;
        }
        // 重写getParameter方法
        @Override
        public String getParameter(String name) {
            String value = this.mRequest.getParameter(name);
            if (value == null) {
                return null;
            }
            for(String dityWord : dirtyWords) {
                if (value.contains(dityWord)){
                    System.out.println("内容中包含敏感词：" + dityWord + "，将会被替换成**");
                    // 替换敏感字符
                    value = value.replace(dityWord, "**");
                }
            }
            return value;
        }
    }
}

然后在web.xml中进行配置：

<filter>
    <filter-name>DirtyFilter</filter-name>
    <filter-class>com.legend.filter.DirtyFilter</filter-class>
    <init-param>
        <param-name>dirty_word</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过滤器中就会将这些敏感字符替换掉。

您上次的留言是：

<script type="text/javascript"> alert("我**！"); </script> 访问百度

我们如果将上述的CharacterEncodingFilter、HtmlFilter、DirtyFilter这三个过滤器联合起来使用，那么就相当于是把request对象包装了3次，request对象的getParameter方法经

过3次重写，使得getParameter方法的功能大大增强，可以同时解决中文乱码，html标签转义，敏感字符过滤这些需求。

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

增强response对象

Servlet API 中提供了response对象的Decorator设计模式的默认实现类HttpServletResponseWrapper ，HttpServletResponseWrapper类实现了response接口中的所有方法，

但这些方法的内部实现都是仅仅调用了一下所包装的的 response对象的对应方法，以避免用户在对response对象进行增强时需要实现response接口中的所有方法。

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

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

思路：

通过filter向目标页面传递一个自定义的response对象。在自定义的response对象中，重写getOutputStream方法和getWriter方法，使目标资源调用此方法输出页面内容时，获得

的是我们自定义的ServletOutputStream对象。在我们自定义的ServletOuputStream对象中，重写write方法，使写出的数据写出到一个buffer中。当页面完成输出后，在filter中就可

得到页面写出的数据，从而我们可以调用GzipOuputStream对数据进行压缩后再写出给浏览器，以此完成响应正文件压缩功能。
编写压缩过滤器，代码如下：

public class GzipFilter implements Filter {
    public void doFilter(ServletRequest req, ServletResponse resp,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        BufferResponse myresponse = new BufferResponse(response);
        chain.doFilter(request, myresponse);
        //拿出缓存中的数据，压缩后再打给浏览器
        byte out[] = myresponse.getBuffer();
        System.out.println("原始大小:" + out.length);
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        //压缩输出流中的数据
        GZIPOutputStream gout = new GZIPOutputStream(bout);
        gout.write(out);
        gout.close();
        byte gzip[] = bout.toByteArray();
        System.out.println("压缩后的大小:" + gzip.length);
        response.setHeader("content-encoding", "gzip");
        response.setContentLength(gzip.length);
        response.getOutputStream().write(gzip);
    }
    public void destroy() {
    }
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    class BufferResponse extends HttpServletResponseWrapper{
        private ByteArrayOutputStream bout = new ByteArrayOutputStream();
        private PrintWriter pw;
        private HttpServletResponse response;
        public BufferResponse(HttpServletResponse response) {
            super(response);
            this.response = response;
        }
        @Override
        public ServletOutputStream getOutputStream() throws IOException {
            return new MyServletOutputStream(bout);
        }
        @Override
        public PrintWriter getWriter() throws IOException {
            pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
            return pw;
        }
        public byte[] getBuffer(){
            try{
                if(pw!=null){
                    pw.close();
                }
                if(bout!=null){
                    bout.flush();
                    return bout.toByteArray();
                }
                return null;
            }catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
    class MyServletOutputStream extends ServletOutputStream{
        private ByteArrayOutputStream bout;
        public MyServletOutputStream(ByteArrayOutputStream bout){
            this.bout = bout;
        }
        @Override
        public void write(int b) throws IOException {
            this.bout.write(b);
        }
    }
}

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

<filter>
      <description>配置压缩过滤器</description>
      <filter-name>GzipFilter</filter-name>
      <filter-class>com.legend.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增强案例—缓存数据到内存

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

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

public class WebResourceCachedFilter implements Filter {
    /**
    * @Field: map
    *     缓存Web资源的Map容器
    */ 
    private Map<String,byte[]> map = new HashMap<String,byte[]>();
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException { }
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //1.得到用户请求的uri
        String uri = request.getRequestURI();
        //2.看缓存中有没有uri对应的数据
        byte b[] = map.get(uri);
        //3.如果缓存中有，直接拿缓存的数据打给浏览器，程序返回
        if(b != null){
            //根据字节数组和指定的字符编码构建字符串
            String webResourceHtmlStr = new String(b,response.getCharacterEncoding());
            System.out.println(webResourceHtmlStr);
            response.getOutputStream().write(b);
            return;
        }
        //4.如果缓存没有，让目标资源执行，并捕获目标资源的输出
        BufferResponse myresponse = new BufferResponse(response);
        chain.doFilter(request, myresponse);
        //获取缓冲流中的内容的字节数组
        byte out[] = myresponse.getBuffer();
        //5.把资源的数据以用户请求的uri为关键字保存到缓存中
        map.put(uri, out);
        //6.把数据打给浏览器
        response.getOutputStream().write(out);
    }
    @Override
    public void destroy() { }
    class BufferResponse extends HttpServletResponseWrapper{
        private ByteArrayOutputStream bout = new ByteArrayOutputStream();  //捕获输出的缓存
        private PrintWriter pw;
        private HttpServletResponse response;
        public BufferResponse(HttpServletResponse response) {
            super(response);
            this.response = response;
        }
        @Override
        public ServletOutputStream getOutputStream() throws IOException {
            return new MyServletOutputStream(bout);
        }
        @Override
        public PrintWriter getWriter() throws IOException {
            pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));
            return pw;
        }
        
        public byte[] getBuffer(){
            try{
                if(pw!=null){
                    pw.close();
                }
                return bout.toByteArray();
            }catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
    class MyServletOutputStream extends ServletOutputStream{
        private ByteArrayOutputStream bout;
        public MyServletOutputStream(ByteArrayOutputStream bout){  //接收数据写到哪里
            this.bout = bout;
        }
        @Override
        public void write(int b) throws IOException {
            bout.write(b);
        }
    }
}

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

<filter>
       <description>Web资源缓存过滤器</description>
      <filter-name>WebResourceCachedFilter</filter-name>
      <filter-class>com.legend.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请求参数的中文问题

public class CharacterEncodingFilter implements Filter {
    private FilterConfig mFilterConfig = null;
    // 设置默认的字符编码
    private String mCharset = "UTF-8";
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        this.mFilterConfig = filterConfig;
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        String charset = mFilterConfig.getInitParameter("charset");
        if (charset == null) {
            charset = mCharset;
        }
        request.setCharacterEncoding(charset);
        response.setCharacterEncoding(charset);
        response.setContentType("text/html;charset=" + charset);
        MyCharacterEncodingRequest encodingRequest = new MyCharacterEncodingRequest(request);
        filterChain.doFilter(encodingRequest, response);
    }
    @Override
    public void destroy() {
    }
    class MyCharacterEncodingRequest extends HttpServletRequestWrapper {
        private HttpServletRequest mRequest;
        public MyCharacterEncodingRequest(HttpServletRequest request) {
            super(request);
            this.mRequest = request;
        }
        // 重写geParameter方法
        @Override
        public String getParameter(String name) {
            try {
                // 获取参数的值
                String value = this.mRequest.getParameter(name);
                if (value == null){
                    return null;
                }
                // 如果不是以get防守提交数据，就直接返回获取到的值
                if (!this.mRequest.getMethod().equalsIgnoreCase("get")) {
                    return value;
                }else {
                    value = new String(value.getBytes("ISO8859-1"), mRequest.getCharacterEncoding());
                    return value;
                }
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

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

<filter>
    <filter-name>CharecterEncodingFilter</filter-name>
    <filter-class>com.legend.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>charset</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharecterEncodingFilter</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秒。

public class NoCacheFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        // 进制浏览器缓存所有动态页面
        response.setDateHeader("Expires", -1);
        response.setHeader("Cache-Control", "no-cache");
        response.setHeader("Pragma", "no-cache");
        filterChain.doFilter(request, response);
    }
    @Override
    public void destroy() {
    }
}

web.xml文件中的配置如下

<filter>
    <filter-name>NoCacheFilter</filter-name>
    <filter-class>com.legend.filter.NoCacheFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>NoCacheFilter</filter-name>
    <url-pattern>*.jsp</url-pattern>
</filter-mapping>

缓存静态资源

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

public class CacheFilter implements Filter {
    private FilterConfig mFilterConfig;
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        mFilterConfig = filterConfig;
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        // 1、获取用户想访问的资源
        String uri = request.getRequestURI();
        // 2、得到用户想访问的资源的后缀名
        String ext = uri.substring(uri.lastIndexOf(".") + 1);
        // 得到资源需要缓存的事件
        String time = mFilterConfig.getInitParameter(ext);
        if (time != null) {
            long t = Long.parseLong(time) * 3600 * 1000;
            // 设置缓存
            response.setDateHeader("expires", System.currentTimeMillis());
        }
        filterChain.doFilter(request, response);
    }
    @Override
    public void destroy() {
    }
}

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

<filter>
    <filter-name>CacheFilter</filter-name>
    <filter-class>com.legend.filter.CacheFilter</filter-class>
    <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>
<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>