J2EE进阶之过滤器Filter 二十一

过滤器Filter

一、过滤器是什么？有什么用？

过滤器是什么？

　　过滤器是一个可以对请求相应进行拦截的程序。

作用：

　　拦截一些信息，比如请求参数有相关不符合请求的。。。

二、过滤器的编码步骤

新建类，实现filter接口，会有三个为实现的方法，destroy，init,doFilter。在doFilter中编写逻辑。之后利用chain.doFilter(request,response)方法放行。
在xml中配置过滤器。

写个demo测试下：

Filter

public class FilterDemo1 implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化了");
    }
    //针对过滤范围内的资源的每次访问都会执行该方法，由服务器调用
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.out.println("FilterDemo1执行前");
        chain.doFilter(request, response);//放行。让下一个执行
        System.out.println("FilterDemo1执行后");
    }

    public void destroy() {
        System.out.println("销毁了");
    }

}

再写一个Servlet

public class ServletDemo1 extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        System.out.println("ServletDemo1执行了");
    }

配置xml文件

  <filter>
    <filter-name>FilterDemo1</filter-name>
    <filter-class>wsj.filter1.FilterDemo1</filter-class>
  </filter>
  <filter-mapping>
  <!-- 过滤器过滤资源 -->
    <filter-name>FilterDemo1</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

打印输出：

总结：
你会发现在运行Servlet之前走了一遍过滤器，然后Servlet之后再次走了一遍过滤器。。注意：再次走过滤器是走了chain.doFilter(request, response);之后的代码。

三、过滤器的执行过程（生命周期）

生命周期

诞生：应用加载时（服务器开启时）就完成实例化，并由服务器调用init初始化方法。

走的Filter的init方法

活着：应用活着他就活着
死亡：应用被卸载时，就死亡，并由服务器调用destory方法。
走Destory方法：

在控制台输入指令：

然后代码就会走销毁方法：

四、串联过滤器

串联过滤器是指多个过滤器多个过滤器多某些资源进行过滤。编写多个过滤器，在xml文件中配置多个过滤器。执行顺序是先配置的过滤器先执行

写个demo2

public class FilterDemo2 implements Filter {

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

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.out.println("FilterDemo2执行前");
        chain.doFilter(request, response);//放行。让下一个执行
        System.out.println("FilterDemo2执行后");

    }

整个过程：

五、过滤器的简单案例：

1解决全站中文乱码问题。除了GET请求方式

public class SetCharacterEncodingFilter implements Filter {

    private FilterConfig filterConfig;//代表者过滤器的参数配置

    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
    }

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        //参数不存在，返回null
        String encoding = filterConfig.getInitParameter("encoding");
        //给出默认编码
        if(encoding == null){
            encoding = "UTF-8";
        }

        request.setCharacterEncoding(encoding);//解决POST请求参数的中文编码
        response.setCharacterEncoding(encoding);//更改输出字符流的编码
        response.setContentType("text/html;charset="+encoding);//告知客户端使用字符编码
        chain.doFilter(request, response);
    }

    public void destroy() {

    }

}

xml配置

  <filter>
    <!--  POST请求和响应的编码过滤器 -->
    <filter-name>SetCharacterEncodingFilter</filter-name>
    <filter-class>com.itheima.filter.SetCharacterEncodingFilter</filter-class>
    <!-- 过滤器参数配置 -->
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>SetCharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

分别控制html、css、js的静态资源的缓存时间

public class StaticResourcesNeedCacheFilter implements Filter {

    private FilterConfig filterConfig;

    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
    }

    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request;
        HttpServletResponse response;
        try{
            request = (HttpServletRequest)req;
            response = (HttpServletResponse)resp;
        }catch(Exception e){
            throw new RuntimeException("non-http request or response");
        }
        long time = 0;//缓存时间的偏移量

        //根据用户访问的资源，获取参数的值，从而设置缓存的时间
        String uri = request.getRequestURI();//   
        String resourceType = uri.substring(uri.lastIndexOf(".")+1);//   html

//      if("html".equals(resourceType)){
//          String value = filterConfig.getInitParameter("html");//得到配置的html的缓存时间，单位是小时
//          time = Long.parseLong(value)*60*60*1000;
//      }
//      
//      if("css".equals(resourceType)){
//          String value = filterConfig.getInitParameter("css");//得到配置的html的缓存时间，单位是小时
//          time = Long.parseLong(value)*60*60*1000;
//      }
//      if("js".equals(resourceType)){
//          String value = filterConfig.getInitParameter("js");//得到配置的html的缓存时间，单位是小时
//          time = Long.parseLong(value)*60*60*1000;
//      }

        String value = filterConfig.getInitParameter(resourceType);
        if(value!=null){
            time = Long.parseLong(value)*60*60*1000;
        }

        response.setDateHeader("Expires", System.currentTimeMillis()+time);
        chain.doFilter(request, response);
    }

    public void destroy() {

    }

}

xml配置

  <!-- 控制静态资源的缓存时间 -->
  <filter>
    <filter-name>StaticResourcesNeedCacheFilter</filter-name>
    <filter-class>com.itheima.filter.StaticResourcesNeedCacheFilter</filter-class>
    <init-param>
        <param-name>html</param-name>
        <param-value>1</param-value><!-- 单位是小时 -->
    </init-param>
    <init-param>
        <param-name>css</param-name>
        <param-value>2</param-value><!-- 单位是小时 -->
    </init-param>
    <init-param>
        <param-name>js</param-name>
        <param-value>3</param-value><!-- 单位是小时 -->
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>StaticResourcesNeedCacheFilter</filter-name>
    <url-pattern>*.html</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>StaticResourcesNeedCacheFilter</filter-name>
    <url-pattern>*.js</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>StaticResourcesNeedCacheFilter</filter-name>
    <url-pattern>*.css</url-pattern>
  </filter-mapping>

不缓存

public class DynamicResourcesNoCacheFilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request;
        HttpServletResponse response;
        try{
            request = (HttpServletRequest)req;
            response = (HttpServletResponse)resp;
        }catch(Exception e){
            throw new RuntimeException("non-http request or response");
        }

        response.setHeader("Expires", "-1");
        response.setHeader("Cache-Control", "no-cache");
        response.setHeader("Pragma", "no-cache");
        chain.doFilter(request, response);
    }

    public void destroy() {

    }

}

xml配置

  <!-- 控制动态资源不要缓存 -->
  <filter>
    <filter-name>DynamicResourcesNoCacheFilter</filter-name>
    <filter-class>com.itheima.filter.DynamicResourcesNoCacheFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>DynamicResourcesNoCacheFilter</filter-name>
    <url-pattern>*.jsp</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>DynamicResourcesNoCacheFilter</filter-name>
    <url-pattern>/servlet/*</url-pattern>
  </filter-mapping>

六、过滤器的高级配置

REQUEST：当用户直接访问页面时，Web容器将会调用过滤器。如果目标资源是通过RequestDispatcher的include()或forward()方法访问时，那么该过滤器就不会被调用。

INCLUDE：如果目标资源是通过RequestDispatcher的include()方法访问时，那么该过滤器将被调用。除此之外，该过滤器不会被调用。

FORWARD：如果目标资源是通过RequestDispatcher的forward()方法访问时，那么该过滤器将被调用，除此之外，该过滤器不会被调用。

ERROR：

以上都会出现不会过滤的情况

设置方式：

  <filter-mapping>
    <filter-name>FilterDemo1</filter-name>
    <url-pattern>/*</url-pattern>
    <!-- 如果一个dispatcher都不写：默认是REQUEST -->
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>FORWARD</dispatcher>
    <dispatcher>INCLUDE</dispatcher>
    <dispatcher>ERROR</dispatcher>
  </filter-mapping>

Gzip压缩

  1 import java.io.ByteArrayOutputStream;
  2 import java.io.IOException;
  3 import java.io.OutputStreamWriter;
  4 import java.io.PrintWriter;
  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.ServletException;
 11 import javax.servlet.ServletOutputStream;
 12 import javax.servlet.ServletRequest;
 13 import javax.servlet.ServletResponse;
 14 import javax.servlet.http.HttpServletRequest;
 15 import javax.servlet.http.HttpServletResponse;
 16 import javax.servlet.http.HttpServletResponseWrapper;
 17 
 18 public class GzipFilter implements Filter {
 19 
 20     public void init(FilterConfig filterConfig) throws ServletException {
 21 
 22     }
 23 
 24     public void doFilter(ServletRequest req, ServletResponse resp,
 25             FilterChain chain) throws IOException, ServletException {
 26         HttpServletRequest request;
 27         HttpServletResponse response;
 28 
 29         try {
 30             request = (HttpServletRequest) req;
 31             response = (HttpServletResponse) resp;
 32         } catch (ClassCastException e) {
 33             throw new ServletException("non-HTTP request or response");
 34         }
 35 
 36         GzipHttpServletResponse mresponse = new GzipHttpServletResponse(response);
 37         chain.doFilter(request, mresponse);
 38         //在此处完成压缩
 39         byte b[] =mresponse.getBytes();//得到原来要输出的数据是关键
 40         System.out.println("数据原来大小："+b.length);
 41         
 42         ByteArrayOutputStream baos = new ByteArrayOutputStream();// 带有缓存的字节内存输出流
 43         GZIPOutputStream gout = new GZIPOutputStream(baos);
 44         gout.write(b);
 45         gout.close();//数据用gzip压缩到了baos中
 46         
 47         b = baos.toByteArray();//取出的压缩后的字节
 48         System.out.println("数据压缩后的大小："+b.length);
 49         
 50         //告知客户端编码方式
 51         response.setHeader("Content-Encoding", "gzip");
 52         response.setContentLength(b.length);//告知正文的长度
 53         
 54         ServletOutputStream sos = response.getOutputStream();
 55         sos.write(b);
 56         
 57     }
 58 
 59     public void destroy() {
 60 
 61     }
 62 
 63 }
 64 class GzipHttpServletResponse extends HttpServletResponseWrapper{
 65     private ByteArrayOutputStream baos = new ByteArrayOutputStream();//临时仓库，存放截获的原始数据
 66     private PrintWriter pw;
 67     public GzipHttpServletResponse(HttpServletResponse response){
 68         super(response);
 69     }
 70     //截获原来的数据：字节流
 71     public ServletOutputStream getOutputStream() throws IOException {
 72         return new MyServletOutputStream(baos);
 73     }
 74     //截获原来的数据：字符流
 75     public PrintWriter getWriter() throws IOException {
 76         pw = new PrintWriter(new OutputStreamWriter(baos, super.getCharacterEncoding()));//字符流--->字节流：查码表。
 77         return pw;
 78     }
 79     //返回原始的数据
 80     public byte[] getBytes(){
 81         try {
 82             if(pw!=null){
 83                 pw.close();
 84             }
 85             baos.flush();
 86         } catch (IOException e) {
 87             e.printStackTrace();
 88         }
 89         return baos.toByteArray();
 90     }
 91 }
 92 class MyServletOutputStream extends ServletOutputStream{
 93     private ByteArrayOutputStream baos;
 94     public MyServletOutputStream(ByteArrayOutputStream baos){
 95         this.baos = baos;
 96     }
 97     public void write(int b) throws IOException {
 98         baos.write(b);
 99     }
100     
101 }

压缩结果：