tomcat下关于压缩过滤器的代码。具体路径为：C:\apache-tomcat-6.0.35\webapps\examples\WEB-INF\classes\compressionFilters。代码为：
package compressionFilters;
import java.io.IOException;
import java.util.zip.GZIPOutputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
public class CompressionResponseStream extends ServletOutputStream {
//是否启用压缩的临界值
protected int compressThreshold = 0;
//临时容纳写入的数据缓冲区
protected byte[] buffer = null;
//缓冲区实际写入的数据量
protected int bufferCount = 0;
protected GZIPOutputStream gzipstream = null;
//当前流对象是否处于关闭状态
protected boolean closed = false;
protected int length = -1;
//用于返回数据的 Response对象
protected HttpServletResponse response = null;
protected ServletOutputStream output = null;
public CompressionResponseStream(HttpServletResponse response) throws IOException{
super();
closed = false;
this.response = response;
this.output = response.getOutputStream();
}
//设置启用压缩的临界值，并初始化输出缓冲区
public void setBuffer(int threshold){
compressThreshold = threshold;
buffer = new byte[threshold];
}
/**
* 关闭流对象
*/
public void close() throws IOException{
if(closed){
throw new IOException("This output stream has already been closed");
}
//如果当前启用的是压缩流，用压缩流刷新缓冲区
if(gzipstream != null){
flushToGZip();
gzipstream.close();
gzipstream = null;
}else{
//如果未开启压缩，则用response的默认输出流刷新缓冲区
if(bufferCount > 0){
output.write(buffer, 0, bufferCount);
bufferCount = 0;
}
}
}
/**
* 刷新输出缓冲区
*/
public void flush() throws IOException{
if(closed){
throw new IOException("Cannot flush a closed output stream");
}
if(gzipstream != null){
gzipstream.flush();
}
}
public void write(int b) throws IOException {
if(closed){
throw new IOException("Cannot write to a closed output stream");
}
//如果数据超出了缓冲区(启用压缩的临界值)，则启用压缩模式
if(bufferCount >= buffer.length){
flushToGZip();
}
//如果没有超出缓冲区，则将数据写入缓冲区
buffer[bufferCount++] = (byte)b;
}
public void write(byte[] b,int off,int len) throws IOException{
if(closed){
throw new IOException("Cannot write to a closed output stream");
}
if(len == 0){
return;
}
//如果缓冲区能容纳这些数据则写入缓冲区
if(len <= buffer.length - bufferCount){
System.arraycopy(b, off, buffer, bufferCount, len);
bufferCount += len;
return;
}
//如果缓冲区剩余空间不住足，则开启压缩流对象
flushToGZip();
//如果清空后的缓冲区能够容纳传送过来的数据，则将数据写入缓冲区
if(len <= buffer.length - bufferCount){
System.arraycopy(b, off, buffer, bufferCount, len);
bufferCount += len;
return;
}
//如果缓冲区不能容纳传送进来的数据，则直接将数据写入压缩流对象
writeToGZip(b, off, len);
}
//刷新压缩流对象的缓冲区
public void flushToGZip() throws IOException{
if(bufferCount > 0){
writeToGZip(buffer, 0, bufferCount);
bufferCount = 0;
}
}
public void writeToGZip(byte b[],int off,int len)throws IOException{
//如果压缩流对象为空，这里初始化它
if(gzipstream == null){
response.addHeader("Content-Encoding", "gzip");
gzipstream = new GZIPOutputStream(output);
}
//将数据听过压缩流对象输出到response的输出流
gzipstream.write(b,off,len);
}
public boolean closed(){
return closed;
}
}
package compressionFilters;
import java.io.IOException;
import java.util.zip.GZIPOutputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
public class CompressionResponseStream extends ServletOutputStream {
//是否启用压缩的临界值
protected int compressThreshold = 0;
//临时容纳写入的数据缓冲区
protected byte[] buffer = null;
//缓冲区实际写入的数据量
protected int bufferCount = 0;
protected GZIPOutputStream gzipstream = null;
//当前流对象是否处于关闭状态
protected boolean closed = false;
protected int length = -1;
//用于返回数据的 Response对象
protected HttpServletResponse response = null;
protected ServletOutputStream output = null;
public CompressionResponseStream(HttpServletResponse response) throws IOException{
super();
closed = false;
this.response = response;
this.output = response.getOutputStream();
}
//设置启用压缩的临界值，并初始化输出缓冲区
public void setBuffer(int threshold){
compressThreshold = threshold;
buffer = new byte[threshold];
}
/**
* 关闭流对象
*/
public void close() throws IOException{
if(closed){
throw new IOException("This output stream has already been closed");
}
//如果当前启用的是压缩流，用压缩流刷新缓冲区
if(gzipstream != null){
flushToGZip();
gzipstream.close();
gzipstream = null;
}else{
//如果未开启压缩，则用response的默认输出流刷新缓冲区
if(bufferCount > 0){
output.write(buffer, 0, bufferCount);
bufferCount = 0;
}
}
}
/**
* 刷新输出缓冲区
*/
public void flush() throws IOException{
if(closed){
throw new IOException("Cannot flush a closed output stream");
}
if(gzipstream != null){
gzipstream.flush();
}
}
public void write(int b) throws IOException {
if(closed){
throw new IOException("Cannot write to a closed output stream");
}
//如果数据超出了缓冲区(启用压缩的临界值)，则启用压缩模式
if(bufferCount >= buffer.length){
flushToGZip();
}
//如果没有超出缓冲区，则将数据写入缓冲区
buffer[bufferCount++] = (byte)b;
}
public void write(byte[] b,int off,int len) throws IOException{
if(closed){
throw new IOException("Cannot write to a closed output stream");
}
if(len == 0){
return;
}
//如果缓冲区能容纳这些数据则写入缓冲区
if(len <= buffer.length - bufferCount){
System.arraycopy(b, off, buffer, bufferCount, len);
bufferCount += len;
return;
}
//如果缓冲区剩余空间不住足，则开启压缩流对象
flushToGZip();
//如果清空后的缓冲区能够容纳传送过来的数据，则将数据写入缓冲区
if(len <= buffer.length - bufferCount){
System.arraycopy(b, off, buffer, bufferCount, len);
bufferCount += len;
return;
}
//如果缓冲区不能容纳传送进来的数据，则直接将数据写入压缩流对象
writeToGZip(b, off, len);
}
//刷新压缩流对象的缓冲区
public void flushToGZip() throws IOException{
if(bufferCount > 0){
writeToGZip(buffer, 0, bufferCount);
bufferCount = 0;
}
}
public void writeToGZip(byte b[],int off,int len)throws IOException{
//如果压缩流对象为空，这里初始化它
if(gzipstream == null){
response.addHeader("Content-Encoding", "gzip");
gzipstream = new GZIPOutputStream(output);
}
//将数据听过压缩流对象输出到response的输出流
gzipstream.write(b,off,len);
}
public boolean closed(){
return closed;
}
}
package compressionFilters;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
public class CompressionServletResponseWrapper extends
HttpServletResponseWrapper {
/**
* 原始的response对象
*/
protected HttpServletResponse origResponse = null;
protected static final String info = "CompressionServletResponseWrapper";
/**
* response对象的输出流
*/
protected ServletOutputStream stream = null;
/**
* response
*/
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);
}
/**
* 设置启用压缩的临界值
* @param threshold 临界值
*/
public void setCompressionThreshold(int threshold){
this.threshold = threshold;
}
public ServletOutputStream createOutputStream() throws IOException{
CompressionResponseStream stream = new CompressionResponseStream(origResponse);
stream.setBuffer(threshold);
return stream;
}
//关闭输出对象
public void finishResponse(){
try {
if(writer != null){
writer.close();
}else{
if(stream != null){
stream.close();
}
}
} catch (IOException e) {
}
}
public void flushBuffer() throws IOException{
((CompressionResponseStream)stream).flush();
}
public ServletOutputStream getOutputStream() throws IOException{
//如果字符流打开，则抛出异常
if(writer != null)
throw new IllegalStateException("getWriter() has already been called for this response");
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 response");
stream = createOutputStream();
String charEnc = origResponse.getCharacterEncoding();
if(charEnc != null){
writer = new PrintWriter(new OutputStreamWriter(stream,charEnc));
}else{
writer = new PrintWriter(stream);
}
return writer;
}
private static String getCharsetFromContentType(String type){
if(type == null){
return null;
}
int semi = type.indexOf(":");
if(semi == -1){
return null;
}
String afterSemi = type.substring(semi + 1);
int charsetLocation = afterSemi.indexOf("charset=");
if(charsetLocation == -1){
return null;
}else{
String afterCharset = afterSemi.substring(charsetLocation + 8);
String encoding = afterCharset.trim();
return encoding;
}
}
}
