JavaWeb學習總結（九）Filter用法（二）

當某個對象的方法不適應業務需求時，通常有2種方式可以對方法進行增強：

1. 編寫子類，覆蓋需增強的方法。
2. 使用Decorator設計模式對方法進行增強。

　　在閻宏博士的《JAVA與模式》一書中開頭是這樣描述裝飾（Decorator）模式的：裝飾模式又名包裝(Wrapper)模式。裝飾模式以對客戶端透明的方式擴展對象的功能，是繼承關係的一個替代方案。裝飾模式是在不必改變原類文件和使用繼承的情況下，動態的擴展一個對象的功能。它是通過創建一個包裝對象，也就是裝飾來包裹真實的對象。

　　那麼在實際應用中遇到需增強對象的方法時，到底選用哪種方式比較好呢？這個沒有具體的定式，只能是根據具體的需求來採用具體的方式，不過有一種情況下，必須使用Decorator設計模式：即被增強的對象，開發人員只能得到它的對象，無法得到它的class文件。比如request、response對象，開發人員之所以在servlet中能通過sun公司定義的HttpServletRequest\response接口去操作這些對象，是因爲Tomcat服務器廠商編寫了request、response接口的實現類。web服務器在調用servlet時，會用這些接口的實現類創建出對象，然後傳遞給servlet程序。此種情況下，由於開發人員根本不知道服務器廠商編寫的request、response接口的實現類是哪個？在程序中只能拿到服務器廠商提供的對象，因此就只能採用Decorator設計模式對這些對象進行增強。

1.2、Decorator設計模式的實現

　　1.首先看需要被增強對象繼承了什麼接口或父類，編寫一個類也去繼承這些接口或父類。
　　2.在類中定義一個變量，變量類型即需增強對象的類型。
　　3.在類中定義一個構造函數，接收需增強的對象。
　　4.覆蓋需增強的方法，編寫增強的代碼。

 二、使用Decorator設計模式增強request對象

　　Servlet API 中提供了一個request對象的Decorator設計模式的默認實現類HttpServletRequestWrapper，HttpServletRequestWrapper 類實現了request 接口中的所有方法，但這些方法的內部實現都是僅僅調用了一下所包裝的的 request 對象的對應方法，以避免用戶在對request對象進行增強時需要實現request接口中的所有方法。

2.1、使用Decorator模式包裝request對象解決get和post請求方式下的中文亂碼問題

　　編寫一個用於處理中文亂碼的過濾器CharacterEncodingFilter，代碼如下：

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.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

/**
* @ClassName: CharacterEncodingFilter
* @Description: 此過濾器用來解決解決get、post請求方式下的中文亂碼問題
* @author: 孤傲蒼狼
* @date: 2014-8-31 下午11:09:37
*
*/ 
public class CharacterEncodingFilter implements Filter {

    private FilterConfig filterConfig = null;
    //設置默認的字符編碼
    private String defaultCharset = "UTF-8";

    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //得到在web.xml中配置的字符編碼
        String charset = filterConfig.getInitParameter("charset");
        if(charset==null){
            charset = defaultCharset;
        }
        request.setCharacterEncoding(charset);
        response.setCharacterEncoding(charset);
        response.setContentType("text/html;charset="+charset);
        
        MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);
        chain.doFilter(requestWrapper, response);
    }

    public void init(FilterConfig filterConfig) throws ServletException {
        //得到過濾器的初始化配置信息
        this.filterConfig = filterConfig;
    }
    
    public void destroy() {

    }
}

/**
* @ClassName: MyCharacterEncodingRequest
* @Description: Servlet API中提供了一個request對象的Decorator設計模式的默認實現類HttpServletRequestWrapper,
* (HttpServletRequestWrapper類實現了request接口中的所有方法，但這些方法的內部實現都是僅僅調用了一下所包裝的的 request對象的對應方法)
* 以避免用戶在對request對象進行增強時需要實現request接口中的所有方法。
* 所以當需要增強request對象時，只需要寫一個類繼承HttpServletRequestWrapper類，然後在重寫需要增強的方法即可
* @author: 孤傲蒼狼
* @date: 2014-9-2 下午10:42:57
*     1.實現與被增強對象相同的接口 
    2、定義一個變量記住被增強對象
    3、定義一個構造函數，接收被增強對象
    4、覆蓋需要增強的方法
    5、對於不想增強的方法，直接調用被增強對象（目標對象）的方法
*/ 
class MyCharacterEncodingRequest extends HttpServletRequestWrapper{
    //定義一個變量記住被增強對象(request對象是需要被增強的對象)
    private HttpServletRequest request;
    //定義一個構造函數，接收被增強對象
    public MyCharacterEncodingRequest(HttpServletRequest request) {
        super(request);
        this.request = request;
    }
    /* 覆蓋需要增強的getParameter方法
     * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
     */
    @Override
    public String getParameter(String name) {
        try{
            //獲取參數的值
            String value= this.request.getParameter(name);
            if(value==null){
                return null;
            }
            //如果不是以get方式提交數據的，就直接返回獲取到的值
            if(!this.request.getMethod().equalsIgnoreCase("get")) {
                return value;
            }else{
                //如果是以get方式提交數據的，就對獲取到的值進行轉碼處理
                value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
                return value;
            }
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

在web.xml文件中配置CharacterEncodingFilter：

<!--配置字符過濾器，解決get、post請求方式下的中文亂碼問題-->
  <filter>
      <filter-name>CharacterEncodingFilter</filter-name>
      <filter-class>di.cha.filter.CharacterEncodingFilter</filter-class>
  </filter>
  
  <filter-mapping>
      <filter-name>CharacterEncodingFilter</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>

2.2、使用Decorator模式包裝request對象實現html標籤轉義功能

　　編寫一個html轉義過濾器，代碼如下：

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.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

/**
* @ClassName: HtmlFilter
* @Description: html轉義過濾器
* @author: 孤傲蒼狼
* @date: 2014-9-2 下午11:28:41
*
*/ 
public class HtmlFilter implements Filter {

    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;

        MyHtmlRequest myrequest = new MyHtmlRequest(request);
        chain.doFilter(myrequest, response);
        
    }

    
    public void destroy() {
        
    }

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

/**
* @ClassName: MyHtmlRequest
* @Description: 使用Decorator模式包裝request對象，實現html標籤轉義功能
* @author: 孤傲蒼狼
* @date: 2014-9-2 下午11:29:09
*
*/ 
class MyHtmlRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;

    public MyHtmlRequest(HttpServletRequest request) {
        super(request);
        this.request = request;
    }

    /* 覆蓋需要增強的getParameter方法
     * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
     */
    @Override
    public String getParameter(String name) {
        String value = this.request.getParameter(name);
        if (value == null) {
            return null;
        }
        //調用filter轉義value中的html標籤
        return filter(value);
    }

    /**
    * @Method: filter
    * @Description: 過濾內容中的html標籤
    * @Anthor:孤傲蒼狼
    * @param message
    * @return
    */ 
    public String filter(String message) {
        if (message == null){
            return null;
        }
        char content[] = new char[message.length()];
        message.getChars(0, message.length(), content, 0);
        StringBuffer result = new StringBuffer(content.length + 50);
        for (int i = 0; i < content.length; i++) {
            switch (content[i]) {
            case '<':
                result.append("<");
                break;
            case '>':
                result.append(">");
                break;
            case '&':
                result.append("&");
                break;
            case '"':
                result.append(""");
                break;
            default:
                result.append(content[i]);
            }
        }
        return result.toString();
    }
}

在web.xml文件中配置HtmlFilter：

<!--配置Html過濾器，轉義內容中的html標籤-->
  <filter>
      <filter-name>HtmlFilter</filter-name>
      <filter-class>di.cha.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="http://www.cnblogs.com">訪問博客園</a>
           </textarea>
           <input type="submit" value="發表">
       </form>
  </body>
</html>

編寫處理用戶請求的ServletDemo2：

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);
    }
}

測試結果如下：

     從運行結果中可以看到，所有的html標籤都被轉義輸出了。

2.3、使用Decorator模式包裝request對象實現敏感字符過濾功能

　　編寫一個敏感字符過濾器，代碼如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
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.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

/**
* @ClassName: DirtyFilter
* @Description: 敏感詞過濾器
* @author: 孤傲蒼狼
* @date: 2014-9-6 上午10:43:11
*
*/ 
public class DirtyFilter implements Filter {

    private FilterConfig config = null;
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        this.config = filterConfig;
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        DirtyRequest dirtyrequest = new DirtyRequest(request);
        
        chain.doFilter(dirtyrequest, response);
    }

    @Override
    public void destroy() {

    }
    
    /**
    * @Method: getDirtyWords
    * @Description: 獲取敏感字符
    * @Anthor:孤傲蒼狼
    *
    * @return
    */ 
    private List<String> getDirtyWords(){
        List<String> dirtyWords = new ArrayList<String>();
        String dirtyWordPath = config.getInitParameter("dirtyWord");
        InputStream inputStream = config.getServletContext().getResourceAsStream(dirtyWordPath);
        InputStreamReader is = null;
        try {
            is = new InputStreamReader(inputStream,"UTF-8");
        } catch (UnsupportedEncodingException e2) {
            e2.printStackTrace();
        }
        BufferedReader reader = new BufferedReader(is);
        String line;
        try {
            while ((line = reader.readLine())!= null) {//如果 line爲空說明讀完了
                dirtyWords.add(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } 
        return dirtyWords;
    }
    
    /**
    * @ClassName: DirtyRequest
    * @Description: 使用Decorator模式包裝request對象，實現敏感字符過濾功能
    * @author: 孤傲蒼狼
    * @date: 2014-9-6 上午11:56:35
    *
    */ 
    class DirtyRequest extends HttpServletRequestWrapper{

        private List<String> dirtyWords = getDirtyWords();
        private HttpServletRequest request;
        public DirtyRequest(HttpServletRequest request) {
            super(request);
            this.request = request;
        }
        /* 重寫getParameter方法，實現對敏感字符的過濾
         * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
         */
        @Override
        public String getParameter(String name) {
            
            String value = this.request.getParameter(name);
            if(value==null){
                return null;
            }
            
            for(String dirtyWord : dirtyWords){
                if(value.contains(dirtyWord)){
                    System.out.println("內容中包含敏感詞："+dirtyWord+"，將會被替換成****");
                    //替換敏感字符
                    value = value.replace(dirtyWord, "****");
                }
            }
            return value;
        }
    }
}

在web.xml文件中配置DirtyFilter:

<!--配置敏感字符過濾器-->
  <filter>
      <filter-name>DirtyFilter</filter-name>
      <filter-class>di.cha.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標籤轉義，敏感字符過濾這些功能，例如：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

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.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

/**
* @ClassName: AdvancedFilter
* @Description: 這個過濾器是用來解決中文亂碼，轉義內容中的html標籤，過濾內容中的敏感字符的
* @author: 孤傲蒼狼
* @date: 2014-9-6 下午6:17:37
*
*/ 
public class AdvancedFilter implements Filter {

    private FilterConfig filterConfig = null;
    //設置默認的字符編碼
    private String defaultCharset = "UTF-8";
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //得到過濾器的初始化配置信息
        this.filterConfig = filterConfig;
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //得到在web.xml中配置的字符編碼
        String charset = filterConfig.getInitParameter("charset");
        if(charset==null){
            charset = defaultCharset;
        }
        request.setCharacterEncoding(charset);
        response.setCharacterEncoding(charset);
        response.setContentType("text/html;charset="+charset);
        
        AdvancedRequest requestWrapper = new AdvancedRequest(request);
        chain.doFilter(requestWrapper, response);
    }

    @Override
    public void destroy() {

    }

    class AdvancedRequest extends HttpServletRequestWrapper{
        
        private List<String> dirtyWords = getDirtyWords();
        
        //定義一個變量記住被增強對象(request對象是需要被增強的對象)
        private HttpServletRequest request;
        //定義一個構造函數，接收被增強對象
        public AdvancedRequest(HttpServletRequest request) {
            super(request);
            this.request = request;
        }
        /* 覆蓋需要增強的getParameter方法
         * @see javax.servlet.ServletRequestWrapper#getParameter(java.lang.String)
         */
        @Override
        public String getParameter(String name) {
            try{
                //獲取參數的值
                String value= this.request.getParameter(name);
                if(value==null){
                    return null;
                }
                //如果不是以get方式提交數據的，就直接返回獲取到的值
                if(!this.request.getMethod().equalsIgnoreCase("get")) {
                    //調用filter轉義value中的html標籤
                    value= filter(value);
                }else{
                    //如果是以get方式提交數據的，就對獲取到的值進行轉碼處理
                    value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());
                    //調用filter轉義value中的html標籤
                    value= filter(value);
                }
                
                for(String dirtyWord : dirtyWords){
                    if(value.contains(dirtyWord)){
                        System.out.println("內容中包含敏感詞："+dirtyWord+"，將會被替換成****");
                        //替換敏感字符
                        value = value.replace(dirtyWord, "****");
                    }
                }
                return value;
            }catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    /**
    * @Method: filter
    * @Description: 過濾內容中的html標籤
    * @Anthor:孤傲蒼狼
    * @param value
    * @return
    */ 
    public String filter(String value) {
        if (value == null){
            return null;
        }
        char content[] = new char[value.length()];
        value.getChars(0, value.length(), content, 0);
        StringBuffer result = new StringBuffer(content.length + 50);
        for (int i = 0; i < content.length; i++) {
            switch (content[i]) {
            case '<':
                result.append("<");
                break;
            case '>':
                result.append(">");
                break;
            case '&':
                result.append("&");
                break;
            case '"':
                result.append(""");
                break;
            default:
                result.append(content[i]);
            }
        }
        return (result.toString());
    }
    
    /**
    * @Method: getDirtyWords
    * @Description: 獲取敏感字符
    * @Anthor:孤傲蒼狼
    *
    * @return
    */ 
    private List<String> getDirtyWords(){
        List<String> dirtyWords = new ArrayList<String>();
        String dirtyWordPath = filterConfig.getInitParameter("dirtyWord");
        InputStream inputStream = filterConfig.getServletContext().getResourceAsStream(dirtyWordPath);
        InputStreamReader is = null;
        try {
            is = new InputStreamReader(inputStream,defaultCharset);
        } catch (UnsupportedEncodingException e2) {
            e2.printStackTrace();
        }
        BufferedReader reader = new BufferedReader(is);
        String line;
        try {
            while ((line = reader.readLine())!= null) {//如果 line爲空說明讀完了
                dirtyWords.add(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } 
        return dirtyWords;
    }
}

在web.xml文件中配置AdvancedFilter:

<filter>
      <filter-name>AdvancedFilter</filter-name>
      <filter-class>di.cha.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接口中的所有方法。

3.1、response增強案例——壓縮響應正文內容

　　應用HttpServletResponseWrapper對象，壓縮響應正文內容。

　　具體思路:通過filter向目標頁面傳遞一個自定義的response對象。在自定義的response對象中，重寫getOutputStream方法和getWriter方法，使目標資源調用此方法輸出頁面內容時，獲得的是我們自定義的ServletOutputStream對象。在我們自定義的ServletOuputStream對象中，重寫write方法，使寫出的數據寫出到一個buffer中。當頁面完成輸出後，在filter中就可得到頁面寫出的數據，從而我們可以調用GzipOuputStream對數據進行壓縮後再寫出給瀏覽器，以此完成響應正文件壓縮功能。

　　編寫壓縮過濾器，代碼如下：

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.zip.GZIPOutputStream;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

/**
* @ClassName: GzipFilter
* @Description: 壓縮過濾器，將web應用中的文本都經過壓縮後再輸出到瀏覽器
* @author: 孤傲蒼狼
* @date: 2014-9-7 上午10:52:42
*
*/ 
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>di.cha.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>

 3.2、response增強案例——緩存數據到內存

　　對於頁面中很少更新的數據，例如商品分類，爲避免每次都要從數據庫查詢分類數據，因此可把分類數據緩存在內存或文件中，以此來減輕數據庫壓力，提高系統響應速度。

　　編寫緩存數據的過濾器，代碼如下：

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

/**
* @ClassName: WebResourceCachedFilter
* @Description: Web資源緩存過濾器
* @author: 孤傲蒼狼
* @date: 2014-9-8 上午12:20:16
*
*/ 
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);
        }
    }
}

<filter>
       <description>Web資源緩存過濾器</description>
      <filter-name>WebResourceCachedFilter</filter-name>
      <filter-class>di.cha.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>

 3.3、原博文地址：http://www.cnblogs.com/xdp-gacl/p/3952405.html