gzip压缩js和html文件java源码

作者：张颋 版本：V1.0 最后更新日期：2013/4/25  http://idata.blog.51cto.com

静态文件压缩是十年前的技术，在视频、图片占据带宽主流的今天对很多网站已不再重要。但是，对于数据服务而言，静态文件压缩技术依然可以摆在显著位置值得一提，甚至可以说比十年前更加重要了。究其原因根本上是因为javascript和html5。在数据服务领域，笔者相信基于javascript+html5的数据可视化技术会成为未来的主流，这正是压缩技术的用武之地。

引入第三方jar包实现压缩是可行的，但是这是以牺牲灵活性和简单性为代价的。在技术进步竞争激烈的今天，关键技术成为黑盒就好比与人赛跑的您身上又多了一道枷锁。下面的代码已在生产环境证实可行，期待您的反馈：

web.xml

1. <!-- ResponseFilter must be executed as the last one of the filter chain.--> 
2. <filter> 
3.     <filter-name>ResponseFilter</filter-name> 
4.     <filter-class>com.datawebservice.ResponseFilter</filter-class> 
5. </filter> 
6.    <filter-mapping>     
7.         <filter-name>ResponseFilter</filter-name> 
8.         <url-pattern>/*</url-pattern>     
9.    </filter-mapping> 

ResponseFilter.java

1. package com.datawebservice;  
2.  
3. import java.io.ByteArrayOutputStream;  
4. import java.io.IOException;  
5. import java.util.zip.GZIPOutputStream;  
6.  
7. import javax.servlet.Filter;  
8. import javax.servlet.FilterChain;  
9. import javax.servlet.FilterConfig;  
10. import javax.servlet.ServletOutputStream;  
11. import javax.servlet.ServletException;  
12. import javax.servlet.ServletRequest;  
13. import javax.servlet.ServletResponse;  
14. import javax.servlet.http.HttpServletRequest;  
15. import javax.servlet.http.HttpServletResponse;  
16.  
17. public class ResponseFilter implements Filter {  
18.         public void init(FilterConfig filterConfig) throws ServletException {}  
19.         public void doFilter(ServletRequest request, ServletResponse response,  
20.                         FilterChain filterChain) throws IOException, ServletException {  
21.                 HttpServletRequest httpServletRequest = (HttpServletRequest) request;  
22.                 HttpServletResponse httpServletResponse = (HttpServletResponse) response;  
23.                   
24.                 String requestURI = httpServletRequest.getRequestURI();  
25.                 if (requestURI.endsWith("html")|| requestURI.endsWith("js"))  
26.                 {  
27.                     ResponseWrapper wrapper = new ResponseWrapper(httpServletResponse);  
28.                     filterChain.doFilter(request, wrapper);  
29.                     String resultText = wrapper.getResultText();                      
30.                     wrapper.close();  
31.           
32.                     //压缩  
33.                     ByteArrayOutputStream os = new ByteArrayOutputStream();     
34.                     GZIPOutputStream gzip = new GZIPOutputStream(os);     
35.                     gzip.write(resultText.getBytes("UTF-8"));     
36.                     gzip.close();     
37.                        
38.                      //输出  
39.                      byte[] bytes = os.toByteArray();              
40.                      httpServletResponse.setContentType("text/html; charset=UTF-8");   
41.                      httpServletResponse.addHeader("Content-Length",Integer.toString(bytes.length));   
42.                      httpServletResponse.addHeader("Content-Encoding", "gzip");  
43.                      ServletOutputStream output = httpServletResponse.getOutputStream();  
44.                      output.write(bytes);  
45.                      output.flush();  
46.                      output.close();  
47.                 }else {  
48.                     filterChain.doFilter(httpServletRequest, httpServletResponse);  
49.                 }  
50.         }  
51.         public void destroy() {}  
52. } 

ResponseWrapper.java

1. package com.datawebservice;  
2.  
3. import java.io.ByteArrayOutputStream;  
4. import java.io.IOException;  
5. import java.io.PrintWriter;  
6. import java.io.Writer;  
7.  
8. import javax.servlet.ServletOutputStream;  
9. import javax.servlet.http.HttpServletResponse;  
10. import javax.servlet.http.HttpServletResponseWrapper;  
11.  
12. public class ResponseWrapper extends HttpServletResponseWrapper {  
13.     private String responseText="";  
14.     private ByteArrayOutputStream responseStream=null;  
15.       
16.     public ResponseWrapper(HttpServletResponse response) {  
17.         super(response);  
18.         responseStream = new ByteArrayOutputStream();  
19.     }  
20.  
21.     public String getResultText() {  
22.         if(responseText.equals("")){  
23.             try{  
24.                 responseText= new String(responseStream.toByteArray(),"UTF-8");  
25.             }catch(Exception e){  
26.                 System.out.println("getResultText exception");  
27.                 System.out.println(e.getMessage());  
28.             }  
29.         }  
30.         return responseText;  
31.     }  
32.  
33.     public byte[] getStreamBytes() {  
34.         return responseStream.toByteArray();  
35.     }  
36.       
37.     public void close(){  
38.         try{  
39.           responseStream.close();  
40.         }catch(Exception e){  
41.             System.out.println("ResponseWrapper.responseStream.close() throw exception");  
42.             System.out.println(e.getMessage());  
43.         }  
44.     }  
45.  
46.     public ServletOutputStream getOutputStream() throws IOException {  
47.         return (new MyServletOutputStream());  
48.     }  
49.        
50.     public PrintWriter getWriter() throws IOException {  
51.         return (new MyPrintWriter(new PrintWriter(new MyServletOutputStream())));  
52.     }  
53.       
54.       class MyServletOutputStream extends ServletOutputStream{  
55.           MyServletOutputStream(){  
56.           }  
57.           public void close() throws IOException {  
58.               super.close();        
59.           }  
60.           public void flush() throws IOException {  
61.                 super.flush();  
62.           }  
63.           public void write(int b) throws IOException {  
64.                 write((byte)b);  
65.           }             
66.           public void write(byte b[]) throws IOException {  
67.               write(b, 0, b.length);  
68.           }  
69.           public void write(byte b[], int off, int len) throws IOException {  
70.              responseStream.write(b, off, len);                
71.           }//end write            
72.       }//end class MyServletOutputStream  
73.  
74.       class MyPrintWriter extends PrintWriter{  
75.           MyPrintWriter(Writer out){  
76.               super(out);  
77.           }  
78.           public void flush(){  
79.           }  
80.           public void close(){  
81.           }  
82.           public void write(int b) {  
83.               char[] cb = new char[1];  
84.               cb[0]=(char)b;  
85.               write(cb);  
86.           }  
87.           public void write(char[] chars) {  
88.               write(chars,0,chars.length);  
89.           }         
90.           public void write(String s){  
91.               responseText=responseText+s;              
92.           }  
93.           public void write(char buf[],int off,int len){  
94.               responseText=responseText+String.copyValueOf(buf, off, len);  
95.           }  
96.           public void write(String s,int off,int len){  
97.               responseText=responseText+s.substring(off, off+len);  
98.           }           
99.       }  
100. } 

补充说明：我使用了内部类来简化代码。如果您不乏冒险精神，这份代码也可用于压缩jsp。

 本文转自 hexiaini235 51CTO博客，原文链接：http://blog.51cto.com/idata/1186176，如需转载请自行联系原作者