filter实现过滤压缩指定的请求的操作 - JAVA

filter过滤器的创建
package filter;

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

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

public class GzipFilter implements Filter {
	// 这是一个用来将响应出去的数据进行压缩的处理过滤的类

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

	@Override
	public void doFilter(ServletRequest req, ServletResponse res,
			FilterChain chain) throws IOException, ServletException {

		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
		
		System.out.println("doFilter被执行在创建增强器MyRresponse之前.................");

		// 对response响应的对象进行增强
		MyRresponse myRresponse=new MyRresponse(response);
		//执行目标方法带着增强后的对象
		chain.doFilter(request, myRresponse);
		
		//获取response对象中的流的原大小
		byte resouceByte[]=myRresponse.getBuffer();
		
		System.out.println("这是原数据的大小==========="+resouceByte.length);
		
		
		//这是压缩之后的数据对象
		ByteArrayOutputStream out=new ByteArrayOutputStream();
		//创建压缩的流对象,接收字节输出流
		GZIPOutputStream gzipOutputStream=new GZIPOutputStream(out);
		
		//压缩流对象,并将数据写入压缩输出流对象
		gzipOutputStream.write(resouceByte);
		//关闭数据流
		gzipOutputStream.close();
		
		//得到压缩后的数据
		byte gzipByte[]=out.toByteArray();
		
		System.out.println("这是压缩后的数据大小==========="+gzipByte.length);
		
		//高速




浏览器以什么样的方式进行解析
		//内容的编码方式
		response.setHeader("Content-Encoding", "gzip");
		//内容大小
		response.setContentLength(gzipByte.length);
		//将内容写入
		response.getOutputStream().write(gzipByte);
	}

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

	// 这是对服务器输出流的增强
	class MyServletOutputStream extends ServletOutputStream {

		// 定义字节的输出流对象
		private ByteArrayOutputStream baos;

		public MyServletOutputStream(ByteArrayOutputStream baos) {
			super();
			this.baos = baos;
		}

		// 重写输输出流方法
		@Override
		public void write(int b) throws IOException {
			// TODO Auto-generated method stub
			baos.write(b);
		}

	}

	// 这是对响应的数据进行增强的类
	// 1.首先看需要被增强对象继承了什么接口或父类，编写一个类也去继承这些接口或父类
	class MyRresponse extends HttpServletResponseWrapper {
		// 缓冲区输出流的定义
		private ByteArrayOutputStream baos = new ByteArrayOutputStream();

		// 2.在类中定义一个变量,变量类型即需要增强对象的类型
		private HttpServletResponse response;

		// 创建文本输出流
		private PrintWriter pw;

		// 3.在类中定义一个构造函数，接收需增强的对象
		public MyRresponse(HttpServletResponse response) {
			super(response);
			this.response = response;
		}

		// 4.覆盖被增强的方法,编写增强的功能
		@Override
		public ServletOutputStream getOutputStream() throws IOException {
			return new MyServletOutputStream(baos);
		}

		@Override
		public PrintWriter getWriter() throws IOException {
			pw = new PrintWriter
filter实现过滤压缩指定的请求的操作(一)
