压缩字符流和字节流和全站压缩过滤器

    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();　　　　//字符流
        OutputStreamWriter osw = new OutputStreamWriter(bos);
        PrintWriter pw = new PrintWriter(osw);
        pw.write("helloworld");
        pw.flush();
        System.out.println(bos.toByteArray().length);

        /*
         * String s = "abcdefasdfasdfasdfasdfasdfasfd";
         * System.out.println("未压缩前:" + s.getBytes().length);
         * 
         * ByteArrayOutputStream baos = new ByteArrayOutputStream(); //
         * 创建一个数组输出流.
         * 
         * GZIPOutputStream gps = new GZIPOutputStream(baos);//
         * 向baos字节数组流写入信息时，进行压缩
         * 
         * gps.write(s.getBytes());
         * 
         * System.out.println("压缩后:" + baos.toByteArray().length);
         * 
         * gps.close();
         * 
         * byte[] b = new byte[1024]; ByteArrayInputStream bis = new
         * ByteArrayInputStream(baos.toByteArray());
         * 
         * GZIPInputStream gis = new GZIPInputStream(bis);
         * 
         * int len = gis.read(b);// 将压缩数组中的信息解压读到b数组中。
         * 
         * System.out.println(new String(b, 0, len));
         * 
         * gis.close();
         */
    }

全站压缩过滤器

package cn.itcast.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.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
//全站压缩过滤器
public class GzipFilter implements Filter {

    public void destroy() {

    }

    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest)req;
        HttpServletResponse response = (HttpServletResponse)resp;
        GzipHttpServletResponse gresponse = new GzipHttpServletResponse(response);
        chain.doFilter(request, gresponse);//放行
        //压缩代码写在此处
        //找一个内存缓冲字节流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //把数据压缩到缓冲字节流流中
        GZIPOutputStream gout = new GZIPOutputStream(baos);
        //取出数据：压缩后的
        byte b[] = gresponse.getOldBytes();//原始字节
        System.out.println("原有数据大小："+b.length);
        
        //因为参数是byte b[]数组，所以会调用父类的write(byte[])方法，调用到最后 是write(int b)方法，
        //而在父类中声明为抽象的，但是MyServletOutputStream实现了，并且在GzipHttpServletResponse对象中
        //在doFilter()会被调用getOutputStream()函数进行操作进行写入输出流
        gout.write(b);            
        gout.close();//保证所有的数据都进入内存缓存流
        
        //取出压缩后的数据
        b = baos.toByteArray();
        System.out.println("压缩后的数据大小："+b.length);
        //输出前一定要告知客户端压缩方式
        response.setHeader("Content-Encoding", "gzip");
        response.setContentLength(b.length);//告知客户端正文的大小
        //用服务器的响应对象输出
        ServletOutputStream out = response.getOutputStream();
        out.write(b);
    }

    public void init(FilterConfig filterConfig) throws ServletException {

    }

}
class GzipHttpServletResponse extends HttpServletResponseWrapper{
    private ByteArrayOutputStream baos = new ByteArrayOutputStream();//用于获取压缩前要输出的数据
    private PrintWriter pw;
    public GzipHttpServletResponse(HttpServletResponse response){
        super(response);
    }
    //把原始数据封装到一个缓冲流中
    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return new MyServletOutputStream(baos);
    }
    
    //字符流：把原始数据封装到一个缓冲流中
    @Override
    public PrintWriter getWriter() throws IOException {            //改写父方法，自己实现PrintWriter
        pw = new PrintWriter(new OutputStreamWriter(baos, super.getCharacterEncoding()));//字符流转成字节流编码会丢失
        return pw;
    }
    //返回baos中的缓存数据：原始
    public byte[] getOldBytes(){
        try {
            if(pw!=null){
                pw.close();
            }
            baos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return baos.toByteArray();
    }
    
}
class MyServletOutputStream extends ServletOutputStream{
    private ByteArrayOutputStream baos;
    public MyServletOutputStream(ByteArrayOutputStream baos){
        this.baos = baos;
    }
    @Override
    public void write(int b) throws IOException {
        baos.write(b);
    }
}

 如果调用response.getWriter()和response.getOutputStream()会抛异常，所以不能在代码中都调用，以上方法调用的getOutputStream和getWriter自己覆写了，没有调用servlet本身提供的，所以没有报异常。

把字节流和字符流全都放入ByteArrayOutputStream 缓冲中了，一并处理了。