过滤器 监听器

【学习笔记】

一、过滤器

 

【定义】：部署在web服务器与客户端中间的机制，主要功能是处理中文乱码和简单的权限控制

 

【生命周期】：在容器【启动时】实例化，在客户端发送请求后过滤器的doFilter()方法会对接受到的

FilterChain对象和请求对象(servletrequest)，响应对象(servletresponse)当对请求对象

处理完成后，可以通过FilterChain对象的doFilter()方法进行放行，在容器关闭时才会销毁

过滤器，故生命周期:容器启动-请求过滤(响应过滤)-容器关闭(同时过滤器销毁(容器调用destroy方                        法))

 

【创建部署】：创建：1.创建普通java类，但必须实现Filter接口(根据容器不同接口不同)才称得上过滤器

    2.重写destroy()，doFilter()，ini()方法

       部署：web.xml部署文件

<filter>

<filter-name>*****</filter-name>

<filter-class>java类绝对路径</filter-class>

</filter>

 

<filter-mapping>

<filter-name>*****</filter-name>

<url-pattern>*</url-pattern>

</filter-mapping>

 

 

注:filter-name为映射对应名，故一对标签中filter-name必须一样

   url-pattern:为指定过滤文件夹【*】代表所有,【文件夹名/*】该文件夹下所有                                                        文件  如usercenter文件夹下所有JSP文件 /usercenter/*

   顺序:fliter-mapping 标签 自上向下顺序执行 尽量按照数据流顺序来部署

过滤器

【数据流】：当数据进入过滤器后，会通过dofilter方法，此方法里有一个FilterChain对象调用dofilter()放行                    方法，这是个数据流关键的地方,一个请求对于一个响应，放行方法上面是放行前的处理，当处理

    完成后，放行给容器，此时对容器来说是客户端的一个请求，当容器处理完成后会返回一个响应

   【此时依然会】经过过滤器处理，此时放行方法后面的代码就是代表的响应回去的处理代码段

 

注:过滤器是【单实例多线程】

 

二、监听器

•  

  借鉴文档

   

  过滤器Filter也具有生命周期：init()->doFilter()->destroy()，由部署文件中的filter元素驱动。在servlet2.4中，过滤器同样可以用于请求分派器，但须在web.xml中声明，<dispatcher>INCLUDE或FORWARD或REQUEST或ERROR</dispatcher>该元素位于filter-mapping中。 

   

  一、批量设置请求编码 

  Java代码 

  1. public class EncodingFilter implements Filter {   
  2.   
  3.     private String encoding = null;   
  4.   
  5.     public void destroy() {   
  6.         encoding = null;   
  7.     }   
  8.   
  9.     public void doFilter(ServletRequest request, ServletResponse response,   
  10.             FilterChain chain) throws IOException, ServletException {   
  11.         String encoding = getEncoding();   
  12.         if (encoding == null){   
  13.             encoding = "gb2312";   
  14.         }   
  15.         request.setCharacterEncoding(encoding);// 在请求里设置上指定的编码   
  16.         chain.doFilter(request, response);   
  17.     }   
  18.   
  19.     public void init(FilterConfig filterConfig) throws ServletException {   
  20.         this.encoding = filterConfig.getInitParameter("encoding");   
  21.     }   
  22.   
  23.     private String getEncoding() {   
  24.         return this.encoding;   
  25.     }   
  26.   
  27. }  

   

  Xml代码 

  28. <filter>  
  29.     <filter-name>EncodingFilter</filter-name>  
  30.     <filter-class>com.logcd.filter.EncodingFilter</filter-class>  
  31.     <init-param>  
  32.        <param-name>encoding</param-name>  
  33.        <param-value>gb2312</param-value>  
  34.     </init-param>  
  35. </filter>  
  36.   
  37. <filter-mapping>  
  38.    <filter-name>EncodingFilter</filter-name>  
  39.    <url-pattern>/*</url-pattern>  
  40. </filter-mapping>  

   

  二、用filter控制用户访问权限 

   

  Java代码 

  41. public void doFilter(ServletRequest request,   
  42.         ServletResponse response,   
  43.         FilterChain chain)   
  44.         throws IOException, ServletException {   
  45.   
  46.     HttpServletRequest req = (HttpServletRequest) request;   
  47.     HttpServletResponse res = (HttpServletResponse) response;   
  48.   
  49.     HttpSession session = req.getSession();   
  50.     if (session.getAttribute("username") != null) {//登录后才能访问   
  51.         chain.doFilter(request, response);   
  52.     } else {   
  53.         res.sendRedirect("../failure.jsp");   
  54.     }   
  55. }  

   

   

  Xml代码 

  56. <filter>  
  57.     <filter-name>SecurityFilter</filter-name>  
  58.     <filter-class>com.logcd.filter.SecurityFilter</filter-class>  
  59. </filter>  
  60. <filter-mapping>  
  61.     <filter-name>SecurityFilter</filter-name>  
  62.     <url-pattern>/admin/*</url-pattern>  
  63. </filter-mapping>  

   

  三、过滤链 

   

     两个过滤器，EncodingFilter负责设置编码，SecurityFilter负责控制权限，服务器会按照web.xml中过滤器定义的先后循序组装成一条链，然后一次执行其中的doFilter()方法。执行的顺序就如上图所示，执行第一个过滤器的chain.doFilter()之前的代码，第二个过滤器的chain.doFilter()之前的代码，请求的资源，第二个过滤器的chain.doFilter()之后的代码，第一个过滤器的chain.doFilter()之后的代码，最后返回响应。 

  执行的代码顺序是： 

  64. 执行EncodingFilter.doFilter()中chain.doFilter()之前的部分：request.setCharacterEncoding("gb2312");
  65. 执行SecurityFilter.doFilter()中chain.doFilter()之前的部分：判断用户是否已登录。
  66. 如果用户已登录，则访问请求的资源：/admin/index.jsp。
  67. 如果用户未登录，则页面重定向到：/failure.jsp。
  68. 执行SecurityFilter.doFilter()中chain.doFilter()之后的部分：这里没有代码。
  69. 执行EncodingFilter.doFilter()中chain.doFilter()之后的部分：这里也没有代码。

   

     过滤链的好处是，执行过程中任何时候都可以打断，只要不执行chain.doFilter()就不会再执行后面的过滤器和请求的内容。而在实际使用时，就要特别注意过滤链的执行顺序问题，像EncodingFilter就一定要放在所有Filter之前，这样才能确保在使用请求中的数据前设置正确的编码。 

   

  四、使用filter,结合gzip 压缩技术,解决web应用中网络传输数据量大的问题 

      gzip是http协议中使用的一种加密算法,客户端向web服务器端发出了请求后，通常情况下服务器端会将页面文件和其他资源，返回到客户端，客户端加载后渲染呈现，这种情况文件一般都比较大，如果开启Gzip ，那么服务器端响应后，会将页面，JS,CSS等文本文件或者其他文件通过高压缩算法将其压缩，然后传输到客户端，由客户端的浏览器负责解压缩与呈现。通常能节省40%以上的流量（一般都有60%左右），一些PHP，JSP文件也能够进行压缩。 

  1.Tomcat 直接开启Gzip 

      打开Tomcat 目录下的conf下的server.xml，并找到如下信息: 

  Xml代码 

  70. <!-- Note : To use gzip compression you could set the following properties :   
  71.    compression="on"    
  72.    compressionMinSize="2048"    
  73.    noCompressionUserAgents="gozilla, traviata"    
  74.    compressableMimeType="text/html,text/xml"  
  75. -->  

   

      把它们加入到你配置的<Connector port="80" .../>中去。如果要压缩css 和 js，加入compressableMimeType="text/html,text/xml,text/css,text/javascript"。还要压缩图片,加入compressableMimeType="text/html,text/xml,text/css,text/javascript,image/gif,image/jpg"。 

      开启后重启Tomcat ，通过浏览器查看headers信息就能看到是否开启。 

   

  2.使用filter,在代码级别完成web应用的gzip压缩的开启。 

   

  (1).CachedResponseWrapper类 

      实现定制输出的关键是对HttpServletResponse 进行包装，截获所有的输出，等到过滤器链处理完毕后，再对截获的输出进行处理，并写入到真正的HttpServletResponse 对象中。JavaEE 框架已经定义了一个HttpServletResponseWrapper 类使得包装HttpServletResponse 更加容易。我们扩展这个HttpServletResponseWrapper，截获所有的输出，并保存到ByteArrayOutputStream 中。 

      定制的包装响应能方便地从帮助类 HttpServletResponseWrapper 中导出。这一类粗略地执行许多方法，允许我们简单地覆盖 getOutputStream() 方法以及 getWriter() 方法，提供了定制输出流的实例。 

      HttpServletResponseWrapper这个类的使用包括以下五个步骤： 

  1）建立一个响应包装器。扩展javax.servlet.http.HttpServletResponseWrapper。 

  2）提供一个缓存输出的PrintWriter。重载getWriter方法，返回一个保存发送给它的所有东西的PrintWriter，并把结果存进一个可以稍后访问的字段中。 

  3）传递该包装器给doFilter。此调用是合法的，因为HttpServletResponseWrapper实现HttpServletResponse。 

  4）提取和修改输出。在调用FilterChain的doFilter方法后，原资源的输出只要利用步骤2中提供的机制就可以得到。只要对你的应用适合，就可以修改或替换它。 

  5）发送修改过的输出到客户机。因为原资源不再发送输出到客户机（这些输出已经存放到你的响应包装器中了），所以必须发送这些输出。这样，你的过滤器需要从原响应对象中获得PrintWriter或OutputStream，并传递修改过的输出到该流中。 

  Java代码 

  76. /**  
  77.  * Wrapper:在内存中开辟一个ByteOutputStream，然后将拦截的响应写入byte[]，  
  78.  * 写入完毕后，再将wrapper的byte[]写入真正的response对象  
  79.  * This class is used for wrapped response for getting cached data.  
  80.  */    
  81. class CachedResponseWrapper extends HttpServletResponseWrapper {   
  82.   
  83.     /**  
  84.      * Indicate that getOutputStream() or getWriter() is not called yet.  
  85.      */  
  86.     public static final int OUTPUT_NONE = 0;   
  87.   
  88.     /**  
  89.      * Indicate that getWriter() is already called.  
  90.      */  
  91.     public static final int OUTPUT_WRITER = 1;   
  92.   
  93.     /**  
  94.      * Indicate that getOutputStream() is already called.  
  95.      */  
  96.     public static final int OUTPUT_STREAM = 2;   
  97.   
  98.     private int outputType = OUTPUT_NONE;   
  99.   
  100.     private int status = SC_OK;   
  101.   
  102.     private ServletOutputStream output = null;   
  103.   
  104.     private PrintWriter writer = null;   
  105.   
  106.     private ByteArrayOutputStream buffer = null;   
  107.   
  108.     public CachedResponseWrapper(HttpServletResponse resp) throws IOException {   
  109.         super(resp);   
  110.         buffer = new ByteArrayOutputStream();   
  111.     }   
  112.   
  113.     public int getStatus() {   
  114.         return status;   
  115.     }   
  116.   
  117.     public void setStatus(int status) {   
  118.         super.setStatus(status);   
  119.         this.status = status;   
  120.     }   
  121.   
  122.     public void setStatus(int status, String string) {   
  123.         super.setStatus(status, string);   
  124.         this.status = status;   
  125.     }   
  126.   
  127.     public void sendError(int status, String string) throws IOException {   
  128.         super.sendError(status, string);   
  129.         this.status = status;   
  130.     }   
  131.   
  132.     public void sendError(int status) throws IOException {   
  133.         super.sendError(status);   
  134.         this.status = status;   
  135.     }   
  136.   
  137.     public void sendRedirect(String location) throws IOException {   
  138.         super.sendRedirect(location);   
  139.         this.status = SC_MOVED_TEMPORARILY;   
  140.     }   
  141.   
  142.     public PrintWriter getWriter() throws IOException {   
  143.         if (outputType == OUTPUT_STREAM)   
  144.             throw new IllegalStateException();   
  145.         else if (outputType == OUTPUT_WRITER)   
  146.             return writer;   
  147.         else {   
  148.             outputType = OUTPUT_WRITER;   
  149.             writer = new PrintWriter(new OutputStreamWriter(buffer,   
  150.                     getCharacterEncoding()));   
  151.             return writer;   
  152.         }   
  153.     }   
  154.   
  155.     public ServletOutputStream getOutputStream() throws IOException {   
  156.         if (outputType == OUTPUT_WRITER)   
  157.             throw new IllegalStateException();   
  158.         else if (outputType == OUTPUT_STREAM)   
  159.             return output;   
  160.         else {   
  161.             outputType = OUTPUT_STREAM;   
  162.             output = new WrappedOutputStream(buffer);   
  163.             return output;   
  164.         }   
  165.     }   
  166.   
  167.     public void flushBuffer() throws IOException {   
  168.         if (outputType == OUTPUT_WRITER)   
  169.             writer.flush();   
  170.         if (outputType == OUTPUT_STREAM)   
  171.             output.flush();   
  172.     }   
  173.   
  174.     public void reset() {   
  175.         outputType = OUTPUT_NONE;   
  176.         buffer.reset();   
  177.     }   
  178.   
  179.     /**  
  180.      * Call this method to get cached response data.  
  181.      *   
  182.      * @return byte array buffer.  
  183.      * @throws IOException  
  184.      */  
  185.     public byte[] getResponseData() throws IOException {   
  186.         flushBuffer();   
  187.         return buffer.toByteArray();   
  188.     }   
  189.   
  190.     /**  
  191.      * This class is used to wrap a ServletOutputStream and store output stream  
  192.      * in byte[] buffer.  
  193.      */  
  194.     class WrappedOutputStream extends ServletOutputStream {   
  195.   
  196.         private ByteArrayOutputStream buffer;   
  197.   
  198.         public WrappedOutputStream(ByteArrayOutputStream buffer) {   
  199.             this.buffer = buffer;   
  200.         }   
  201.   
  202.         public void write(int b) throws IOException {   
  203.             buffer.write(b);   
  204.         }   
  205.   
  206.         public byte[] toByteArray() {   
  207.             return buffer.toByteArray();   
  208.         }   
  209.     }   
  210.   
  211. }  

   

  (2).GZipFilter类 

  Java代码 

  212. public class GZipFilter implements Filter {   
  213.     public void init(FilterConfig arg0) throws ServletException {   
  214.     }   
  215.   
  216.     public void doFilter(ServletRequest request, ServletResponse response,   
  217.             FilterChain chain) throws IOException, ServletException {   
  218.   
  219.         HttpServletResponse httpResponse = (HttpServletResponse) response;   
  220.         CachedResponseWrapper wrapper = new CachedResponseWrapper(httpResponse);   
  221.         // 写入wrapper:   
  222.         chain.doFilter(request, wrapper);   
  223.         // 对响应进行处理，这里是进行GZip压缩:   
  224.         byte[] data = GZipUtil.gzip(wrapper.getResponseData());   
  225.         httpResponse.setHeader("Content-Encoding", "gzip");   
  226.         httpResponse.setContentLength(data.length);   
  227.         ServletOutputStream output = response.getOutputStream();   
  228.         output.write(data);   
  229.         output.flush();   
  230.     }   
  231.   
  232.     public void destroy() {   
  233.   
  234.     }   
  235.   
  236. }  

   

  (3).GZipUtil类 

  Java代码 

  237. public final class GZipUtil {   
  238.     /** * Do a gzip operation. */  
  239.     public static byte[] gzip(byte[] data) {   
  240.         ByteArrayOutputStream byteOutput = new ByteArrayOutputStream(10240);   
  241.         GZIPOutputStream output = null;   
  242.         try {   
  243.             output = new GZIPOutputStream(byteOutput);   
  244.             output.write(data);   
  245.         } catch (IOException e) {   
  246.             throw new RuntimeException("G-Zip failed.", e);   
  247.         } finally {   
  248.             if (output != null) {   
  249.                 try {   
  250.                     output.close();   
  251.                 } catch (IOException e) {   
  252.                 }   
  253.             }   
  254.         }   
  255.         return byteOutput.toByteArray();   
  256.     }   
  257. }  

   

  (4).在web.xml中配置 GZipFilter 

  Xml代码 

  258. <filter>  
  259.    <filter-name>GZipFilter</filter-name>     
  260.    <filter-class>com.logcd.filter.GZipFilter</filter-class>     
  261. </filter>     
  262. <filter-mapping>     
  263.    <filter-name>GZipFilter</filter-name>     
  264.    <url-pattern>*.html</url-pattern>     
  265. </filter-mapping>