响应压缩

响应压缩的目的是压缩服务器向客户端发回的响应，这样就可以提高响应速度。但首先要确定用户浏览器支持响应压缩，即可以将服务器发来的压缩文件进行解压。

但是response的响应流—ServletOutputStream不是缓冲的，它不会等待过滤器处理，就会直接返回给用户。

所以要用装饰模式，将servletOutputStream包装成一个有缓冲的输出流。还要包装response得到getOutputStream方法和getWriter方法，都能返回相应缓冲功能的流。而且要流一个最终可访问的流。来刷新响应给用户。

GZIPServletOutputStream.java

package com.star7.forum.optmize;

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

import javax.servlet.ServletOutputStream;

/**
 * 包装ServletOutputStream，实现流的压缩。
 * 
 * @created : 2011-6-3下午03:19:09
 * @author star7
 * @email : [e-mail]
 */
public class GZIPServletOutputStream extends ServletOutputStream {
	
	// 声明包访问权限的GZIPOutoutStream
	GZIPOutputStream gZIPOutputStream;

	/**
	 * 构造器初始化压缩流。
	 * 这就是包装器的特征：《1》继承被包装的类《2》构造器的参数是被包装的类《3》覆盖被包装的类的部分方法。
	 * 
	 * @throws IOException 
	 * 
	 */
	public GZIPServletOutputStream(ServletOutputStream servletOutputStream) throws IOException{
		
		gZIPOutputStream = new 	GZIPOutputStream(servletOutputStream);
	}
	/**
	 * 覆盖原来的write方法。
	 * 这里需要的是声明的类是ServletOutputStream类型，和write方法，所以这样写就可以满足条件。
	 * 
	 */
	@Override
	public void write(int b) throws IOException {

		gZIPOutputStream.write(b);
	}

}

CompressionResponseWrapper.java

package com.star7.forum.optmize;

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;

/**
 * 包装响应流。
 * 
 * @created : 2011-6-3下午03:12:53
 * @author star7
 * @email : [e-mail]
 */
public class CompressionResponseWrapper extends HttpServletResponseWrapper {

	// 声明压缩输出流
	private GZIPServletOutputStream servletGzipOs = null;
	
	// 声明response中的PrintWriter
	private PrintWriter printWriter;
	
	/**
	 * 通过构造函数，进行包装。
	 * 这里父类是一个包装器，所以就用supper。
	 * 
	 * @param resp
	 */
	public CompressionResponseWrapper(HttpServletResponse resp){
		
		super(resp);
	}
	
	/**
	 * 返回压缩流，以便在调用它的地方刷新。
	 * 
	 */
	public GZIPOutputStream getGZIPOutputStream(){
		
		return this.servletGzipOs.gZIPOutputStream;
	}
	
	private Object streamUsed = null;
	
	/**
	 * 实现response的getOutputStream方法。
	 * 
	 */
	public ServletOutputStream getOutputStream()throws IOException{
		
		if((streamUsed != null)&&(streamUsed != printWriter)){
			// 如果在此之前没有访问过getWriter方法，就执行本方法
			
			throw new IllegalStateException();
		}
		
		if(servletGzipOs == null){
			
			// 装饰response的输出流
			servletGzipOs = new GZIPServletOutputStream(this.getResponse().getOutputStream());
			
			streamUsed = servletGzipOs;
		}
		
		// 返回装饰完的输出流
		return servletGzipOs;
	}
	
	public PrintWriter getWriter()throws IOException{
		
		if((streamUsed != null)&&(streamUsed != servletGzipOs)){
			// 如果在此之前没有访问过getOutputStream方法，才允许访问本方法
			
			throw new IllegalStateException();
		}
		
		if(printWriter == null){
			
			servletGzipOs = new GZIPServletOutputStream(getResponse().getOutputStream());
			
			// 通过OutputStreamWriter设置编码方式,因为这个流是字符流，所以一定需要编码，能够从字节流到字符流的流是OutputStreamWriter。
			OutputStreamWriter osw = new OutputStreamWriter(servletGzipOs,getResponse().getCharacterEncoding());
			
			// 通过装饰得到编码过的printwriter
			printWriter = new PrintWriter(osw);
		}
		
		return printWriter;
	}
}

CompressionFilter.java

package com.star7.forum.optmize;

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

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

/**
 * 压缩输出流。
 * 
 * @created : 2011-6-2下午10:09:48
 * @author star7
 * @email : [e-mail]
 */
public class CompressionFilter implements Filter {
	
	// 声明ServletContext
	private ServletContext servletContext;
	
	// 声明FilterConfig
	private FilterConfig filterConfig;

	@Override
	public void destroy() {

		// 清空对象引用，帮助回收机制回收
		servletContext = null;
		filterConfig = null;
	}

	/**
	 * 通过装饰器，包装response，实现相应流缓存。
	 * 
	 */
	@Override
	public void doFilter(ServletRequest req, ServletResponse resp,
			FilterChain filterChain) throws IOException, ServletException {
		
		// 转换成相应的Httpserlvet
		HttpServletRequest request = (HttpServletRequest)req;
		HttpServletResponse response = (HttpServletResponse)resp;

		// 得到请求头信息
		String acceptEncoding = request.getHeader("Accept-Encoding");
		if(acceptEncoding.contains("gzip")){
			// 如果用户浏览器支持解压
			
			CompressionResponseWrapper wrappedResp = new CompressionResponseWrapper(response);
			
			// 设置contentEncoding为gzip，如果注释掉，客户端就无法读取压缩后的数据
			wrappedResp.setHeader("Content-Encoding","gzip");
			
			// 链到下一个组件，响应已经被包装好
			filterChain.doFilter(req, wrappedResp);
			
			// 得到压缩流
			GZIPOutputStream gZIPOutputStream = wrappedResp.getGZIPOutputStream();
			
			// 刷新缓存
			gZIPOutputStream.finish();
			
			servletContext.log(filterConfig.getFilterName()+" :结束请求,压缩完毕.");
		}else{
			
			servletContext.log(filterConfig.getFilterName()+" 没有压缩响应");
			
			filterChain.doFilter(request, response);
		}
	}

	@Override
	public void init(FilterConfig cfg) throws ServletException {

		this.filterConfig = cfg;
		
		// 通过filterConfig初始化SerlveContext
		this.servletContext = filterConfig.getServletContext();
		
		// 用servlet日志
		servletContext.log(filterConfig.getFilterName()+" 初始化");
	}

}