使用Filter实现正文压缩

public class CompressionResponseStream extends ServletOutputStream {

    protected int compressionThreshold = 0;// 是否启用压缩的临界值
    protected byte[] buffer = null;// 临时容纳写入的数据的缓冲区
    protected int bufferCount = 0; // 缓冲区实际写入的数据量
    protected GZIPOutputStream gzipstream = null;
    protected boolean closed = false;// 对当前流对象是否处于关闭状态
    protected int length = -1;
    protected HttpServletResponse response = null;
    protected ServletOutputStream output = null;

    public CompressionResponseStream(HttpServletResponse response)
            throws IOException {
        super();
        closed = false;
        this.response = response;
        this.output = response.getOutputStream();
    }

    protected void setBuffer(int threshold) {
        compressionThreshold = threshold;
        buffer = new byte[compressionThreshold];
    }

    public void close() throws IOException {
        if (closed) {
            throw new IOException("This output stream has already been closed");
        }
        /*
         * 根据gzipstream是否为null，就可以判断写入的内容是否达到
         * 启用压缩的临界值，因为到达临界值时，write方法会自动创建gzipstream对象
         */
        if (gzipstream != null) {
            flushToGZip();
            gzipstream.close();
            gzipstream = null;
        } else {
            if (bufferCount > 0) {
                output.write(buffer, 0, bufferCount);
                bufferCount = 0;
            }
        }

        output.close();
        closed = true;
    }

    public void flush() throws IOException {
        if (closed) {
            throw new IOException("Can't flush a closed output stream");
        }
        if (gzipstream != null) {
            gzipstream.flush();
        }
    }

    /**
     * 将buffer缓冲区中的数据写入到gzipstream中
     *
     * @throws IOException
     */
    public void flushToGZip() throws IOException {
        if (bufferCount > 0) {
            writeToGZip(buffer, 0, bufferCount);
            bufferCount = 0;
        }
    }

    @Override
    public void write(int b) throws IOException {
        if (closed) {
            throw new IOException("Can't write to a closed output stream");
        }

        /*
         * 当写入的数据达到启用压缩的临界值时， 则先将buffer缓冲区的数据写入到gzipstream对象中
         */
        if (bufferCount >= buffer.length) {
            flushToGZip();
        }
        buffer[bufferCount++] = (byte) b;
    }

    public void write(byte b[]) throws IOException {
        write(b, 0, b.length);
    }

    public void write(byte[] b, int off, int len) throws IOException {
        if (closed) {
            throw new IOException("Can't write to a closed output stream");
        }
        if (len == 0) {
            return;
        }
        /*
         * 如果buffer缓冲区中剩余的空间能够容纳要写入的数据， 则先将这些数据写入到buffer缓冲区中
         */
        if (len <= (buffer.length - bufferCount)) {
            System.arraycopy(b, off, buffer, bufferCount, len);
            bufferCount += len;
            return;
        }
        /*
         * 如果buffer缓冲区剩余的空间不能容纳要写入的数据， 则先将buffer缓冲区的原有数据写入到gzipstream对象中
         */
        flushToGZip();

        /*
         * 腾空buffer缓冲区数据后，判断整个buffer缓冲区是否能够容纳要写入的数据， 如果能将这些数据写入到buffer缓冲区中
         */
        if (len <= (buffer.length - bufferCount)) {
            System.arraycopy(b, off, buffer, bufferCount, len);
            bufferCount += len;
            return;
        }
        /*
         * 如果整个buffer缓冲区的空间都不能容纳要写入的数据， 则直接将这些数据写入gzipstream中
         */
        writeToGZip(b, off, len);
    }

    /**
     * 将gzipstream对象中写入数据，如果第一次写入 则还需创建gzips实体对象
     *
     * @param b
     * @param off
     * @param len
     * @throws IOException
     */
    public void writeToGZip(byte b[], int off, int len) throws IOException {
        if (gzipstream == null) {
            response.addHeader("Content-Encoding", "gzip");
            gzipstream = new GZIPOutputStream(output);
        }
        gzipstream.write(b, off, len);
    }
}

 

public class CompressionServletResponseWrapper extends
		HttpServletResponseWrapper {

	protected HttpServletResponse origResponse = null;
	protected static final String info = "CompressionServletResponseWrapper";
	protected ServletOutputStream stream = null;
	protected PrintWriter writer = null;
	protected int threshold = 0;
	protected String contentType = null;

	public CompressionServletResponseWrapper(HttpServletResponse response) {
		super(response);
		origResponse = response;
	}

	public void setContentType(String contentType) {
		this.contentType = contentType;
		origResponse.setContentType(contentType);
	}

	public void setCompressionThreshold(int threshold) {
		this.threshold = threshold;
	}

	/**
	 * 创建自定义response对象包括输出流对象
	 * 
	 * @return
	 * @throws IOException
	 */
	public ServletOutputStream createOutputStream() throws IOException {
		CompressionResponseStream stream = new CompressionResponseStream(
				origResponse);
		stream.setBuffer(threshold);
		return stream;
	}

	/**
	 * 为了防止目标Servlet没有关闭输出流对象，Filter调用该方法 以便自动关闭输出流对象
	 */
	public void finishResponse() {
		try {
			if (writer != null) {
				writer.close();
			} else {
				if (stream != null) {
					stream.close();
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
	}

	/**
	 * 覆盖flushBuffer方法
	 */
	public void flushBuffer() throws IOException {
		((CompressionResponseStream) stream).flush();
	}

	/**
	 * 覆盖getOutputStream方法
	 */
	public ServletOutputStream getOutputStream() throws IOException {
		if (writer != null) {
			throw new IllegalStateException(
					"getWriter() has already been called for this resposne");
		}
		if (stream == null) {
			stream = createOutputStream();
		}
		return stream;
	}

	public PrintWriter getWriter() throws IOException {
		if (writer != null) {
			return writer;
		}
		if (stream != null) {
			throw new IllegalStateException(
					"getOutputStream() has already been called for this resposne");
		}
		stream = createOutputStream();

		String charEnc = origResponse.getCharacterEncoding();
		if (charEnc != null) {
			writer = new PrintWriter(new OutputStreamWriter(stream, charEnc));
		} else {
			writer = new PrintWriter(stream);
		}
		return writer;
	}

}

 

public class CompressionFilter implements Filter {
	private FilterConfig config = null;
	private int minThreshold = 128;
	protected int compressionThreshold;

	public void init(FilterConfig filterConfig) throws ServletException {
		this.config = filterConfig;
		if (filterConfig != null) {
			String str = filterConfig.getInitParameter("compressionThreshold");
			if (compressionThreshold != 0 & compressionThreshold < minThreshold) {
				compressionThreshold = minThreshold;
			} else {
				// 不对响应信息的实体内容进行压缩
				compressionThreshold = 0;
			}
		} else {
			compressionThreshold = 0;
		}

	}

	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		/*
		 * 不对响应信息的实体内容进行压缩
		 */
		if (compressionThreshold == 0) {
			chain.doFilter(request, response);
		}
		/*
		 * 检测客户端浏览器是否支持gzip数据压缩格式
		 */
		boolean supportCompression = false;
		if (request instanceof HttpServletRequest) {
			Enumeration<String> e = ((HttpServletRequest) request)
					.getHeaders("Accept-Encoding");
			while (e.hasMoreElements()) {
				String name = e.nextElement();
				if (name.indexOf("gzip") != -1) {
					supportCompression = true;
				}
			}
		}
		if (!supportCompression) {
			chain.doFilter(request, response);
			return;
		} else {
			if (response instanceof HttpServletResponse) {
				/*
				 * 创建自定义的Response对象
				 */
				CompressionServletResponseWrapper wrapperResponse = 
                         new CompressionServletResponseWrapper(
						(HttpServletResponse) response);
				wrapperResponse.setCompressionThreshold(compressionThreshold);
				try {
					chain.doFilter(request, wrapperResponse);
				} finally {
					wrapperResponse.finishResponse();
				}
			}
			return;
		}
	}

	public void destroy() {
		this.config = null;
	}

}