Filter实现Gzip压缩数据

最新推荐文章于 2025-08-06 16:23:50 发布

转载最新推荐文章于 2025-08-06 16:23:50 发布 · 104 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/icoke/archive/2010/02/23/1672144.html

文章标签：

#java #设计模式

本文介绍了一种使用GZIP压缩技术减少HTTP响应体大小的方法。通过自定义Servlet过滤器GzipFilter，该方法能够在服务器端对响应内容进行实时压缩，从而减少网络传输的数据量，提升用户体验。文中详细展示了如何利用代理模式实现对原始HTTPServletResponse对象的功能增强，以支持压缩输出。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Filter实现压缩数据

package cn.icoke.filter;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.zip.GZIPOutputStream;

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.Filter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import javax.servlet.http.HttpSession;

/*
*author xiaozhe
*
*
*/
public class GzipFilter implements Filter {

    /**
     * Constructor of the object.
     */
    public GzipFilter() {
        super();
    }

    private FilterConfig filterConfig;

    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
    }

    public void doFilter(ServletRequest req, ServletResponse res,
            FilterChain filterChain) {
        try {

            HttpServletRequest request = (HttpServletRequest) req;
            HttpServletResponse response = (HttpServletResponse) res;
            HttpSession session = request.getSession();

            ProxyResponse rpoxy = new ProxyResponse(response);

            filterChain.doFilter(request, rpoxy.getResponse());
            byte[] result = rpoxy.toByteArray();
            System.out.println("压缩前的数据大小："+ result.length);
            //实现压缩数据
            byte[] gzipResult = gzip(result);
            System.err.println("压缩后的数据大小："+gzipResult.length);
            response.setHeader("Content-Encoding","gzip");
            response.setHeader("Content-Length", gzipResult.length+"");
            response.getOutputStream().write(gzipResult);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ServletException e) {
            e.printStackTrace();
        }
    }//end method doFilter()

    private byte[] gzip(byte[] result) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        GZIPOutputStream gout = new GZIPOutputStream(out);
        gout.write(result);
        gout.close();
        return out.toByteArray();
    }

    public void destroy() {

    }

}//end class

/*
* response 装饰设计模式实现
*/
/*
class RaiseResponse extends HttpServletResponseWrapper{

    private ByteArrayOutputStream out = new ByteArrayOutputStream();
    private PrintWriter pw = null;
    private HttpServletResponse response =
        (HttpServletResponse) super.getResponse();

    public RaiseResponse(HttpServletResponse response) {
        super(response);
    }

    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return new RaiseOutputStream(out);
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        //字符流在再转换成字节流是注意要用转换流OutputStreamWriter去转换并设置编码集不然会出现乱码现象
        pw = new PrintWriter(new OutputStreamWriter(out,response.getCharacterEncoding()));
        return pw;
    }

    public byte[] toByteArray(){
        if(pw != null){
            pw.close();
        }
        return out.toByteArray();
    }
}//end class
class RaiseOutputStream extends ServletOutputStream{
    ByteArrayOutputStream out = null;
    public RaiseOutputStream(ByteArrayOutputStream out){
        this.out = out;
    }
    @Override
    public void write(int b) throws IOException {
        out.write(b);
    }
}//end class
*/

/*
*代理模式实现数据压缩
*/
class ProxyResponse {

    private HttpServletResponse response;
    private ByteArrayOutputStream out = new ByteArrayOutputStream();
    private PrintWriter pw = null;
    public ProxyResponse(HttpServletResponse response){
        this.response = response;
    }
    public HttpServletResponse getResponse(){
        return (HttpServletResponse) Proxy.newProxyInstance(ProxyResponse.class.getClassLoader(),
                response.getClass().getInterfaces(),
                new InvocationHandler(){
                    public Object invoke(Object proxy, Method method,
                            Object[] args) throws Throwable {
                        if(method.getName().equals("getOutputStream")){
                            return new RaiseServletOutputStream(out);
                        }
                        if(method.getName().equals("getWriter")){
                            pw = new PrintWriter(
                                    new OutputStreamWriter(out,response.getCharacterEncoding()));
                            return pw;
                        }
                        return method.invoke(response, args);
                    }
        });
    }//end method

    public byte[] toByteArray(){
        if(pw != null){
            pw.close();
        }
        return out.toByteArray();
    }//end method

}//end class
class RaiseServletOutputStream extends ServletOutputStream{

    ByteArrayOutputStream out = null;
    public RaiseServletOutputStream(ByteArrayOutputStream out ){
        this. out = out;
    }
    @Override
    public void write(int b) throws IOException {
        out.write(b);
    }
}

/*
* 在配置一个压缩功能的filter时要注意 <dispatcher>FORWARD</dispatcher>
* 拦截方式要大写可以同时配置多个拦截方式
*
*     <filter>
          <filter-name>GzipFilter</filter-name>
          <filter-class>cn.icoke.filter.GzipFilter</filter-class>
    </filter>
    <filter-mapping>
          <filter-name>GzipFilter</filter-name>
          <url-pattern>/*</url-pattern>
          <dispatcher>FORWARD</dispatcher>
    </filter-mapping>
*
*
*/

转载于:https://www.cnblogs.com/icoke/archive/2010/02/23/1672144.html