url:http://hi.baidu.com/xhftx/blog/item/fbc11d3012648711ebc4af59.html 
关键词：JSP,Filter,Servlet,GZIP 
现在主流浏览器都是支持gzip的。服务器压缩网页后进行传输，可减少传输数据的大小使用户感觉访问速度更快。当然，压缩也会消耗一部分服务器处理时间。 
用Filter实现对返回信息的压缩，代码参考Tomcat examples里面的compressionFilters： 
GZipStream.java

  1. import java.io.IOException;
  2. import java.io.OutputStream;
  3. import java.util.zip.GZIPOutputStream;
  4. import javax.servlet.ServletOutputStream;
  5. public class GZipStream extends ServletOutputStream {
  6. private GZIPOutputStream zipStream;
  7. public GZipStream(OutputStream out) throws IOException {
  8. zipStream = new GZIPOutputStream(out);
  9. }
  10. @Override
  11. public void flush() throws IOException {
  12. zipStream.flush();
  13. }
  14. @Override
  15. public void write(byte[] b, int off, int len) throws IOException {
  16. zipStream.write(b, off, len);
  17. }
  18. @Override
  19. public void write(byte[] b) throws IOException {
  20. zipStream.write(b);
  21. }
  22. @Override
  23. public void write(int arg0) throws IOException {
  24. zipStream.write(arg0);
  25. }
  26. public void finish() throws IOException {
  27. zipStream.finish();
  28. }
  29. public void close() throws IOException {
  30. zipStream.close();
  31. }
  32. }

GZipResponse.java

  1. import java.io.IOException;
  2. import java.io.OutputStreamWriter;
  3. import java.io.PrintWriter;
  4. import javax.servlet.ServletOutputStream;
  5. import javax.servlet.http.HttpServletResponse;
  6. import javax.servlet.http.HttpServletResponseWrapper;
  7. public class GZipResponse extends HttpServletResponseWrapper {
  8. private GZipStream stream;
  9. private PrintWriter writer;
  10. public GZipResponse(HttpServletResponse response) throws IOException{
  11. super(response);
  12. stream=new GZipStream(response.getOutputStream());
  13. }
  14. @Override
  15. public ServletOutputStream getOutputStream() throws IOException {
  16. return stream;
  17. }
  18. @Override
  19. public PrintWriter getWriter() throws IOException {
  20. if (writer == null) {
  21. writer = new PrintWriter(new OutputStreamWriter(
  22. getOutputStream(), getCharacterEncoding()));
  23. }
  24. return writer;
  25. }
  26. public void flush() throws IOException {
  27. if (writer != null) {
  28. writer.flush();
  29. }
  30. stream.finish();
  31. }
  32. }

GZipFilter.java

  1. import java.io.IOException;
  2. import javax.servlet.Filter;
  3. import javax.servlet.FilterChain;
  4. import javax.servlet.FilterConfig;
  5. import javax.servlet.ServletException;
  6. import javax.servlet.ServletRequest;
  7. import javax.servlet.ServletResponse;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. public class GZipFilter implements Filter {
  11. public void destroy() {
  12. }
  13. public void init(FilterConfig fConfig) throws ServletException {
  14. }
  15. public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  16. throws IOException, ServletException {
  17. HttpServletRequest req=(HttpServletRequest)request;
  18. HttpServletResponse res=(HttpServletResponse)response;
  19. if(isGZipEncoding(req)){
  20. GZipResponse zipResponse=new GZipResponse(res);
  21. res.setHeader("Content-Encoding", "gzip");
  22. chain.doFilter(request, zipResponse);
  23. zipResponse.flush();
  24. } else {
  25. chain.doFilter(request, response);
  26. }
  27. }
  28. /**
  29. * 判断浏览器是否支持GZIP
  30. * @param request
  31. * @return
  32. */
  33. private static boolean isGZipEncoding(HttpServletRequest request){
  34. boolean flag=false;
  35. String encoding=request.getHeader("Accept-Encoding");
  36. ){
  37. flag=true;
  38. }
  39. return flag;
  40. }
  41. }

web.xml配置

  1. <filter>
  2. <description>
  3. </description>
  4. <display-name>GZipFilter</display-name>
  5. <filter-name>GZipFilter</filter-name>
  6. <filter-class>GZipFilter</filter-class>
  7. </filter>
  8. <filter-mapping>
  9. <filter-name>GZipFilter</filter-name>
  10. <url-pattern>/*</url-pattern>
  11. </filter-mapping>

这个配置是对所有的资源都进行压缩传输，对于图片，flash等本身已经压缩过的文件就没有必要再进行压缩了，可以根据自己的需要更改<url-pattern>已提高WEB访问速度。

tomcat自带源码剖析: 
url:http://hi.baidu.com/springfieldx/blog/item/9faa88dfd5760414495403b6.html 
在响应请求的时候对response进行封装，替换他的输出流为 GZipOutputStream 压缩输出流

  1. package compressionFilters;
  2. import java.io.IOException;
  3. import java.util.zip.GZIPOutputStream;
  4. import javax.servlet.ServletOutputStream;
  5. import javax.servlet.http.HttpServletResponse;
  6. public class CompressionResponseStream extends ServletOutputStream {
  7. //是否启用压缩的临界值
  8. ;
  9. //临时容纳写入的数据缓冲区
  10. protected byte[] buffer = null;
  11. //缓冲区实际写入的数据量
  12. ;
  13. protected GZIPOutputStream gzipstream = null;
  14. //当前流对象是否处于关闭状态
  15. protected boolean closed = false;
  16. ;
  17. //用于返回数据的 Response对象
  18. protected HttpServletResponse response = null;
  19. protected ServletOutputStream output = null;
  20. public CompressionResponseStream(HttpServletResponse response) throws IOException{
  21. super();
  22. closed = false;
  23. this.response = response;
  24. this.output = response.getOutputStream();
  25. }
  26. //设置启用压缩的临界值，并初始化输出缓冲区
  27. public void setBuffer(int threshold){
  28. compressThreshold = threshold;
  29. buffer = new byte[threshold];
  30. }
  31. /**
  32. * 关闭流对象
  33. */
  34. public void close() throws IOException{
  35. if(closed){
  36. throw new IOException("This output stream has already been closed");
  37. }
  38. //如果当前启用的是压缩流，用压缩流刷新缓冲区
  39. if(gzipstream != null){
  40. flushToGZip();
  41. gzipstream.close();
  42. gzipstream = null;
  43. }else{
  44. //如果未开启压缩，则用response的默认输出流刷新缓冲区
  45. ){
  46. , bufferCount);
  47. ;
  48. }
  49. }
  50. }
  51. /**
  52. * 刷新输出缓冲区
  53. */
  54. public void flush() throws IOException{
  55. if(closed){
  56. throw new IOException("Cannot flush a closed output stream");
  57. }
  58. if(gzipstream != null){
  59. gzipstream.flush();
  60. }
  61. }
  62. public void write(int b) throws IOException {
  63. if(closed){
  64. throw new IOException("Cannot write to a closed output stream");
  65. }
  66. //如果数据超出了缓冲区(启用压缩的临界值)，则启用压缩模式
  67. if(bufferCount >= buffer.length){
  68. flushToGZip();
  69. }
  70. //如果没有超出缓冲区，则将数据写入缓冲区
  71. buffer[bufferCount++] = (byte)b;
  72. }
  73. public void write(byte[] b,int off,int len) throws IOException{
  74. if(closed){
  75. throw new IOException("Cannot write to a closed output stream");
  76. }
  77. ){
  78. return;
  79. }
  80. //如果缓冲区能容纳这些数据则写入缓冲区
  81. if(len <= buffer.length - bufferCount){
  82. System.arraycopy(b, off, buffer, bufferCount, len);
  83. bufferCount += len;
  84. return;
  85. }
  86. //如果缓冲区剩余空间不住足，则开启压缩流对象
  87. flushToGZip();
  88. //如果清空后的缓冲区能够容纳传送过来的数据，则将数据写入缓冲区
  89. if(len <= buffer.length - bufferCount){
  90. System.arraycopy(b, off, buffer, bufferCount, len);
  91. bufferCount += len;
  92. return;
  93. }
  94. //如果缓冲区不能容纳传送进来的数据，则直接将数据写入压缩流对象
  95. writeToGZip(b, off, len);
  96. }
  97. //刷新压缩流对象的缓冲区
  98. public void flushToGZip() throws IOException{
  99. ){
  100. , bufferCount);
  101. ;
  102. }
  103. }
  104. public void writeToGZip(byte b[],int off,int len)throws IOException{
  105. //如果压缩流对象为空，这里初始化它
  106. if(gzipstream == null){
  107. response.addHeader("Content-Encoding", "gzip");
  108. gzipstream = new GZIPOutputStream(output);
  109. }
  110. //将数据听过压缩流对象输出到response的输出流
  111. gzipstream.write(b,off,len);
  112. }
  113. public boolean closed(){
  114. return closed;
  115. }
  116. }
  117. package compressionFilters;
  118. import java.io.IOException;
  119. import java.util.zip.GZIPOutputStream;
  120. import javax.servlet.ServletOutputStream;
  121. import javax.servlet.http.HttpServletResponse;
  122. public class CompressionResponseStream extends ServletOutputStream {
  123. //是否启用压缩的临界值
  124. ;
  125. //临时容纳写入的数据缓冲区
  126. protected byte[] buffer = null;
  127. //缓冲区实际写入的数据量
  128. ;
  129. protected GZIPOutputStream gzipstream = null;
  130. //当前流对象是否处于关闭状态
  131. protected boolean closed = false;
  132. ;
  133. //用于返回数据的 Response对象
  134. protected HttpServletResponse response = null;
  135. protected ServletOutputStream output = null;
  136. public CompressionResponseStream(HttpServletResponse response) throws IOException{
  137. super();
  138. closed = false;
  139. this.response = response;
  140. this.output = response.getOutputStream();
  141. }
  142. //设置启用压缩的临界值，并初始化输出缓冲区
  143. public void setBuffer(int threshold){
  144. compressThreshold = threshold;
  145. buffer = new byte[threshold];
  146. }
  147. /**
  148. * 关闭流对象
  149. */
  150. public void close() throws IOException{
  151. if(closed){
  152. throw new IOException("This output stream has already been closed");
  153. }
  154. //如果当前启用的是压缩流，用压缩流刷新缓冲区
  155. if(gzipstream != null){
  156. flushToGZip();
  157. gzipstream.close();
  158. gzipstream = null;
  159. }else{
  160. //如果未开启压缩，则用response的默认输出流刷新缓冲区
  161. ){
  162. , bufferCount);
  163. ;
  164. }
  165. }
  166. }
  167. /**
  168. * 刷新输出缓冲区
  169. */
  170. public void flush() throws IOException{
  171. if(closed){
  172. throw new IOException("Cannot flush a closed output stream");
  173. }
  174. if(gzipstream != null){
  175. gzipstream.flush();
  176. }
  177. }
  178. public void write(int b) throws IOException {
  179. if(closed){
  180. throw new IOException("Cannot write to a closed output stream");
  181. }
  182. //如果数据超出了缓冲区(启用压缩的临界值)，则启用压缩模式
  183. if(bufferCount >= buffer.length){
  184. flushToGZip();
  185. }
  186. //如果没有超出缓冲区，则将数据写入缓冲区
  187. buffer[bufferCount++] = (byte)b;
  188. }
  189. public void write(byte[] b,int off,int len) throws IOException{
  190. if(closed){
  191. throw new IOException("Cannot write to a closed output stream");
  192. }
  193. ){
  194. return;
  195. }
  196. //如果缓冲区能容纳这些数据则写入缓冲区
  197. if(len <= buffer.length - bufferCount){
  198. System.arraycopy(b, off, buffer, bufferCount, len);
  199. bufferCount += len;
  200. return;
  201. }
  202. //如果缓冲区剩余空间不住足，则开启压缩流对象
  203. flushToGZip();
  204. //如果清空后的缓冲区能够容纳传送过来的数据，则将数据写入缓冲区
  205. if(len <= buffer.length - bufferCount){
  206. System.arraycopy(b, off, buffer, bufferCount, len);
  207. bufferCount += len;
  208. return;
  209. }
  210. //如果缓冲区不能容纳传送进来的数据，则直接将数据写入压缩流对象
  211. writeToGZip(b, off, len);
  212. }
  213. //刷新压缩流对象的缓冲区
  214. public void flushToGZip() throws IOException{
  215. ){
  216. , bufferCount);
  217. ;
  218. }
  219. }
  220. public void writeToGZip(byte b[],int off,int len)throws IOException{
  221. //如果压缩流对象为空，这里初始化它
  222. if(gzipstream == null){
  223. response.addHeader("Content-Encoding", "gzip");
  224. gzipstream = new GZIPOutputStream(output);
  225. }
  226. //将数据听过压缩流对象输出到response的输出流
  227. gzipstream.write(b,off,len);
  228. }
  229. public boolean closed(){
  230. return closed;
  231. }
  232. }
  233. package compressionFilters;
  234. import java.io.IOException;
  235. import java.io.OutputStream;
  236. import java.io.OutputStreamWriter;
  237. import java.io.PrintWriter;
  238. import javax.servlet.ServletOutputStream;
  239. import javax.servlet.http.HttpServletResponse;
  240. import javax.servlet.http.HttpServletResponseWrapper;
  241. public class CompressionServletResponseWrapper extends
  242. HttpServletResponseWrapper {
  243. /**
  244. * 原始的response对象
  245. */
  246. protected HttpServletResponse origResponse = null;
  247. protected static final String info = "CompressionServletResponseWrapper";
  248. /**
  249. * response对象的输出流
  250. */
  251. protected ServletOutputStream stream = null;
  252. /**
  253. * response
  254. */
  255. protected PrintWriter writer = null;
  256. ;
  257. protected String contentType = null;
  258. public CompressionServletResponseWrapper(HttpServletResponse response) {
  259. super(response);
  260. origResponse = response;
  261. }
  262. /**
  263. * 设置实体类型
  264. */
  265. public void setContentType(String contentType){
  266. this.contentType = contentType;
  267. origResponse.setContentType(contentType);
  268. }
  269. /**
  270. * 设置启用压缩的临界值
  271. * @param threshold 临界值
  272. */
  273. public void setCompressionThreshold(int threshold){
  274. this.threshold = threshold;
  275. }
  276. public ServletOutputStream createOutputStream() throws IOException{
  277. CompressionResponseStream stream = new CompressionResponseStream(origResponse);
  278. stream.setBuffer(threshold);
  279. return stream;
  280. }
  281. //关闭输出对象
  282. public void finishResponse(){
  283. try {
  284. if(writer != null){
  285. writer.close();
  286. }else{
  287. if(stream != null){
  288. stream.close();
  289. }
  290. }
  291. } catch (IOException e) {
  292. }
  293. }
  294. public void flushBuffer() throws IOException{
  295. ((CompressionResponseStream)stream).flush();
  296. }
  297. public ServletOutputStream getOutputStream() throws IOException{
  298. //如果字符流打开，则抛出异常
  299. if(writer != null)
  300. throw new IllegalStateException("getWriter() has already been called for this response");
  301. if(stream == null) stream = createOutputStream();
  302. return stream;
  303. }
  304. public PrintWriter getWriter() throws IOException{
  305. if(writer != null){
  306. return (writer);
  307. }
  308. if(stream != null)
  309. throw new IllegalStateException("getOutputStream() has already been called for this response");
  310. stream = createOutputStream();
  311. String charEnc = origResponse.getCharacterEncoding();
  312. if(charEnc != null){
  313. writer = new PrintWriter(new OutputStreamWriter(stream,charEnc));
  314. }else{
  315. writer = new PrintWriter(stream);
  316. }
  317. return writer;
  318. }
  319. private static String getCharsetFromContentType(String type){
  320. if(type == null){
  321. return null;
  322. }
  323. int semi = type.indexOf(":");
  324. ){
  325. return null;
  326. }
  327. );
  328. int charsetLocation = afterSemi.indexOf("charset=");
  329. ){
  330. return null;
  331. }else{
  332. );
  333. String encoding = afterCharset.trim();
  334. return encoding;
  335. }
  336. }
  337. }

reference: 
1.http://onjava.com/pub/a/onjava/2003/11/19/filters.html 
2.java filter 过滤机制详解 http://hi.baidu.com/linfengtingyu1/blog/item/e14a1af20de0505b352accda.html 
3.java.servlet.Filter的应用http://yuhaining.spaces.live.com/Blog/cns!5BBD70DF0F6F839C!307.entry 
4.使用filter机制来GZIP压缩网页http://www.javamilk.cn/article/notes/624.htm

JSP Filter,GZIP压缩响应流的更多相关文章

  1. thttpd增加gzip压缩响应报文体功能，以减少传输数据量

    thttpd thttpd是一个非常小巧的轻量级web server,它非常非常简单,仅仅提供了HTTP/1.1和简单的CGI支持,在其官方网站上有一个与其他web server(如Apache, Z ...

  2. Android GZIP压缩IO流，优化APP数据传输（一）

    我是小搬运工,今天讲解流的压缩传输 在我们安卓开发中,通常伴随着大量的数据传输,在此,楼主给出一个简单的压缩流的数据进行操作. public void GZIPCpf(String path) { / ...

  3. Springboot 之 Filter 实现超大响应 JSON 数据压缩

    简介 项目中,请求时发送超大 json 数据外:响应时也有可能返回超大 json数据.上一篇实现了请求数据的 gzip 压缩.本篇通过 filter 实现对响应 json 数据的压缩. 先了解一下以下 ...

  4. 使用filter过滤GZIP压缩（二）

    在代码之前,讲一下用filter实现GZIP压缩的原理: 因为GZIP压缩之后,是从服务器端传输到浏览器端,从servlet到浏览器(从jsp到浏览器),其实是response带回内容,所以我们要在f ...

  5. Java Web 减少网络 IO、静态资源磁盘 IO 有效的办法--响应使用 GZIP( 压缩http请求与响应gzip压缩)

    (转载http://blog.csdn.net/hylclxy/article/details/7779662) 出于节约流量考虑, 客户端在向服务端发送request的时候对post数据进行gzip ...

  6. Springboot 之 Filter 实现 Gzip 压缩超大 json 对象

    简介 在项目中,存在传递超大 json 数据的场景.直接传输超大 json 数据的话,有以下两个弊端 占用网络带宽,而有些云产品就是按照带宽来计费的,间接浪费了钱 传输数据大导致网络传输耗时较长 为了 ...

  7. GZIP压缩优化

    使用gzip优化web应用(filter实现) 相关知识: gzip是http协议中使用的一种加密算法,客户端向web服务器端发出了请求后,通常情况下服务器端会将页面文件和其他资源,返回到客户端,客户 ...

  8. 过滤器-->GZIP压缩

    1.创建一个 可以使用GZIPOutputStream 压缩的流 package com.zh.yasuo2; import java.io.IOException; import java.util ...

  9. GZIP压缩提高网络传输效率

    [spring]通过GZIP压缩提高网络传输效率(可以实现任何资源的gzip压缩.包括AJAX) gzip是http协议中使用的一种加密算法,客户端向web服务器端发出了请求后,通常情况下服务器端会将 ...

随机推荐

  1. GCD 多线程 初探

    GCD编程的核心就是dispatch队列,dispatch block的执行最终都会放进某个队列中去进行,它类似NSOperationQueue但更复杂也更强大,并且可以嵌套使用.所以说,结合bloc ...

  2. 使用epel源安装依赖包时报错

    [root@test_web1 ~]#  rpm -ivh http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch. ...

  3. include<stdio.h> 和include<iostream.h>的区别

    stdio 是C标准库里面的函数库 对应的基本都是标准输入输出等等C语言常用库的定义iostream是C++标准库的头定义, 对应的基本上是C++的输入输出相关库定义开发C程序用Stdio, C++用 ...

  4. ［转］在iOS项目中使用CorePlot框架

    转载地址:http://blog.csdn.net/llfjfz/article/details/7849190#comments Core Plot是OS X和IOS下的一个开源图形库,它提供数据的 ...

  5. YTU 2989: 顺序表基本运算（线性表）

    2989: 顺序表基本运算(线性表) 时间限制: 1 Sec  内存限制: 128 MB 提交: 1  解决: 1 题目描述 编写一个程序,实现顺序表的各种基本运算(假设顺序表的元素类型为char), ...

  6. BLOB:大数据，大对象，在数据库中用来存储超长文本的数据，例如图片等

    将一张图片存储在mysql中,并读取出来(BLOB数据:插入BLOB类型的数据必须使用PreparedStatement,因为插入BLOB类型的数据无法使用字符串拼写): -------------- ...

  7. ThinkPHP使用PHPmailer发送Email邮件

    下面介绍thinkphp如何使用phpmailer发送邮件,使用这个邮件发送类,配置好参数后,一句话即可发送邮件.仅适合于thinkphp框架. 第一步,下载类库 将Mail.class.php复制到 ...

  8. UPnP基本原理介绍

    http://blog.csdn.net/braddoris/article/details/41576515 随着计算机产业以及计算机网络技术的迅猛发展,越来越多嵌入式设备的出现和家庭网络的发展,实 ...

  9. linux系统中如何查看日志 (常用命令2)

    cat tail -f 日 志 文 件 说 明 /var/log/message 系统启动后的信息和错误日志,是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关 ...

  10. zookeeper系列之一—zookeeper入门

    Zookeeper是什么? Zookeeper故名思议动物管理员,它是拿来管大象(Hadoop).蜜蜂(Hive).小猪(Pig)的管理员,Apache Hbase和Apache Solr以及Link ...