J2EE进阶之过滤器Filter 二十一

傷城~ 2024-02-18 14:51 50阅读 0赞

## **过滤器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>

打印输出：

![cVdF6Qg.png][]

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

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

#### 生命周期 ####

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

走的Filter的init方法

![yJj2uKC.png][]

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

在控制台输入指令：

![D4rhV5W.png][]

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

![MnkIkot.png][]

### 四、串联过滤器 ###

串联过滤器是指多个过滤器多个过滤器多某些资源进行过滤。编写多个过滤器，在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执行后");
    
        }

整个过程：

![4kdScHf.png][]

### 五、过滤器的简单案例： ###

#### 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>
        
        <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>
        <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 }

压缩结果：

![Ft07sju.png][]

[cVdF6Qg.png]: http://i.imgur.com/cVdF6Qg.png
[yJj2uKC.png]: http://i.imgur.com/yJj2uKC.png
[D4rhV5W.png]: http://i.imgur.com/D4rhV5W.png
[MnkIkot.png]: http://i.imgur.com/MnkIkot.png
[4kdScHf.png]: http://i.imgur.com/4kdScHf.png
[Ft07sju.png]: http://i.imgur.com/Ft07sju.png