过滤器可以在执行Servlet的service()方法前后，进行前置和后置处理。但是有些信息无法更改，例如请求参数。使用请求封装器及相应封装器，将容器产生的请求与相应对象加以封装，可以针对某个请求信息或响应进行加工处理。

请求封装器

HttpServletRequestWrapper实现了HttpServletRequest接口，以下范例通过继承HttpServletRequestWrapper实现了一个请求封装器，可以请请求参数中的角括号替换为替代字符。

import java.util.Iterator;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

public class CharacterRequestWrapper extends HttpServletRequestWrapper{
    private Map<String, String> escapeMap;

    public CharacterRequestWrapper(HttpServletRequest request, 
            Map<String, String> escapeMap) {
        super(request); //封装传入的请求对象
        this.escapeMap = escapeMap;
    }

    @Override
    public String getParameter(String name) { //重写getParameter()方法
        return doEscape(this.getRequest().getParameter(name));
    }

    private String doEscape(String parameter) {
        if (parameter == null) {
            return null;
        }
        String result = parameter;
        Iterator<String> it = escapeMap.keySet().iterator();
        while(it.hasNext()) {
            String origin = it.next();
            String escape = escapeMap.get(origin);
            result = result.replaceAll(origin, escape);
        }

        return result;
    }
}

可以使用这个请求封装器搭配过滤器，以进行字符过滤的服务。例如：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

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;

public class CharacterFilter implements Filter {
    private Map<String, String> escapeMap;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        BufferedReader reader = null;
        try {
            String escapeListFile = filterConfig.getInitParameter("ESCAPE_LIST");
            reader = new BufferedReader(new InputStreamReader(
                    filterConfig.getServletContext().getResourceAsStream(escapeListFile)));

            String input = null;
            escapeMap = new HashMap<String, String>();
            while ((input = reader.readLine()) != null) {
                String[] token = input.split("\t");
                escapeMap.put(token[0], token[1]);
            }
        } catch (IOException ex) {
            Logger.getLogger(CharacterFilter.class.getName())
                    .log(Level.SEVERE, null, ex);
        } finally {
            try {
                reader.close();
            } catch (IOException ex) {
                Logger.getLogger(CharacterFilter.class.getName())
                        .log(Level.SEVERE, null, ex);
            }
        }
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        //将原请求对象封装到CharacterRequestWrapper中
        HttpServletRequest requestWrapper = 
                new CharacterRequestWrapper((HttpServletRequest)request, escapeMap);
        //将CharacterRequestWrapper对象当做请求参数传入doFilter()
        chain.doFilter(requestWrapper, response);
    }

    @Override
    public void destroy() {
        // TODO Auto-generated method stub
    }
}

响应封装器

如果想要对响应的内容进行压缩处理等，可以在响应封装器部分继承HttpServletResponseWrapper类来对HttpServletResponse对象进行封装。

如要对浏览器进行输出响应，必须通过getWriter()取得PrintWriter，或是通过getOutputStream()取得ServletOutputStream。所以针对压缩输出的请求，主要就是继承HttpServletResponseWrapper之后，通过重写这两个方法来达成的。

在这里压缩功能将采用GZIP格式，这是浏览器可以接受的压缩格式，可以使用GZIPOutputStream类来实现。由于getWriter()的PrintWriter在创建时也是必须要用到ServletOutputStream，所以这里首先扩展ServletOutputStream类，让它具有压缩功能。

GzipServletOutputStream.java:

package club.chuxing;

import java.io.IOException;
import java.util.zip.GZIPOutputStream;

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;

public class GZipServletOutputStream extends ServletOutputStream{
    private GZIPOutputStream gzipOutputStream;

    public GZipServletOutputStream(ServletOutputStream servletOutputStream) 
            throws IOException {
        this.gzipOutputStream = new GZIPOutputStream(servletOutputStream);
    }

    public void write(int b) throws IOException {
        //输出时通过GZIPOutputSteam的write()压缩输出
        gzipOutputStream.write(b);
    }

    public GZIPOutputStream getGzipOutputStream() {
        return gzipOutputStream;
    }

    @Override
    public boolean isReady() {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public void setWriteListener(WriteListener listener) {
        // TODO Auto-generated method stub
    }
}

CompressionResponseWrapper.java:

package club.chuxing;

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

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

public class CompressionResponseWrapper extends HttpServletResponseWrapper {
    private GZipServletOutputStream gzServletOutputStream;
    private PrintWriter printWriter;
    public CompressionResponseWrapper(HttpServletResponse resp) {
        super(resp);
    }

    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        if (printWriter != null) {
            throw new IllegalStateException();
        }
        if (gzServletOutputStream == null) {
            gzServletOutputStream = new GZipServletOutputStream(
                    getResponse().getOutputStream());
        }

        return gzServletOutputStream;
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        if (gzServletOutputStream != null) {
            throw new IllegalStateException();
        }
        if (printWriter == null) {
            gzServletOutputStream = new GZipServletOutputStream(
                    getResponse().getOutputStream());
            OutputStreamWriter osw = new OutputStreamWriter(
                    gzServletOutputStream, getResponse().getCharacterEncoding());
            printWriter = new PrintWriter(osw);
        }

        return printWriter;
    }

    @Override
    public void setContentLength(int len) {

    }

    public GZIPOutputStream getGZIPOutputStream() {
        if (this.gzServletOutputStream == null) {
            return null;
        }
        return this.gzServletOutputStream.getGzipOutputStream();
    }
}

CompressionFilter.java(压缩过滤器):

package club.chuxing;

import java.io.IOException;
import java.util.zip.GZIPOutputStream;

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;

public class CompressionFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // TODO Auto-generated method stub
    }

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

        String encodings = req.getHeader("accept-encoding");
        if ((encodings != null) && encodings.indexOf("gzip") > -1) {
            //建立响应封装
            CompressionResponseWrapper responseWrapper = 
                    new CompressionResponseWrapper(res);
            //设置响应内容编码为gzip格式
            responseWrapper.setHeader("content-encoding", "gzip");

            chain.doFilter(request, responseWrapper);

            GZIPOutputStream gzipOutputStream = responseWrapper.getGZIPOutputStream();
            if (gzipOutputStream != null) {
                //调用GZIPOutputStream的finish()方法完成压缩输出
                gzipOutputStream.finish();
            }
        } else {
            chain.doFilter(request, response);
        }
    }

    @Override
    public void destroy() {
        // TODO Auto-generated method stub
    }
}

最后，将过滤器设置在web.xml中，响应就会是压缩过后的内容。