导学

过滤器-Filter，其实可以见名知意，就像我们日常生活中的净化器，过滤网一样，用于在访问资源文件之前，通过一系列的过滤器对请求进行修改、判断等，把不符合规则的请求在中途拦截或修改。也可以对响应进行过滤，拦截或修改响应。

过滤器初识

  • Filter过滤器 （Filter)是J2EE Servlet模块下的组件
  • Filter的作用是对URL进行统一的拦截处理
  • Filter通常用于应用程序层面进行全局处理

4.过滤器 - 图1
开发过滤器的三要素

  1. 任何过滤器都要实现javax.servlet.Filtere接口
  2. 在filter接口的doFilter()方法中编写过滤器的功能代码（一个过滤器一个功能）

  3. 在web.xml中对过滤器进行配置，说明拦截URL的范围 ``` public class MyFirstFilter implements Filter{

    //销毁 @Override public void destroy() {

    } /**

    • @param request
    • @param response
    • @param chain 过滤链对象
    • @throws IOException

    • @throws ServletException */ @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

      1.  throws IOException, ServletException {

      System.out.println(“过滤器已生效！”); //将请求与响应对象沿着过滤链依次向后传递，如果不调用该方法，请求无法正常的向后被处理 chain.doFilter(request, response); }

      //初始化方法 @Override public void init(FilterConfig arg0) throws ServletException {

      }

}

  1. ```
  2. <!-- 配置过滤器，filter标签用于说明哪个类是过滤器，并在应用启动的时候自动加载 -->
  3.   <filter>
  4.       <filter-name>myFirstFilter</filter-name>
  5.       <filter-class>com.dodoke.firstfilter.MyFirstFilter</filter-class>
  6.   </filter>
  7.   <!--
  8.     filter-mapping标签用于说明过滤器对URL应用的范围,要点有二:
  9.     1、filter-name 过滤器名称与filter.filter-name保持一致
  10.     2、url-pattern 说明过滤器作用范围,/*代表对所有URL进行过滤
  11.   -->
  12.   <filter-mapping>
  13.       <filter-name>myFirstFilter</filter-name>
  14.       <!-- 指明过滤器能够过滤的请求映射范围 -->
  15.       <url-pattern>/*</url-pattern>
  16.   </filter-mapping>
  1. @WebServlet("/hello")
  2. public class HelloServlet extends HttpServlet {
  3.     private static final long serialVersionUID = 1L;
  5.     public HelloServlet() {
  6.         super();
  7.     }
  8.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  9.         response.setContentType("text/html;charset=utf-8");
  10.         response.getWriter().println("Hello,world!!!");
  11.     }
  12.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  13.     }
  14. }
  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Insert title here</title>
  6. </head>
  7. <body>
  8. <h1>我是默认首页</h1>
  9. </body>
  10. </html>

无论是请求servlet还是请求静态资源的时候，只要过滤器范文允许，都会实现过滤任务。

过滤器的生命周期

4.过滤器 - 图2
先进行web.xml配置文件的加载，然后进行初始化工作，调用Filter.init()对当前过滤器进行初始化，执行时机tomcat启动后会自动创建Filter这个过滤器对象，一旦对象创建完，马上执行Filter.init()方法。提供服务Filter.doilter()，销毁- Filter.destroy（）执行时机应用关闭或者重启时。

  1. public class MyFirstFilter implements Filter {
  2.     @Override
  3.     public void destroy() {
  4.         System.out.println("过滤器已被销毁");;
  5.     }
  6.     @Override
  7.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  8.             throws IOException, ServletException {
  9.         System.out.println("过滤器已生效");
  10.         chain.doFilter(request, response);
  11.     }
  12.     @Override
  13.     public void init(FilterConfig filterConfig) throws ServletException {
  14.         System.out.println("过滤器初始化成功");
  15.     }
  16. }

过滤器的特性：

  • 过滤器对象在Web应用启动时被创建且全局唯一

  • 唯一的过滤器对象在并发环境中采用“多线程”提供服务（单例多线程方式）
    虽然全局只有一个过滤器对象，但是如果是在并发环节中，每一个请求进来的时候，过滤器都会为其创建一个独立的线程来提供服务，线程和线程之间他们是彼此不受影响的，正是因为叫单例多线程的这么一种设计，既保证了过滤器不会因为频繁创建对象消耗系统资源，同时又采用多线程方式，有效提高了多用户在访问同一个过滤器时的执行速度

    过滤器的两种开发方式

    在之前开发过滤器的时候，我们使用配置文件中注册的形式完成了过滤器的开发。其实类似于servlet，过滤器的配置同样可以使用注解完成。

    1. 过滤器注解形式
    2. @WebFilter(filterName="",urlPatterns="")

    过滤器两种开发方式

  • 配置形式维护性更好，适用应用全局过滤 xml中配置

  • 注解形式开发体验更好，适用于小型项目敏捷开发

    1. //filterName 指明过滤器名称，不同的过滤器需要保证过滤器名称不同，否则过滤器失效。 urlPatterns指明过滤哪些URL
    2. @WebFilter(filterName="MyAnnotationFilter",urlPatterns="/*")
    3. public class MyAnnoationFilter implements Filter{
    4.   @Override
    5.   public void destroy() {
    7.   }
    8.   @Override
    9.   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    10.           throws IOException, ServletException {
    11.       System.out.println("注解形式过滤器已生效");
    12.       chain.doFilter(request, response);
    13.   }
    14.   @Override
    15.   public void init(FilterConfig filterConfig) throws ServletException {
    17.   }
    18. }

    Tomcat是如何发现过滤器并启动过滤器的？
    Servlet3.0版本之后，默认对注解有了支持。每次应用程序启动时，Tomcat会对项目内的所有class字节码文件(java编译后的文件)进行扫描，当扫描到WebFlter注解时，则启用这个过滤器。
    同时存在配置形式和注解形式的过滤器时，会先执行配置形式过滤器。一般来说，整个项目只需要采用一种形式的过滤器，尽可能避免使用两种形式。

    案例：开发字符集过滤器

    主要任务，解决开发过程中的中文乱码问题。
    4.过滤器 - 图3
    在进行开发的时候，如果存在中文，在每一个有中文内容的servlet中都需要进行字符编码的设置，这对我们来说是重复的工作，所以我们可以借助过滤器实现对每个请求与响应的编码设置。

    1. @WebFilter(filterName="CharacterEncodingFilter",urlPatterns="/*")
    2. public class CharacterEncodingFilter implements Filter {
    3.   @Override
    4.   public void init(FilterConfig filterConfig) throws ServletException {
    5.   }
    6.   @Override
    7.   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    8.           throws IOException, ServletException {
    9.       //注意此处不是我们之前使用的HttpServletRequest和HttpServletResponse
    10.       HttpServletRequest req = (HttpServletRequest)request;
    11.       req.setCharacterEncoding("UTF-8");
    12.       HttpServletResponse res = (HttpServletResponse)response;
    13.       res.setContentType("text/html;charset=UTF-8");
    14.       chain.doFilter(request, response);
    15.   }
    16.   @Override
    17.   public void destroy() {
    18.   }
    19. }

    或采用

    1. xml配置：
    2. <filter>
    3.     <filter-name>CharacterEncodingFilter</filter-name>
    4.     <filter-class>com.dodoke.filter.CharacterEncodingFilter</filter-class>
    5. </filter>
    6. <filter-mapping>
    7.     <filter-name>CharacterEncodingFilter</filter-name>
    8.     <url-pattern>/*</url-pattern>
    9. </filter-mapping>

    4.过滤器 - 图4
    为什么doFilter使用的是ServletRequest而不是HttpServletRequest？
    过滤器过滤的不是只有web页面的请求和响应，同时也需要过滤其他类型的请求和响应，其中涉及J2EE的底层机制。
    ServletRequest接口是所有类型请求的最顶层的接口，包含了所有请求接口的通用方法。HttpServletRequest接口是其中的一个子接口，扩展定义自己的方法，是针对Http协议进行定义。
    RequestFacade类是tomcat服务器针对HttpServletRequest接口的实现类，如果使用别的web服务器，实现类也就不是RequestFacade了。
    J2EE是定制者，定制所有的接口，而实现类都是由三方厂商自己定制，此处servlet-api.jar就是J2EE的规范，catalina.jar是由Tomcat提供的实现类。响应接口同理。

    过滤器开发技巧

    过滤器参数化

  • 过滤器为了增强灵活性，允许配置信息放在web.xml

  • 在web.xml中配置设置过滤器参数

    1. <filter>
    2.     <filter-name>CharacterEncodingFilter</filter-name>
    3.     <filter-class>com.dodoke.filter.CharacterEncodingFilter</filter-class>
    4.     <init-param>
    5.         <param-name>encoding</param-name>
    6.         <param-value>GBK</param-value>
    7.     </init-param>
    8.     <init-param>
    9.         <param-name>p1</param-name>
    10.         <param-value>v1</param-value>
    11.     </init-param>
    12.     <init-param>
    13.         <param-name>p2</param-name>
    14.         <param-value>v2</param-value>
    15.     </init-param>
    16. </filter>
    1. @WebFilter(filterName="CharacterEncodingFilter",urlPatterns="/*",
    2.   initParams= {
    3.           @WebInitParam(name="encoding" , value="GBK"),
    4.           @WebInitParam(name="p1" , value="v1"),
    5.           @WebInitParam(name="p2" , value="v2")
    6.   })
    7. public class CharacterEncodingFilter implements Filter {
    8.   private String encoding;
    9.   @Override
    10.   public void init(FilterConfig filterConfig) throws ServletException {
    11.       encoding=filterConfig.getInitParameter("encoding");
    12.       System.out.println("encoding:"+encoding);
    13.   }
    14.   @Override
    15.   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    16.           throws IOException, ServletException {
    17.       //注意此处不是我们之前使用的HttpServletRequest和HttpServletResponse
    18.       HttpServletRequest req = (HttpServletRequest)request;
    19.       req.setCharacterEncoding("UTF-8");
    20.       HttpServletResponse res = (HttpServletResponse)response;
    21.       res.setContentType("text/html;charset=UTF-8");
    22.       chain.doFilter(request, response);
    23.   }
    24.   @Override
    25.   public void destroy() {
    26.   }
    27. }

    url-pattern设置过滤范围

    url-pattern常用写法：

  • /index.jsp - 执行资源精准匹配

  • /servlet/*-以前缀进行模糊匹配（匹配以url中以servlet开头的）
  • *.jsp-以后缀进行模糊匹配

url-pattern允许组合使用形成组合链。

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <!DOCTYPE html>
  4. <html>
  5. <head>
  6. <meta charset="UTF-8">
  7. <title>Insert title here</title>
  8. </head>
  9. <body>
  10.     I'm index page!
  11. </body>
  12. </html>
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <!DOCTYPE html>
  4. <html>
  5. <head>
  6. <meta charset="UTF-8">
  7. <title>Insert title here</title>
  8. </head>
  9. <body>
  10.     I'm test page!
  11. </body>
  12. </html>
  1. @WebServlet("/servlet/sample1")
  2. public class SampleServlet1 extends HttpServlet {
  3.     private static final long serialVersionUID = 1L;
  4.     public SampleServlet1() {
  5.         super();
  6.     }
  7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  8.         response.getWriter().println("I'm " + this.getClass().getSimpleName());
  9.     }
  10.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  11.         doGet(request, response);
  12.     }
  13. }
  1. @WebServlet("/")
  2. public class SampleServlet2 extends HttpServlet {
  3.     private static final long serialVersionUID = 1L;
  5.     public SampleServlet2() {
  6.         super();
  7.     }
  8.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  9.         response.getWriter().println("I'm " + this.getClass().getSimpleName());
  10.     }
  11.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  12.         doGet(request, response);
  13.     }
  14. }
  1. /*@WebFilter(filterName="UrlPatternFilter" , urlPatterns= {
  2.         "/","/servlet/*","*.jsp"
  3. })*/
  4. //复杂url，还是使用配置比较好
  5. public class UrlPatternFilter implements Filter{
  6.     @Override
  7.     public void init(FilterConfig filterConfig) throws ServletException {
  9.     }
  10.     @Override
  11.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  12.             throws IOException, ServletException {
  13.         HttpServletRequest req = (HttpServletRequest)request;
  14.         HttpServletResponse res = (HttpServletResponse)response;
  15.         System.out.println("拦截到:" + req.getRequestURL());
  16.         chain.doFilter(request, response);
  17.     }
  18.     @Override
  19.     public void destroy() {
  21.     }
  22. }
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  3.   <display-name>url-pattern</display-name>
  4.   <welcome-file-list>
  5.     <welcome-file>index.html</welcome-file>
  6.     <welcome-file>index.htm</welcome-file>
  7.     <welcome-file>index.jsp</welcome-file>
  8.     <welcome-file>default.html</welcome-file>
  9.     <welcome-file>default.htm</welcome-file>
  10.     <welcome-file>default.jsp</welcome-file>
  11.   </welcome-file-list>
  12.   <filter>
  13.     <filter-name>UrlPatternFilter</filter-name>
  14.     <filter-class>com.imooc.filter.UrlPatternFilter</filter-class>
  15.   </filter>
  16.   <filter-mapping>
  17.     <filter-name>UrlPatternFilter</filter-name>
  18.     <url-pattern>/</url-pattern>
  19.   </filter-mapping>
  20.   <filter-mapping>
  21.     <filter-name>UrlPatternFilter</filter-name>
  22.     <url-pattern>/servlet/*</url-pattern>
  23.   </filter-mapping>
  24.   <filter-mapping>
  25.     <filter-name>UrlPatternFilter</filter-name>
  26.     <url-pattern>*.jsp</url-pattern>
  27.   </filter-mapping>
  28. </web-app>

映射的问题：

  • /指映射Web应用根路径，且只对Servlet生效
  • 默认首页index.jsp会让/失效

  • /与/*含义不同，前者指向根路径，后者代表所有

    过滤链

    过滤链开发注意事项：

  • 每一个过滤器应具有单独职能

  • 调用chain.doFiiter()将请求向后传递
  • 过滤链是双向的，响应返回时按逆序通过过滤链
  • 过滤器的执行顺序以XML配置中的从上到下执行

  • 以注解形式设置过滤器时，过滤器执行顺序按过滤器类名（不是注解中的filterName）的大小顺序进行，如：filterA filterZ filterV三个过滤器执行顺序为AVZ（不合理）类名有独特含义，不能特地为了过滤链的执行顺序而修改过滤器类名

    案例：多端设备自动匹配

    1. <!DOCTYPE html>
    2. <html>
    3. <head>
    4. <meta charset="UTF-8">
    5. <title>Insert title here</title>
    6. </head>
    7. <body>
    8. <h1>这是客户端页面</h1>
    9. </body>
    10. </html>
    1. <!DOCTYPE html>
    2. <html>
    3. <head>
    4. <meta charset="UTF-8">
    5. <title>Insert title here</title>
    6. </head>
    7. <body>
    8.   <h1>这是移动端页面</h1>
    9. </body>
    10. </html>
    1. public class DeviceAdapterFilter implements Filter{
    2.   @Override
    3.   public void init(FilterConfig filterConfig) throws ServletException {
    5.   }
    6.   @Override
    7.   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    8.           throws IOException, ServletException {
    9.       HttpServletRequest req = (HttpServletRequest)request;
    10.       HttpServletResponse res = (HttpServletResponse)response;
    11.       /*原理：将不同端的页面放置在不同的文件夹中，判断请求的路径，增加前缀
    12.        /index.html
    13.        PC: /desktop/index.html
    14.        MOBILE: /mobile/index.html
    15.        /test.html
    16.        PC: /desktop/test.html
    17.        MOBILE: /mobile/test.html
    18.        */
    20.       //注意区分url和uri
    21.       String uri = req.getRequestURI();
    22.       System.out.println("URI:" + uri);
    23.       if(uri.startsWith("/desktop") || uri.startsWith("/mobile")) {
    24.           chain.doFilter(request, response);
    25.       }else {
    26.           //获取请求主体，并全部转为小写
    27.           String userAgent = req.getHeader("user-agent").toLowerCase();
    28.           String targetURI="";
    29.           if(userAgent.indexOf("android")!=-1 || userAgent.indexOf("iphone") != -1) {
    30.               targetURI = "/mobile" + uri;
    31.               System.out.println("移动端设备正在访问,重新跳转URI:" + targetURI);
    32.               //此处将原始URI修改成targetURI后，不进入过滤链。
    33.               //而是利用响应重定向senRedirect(targetURI)使浏览器重新发送请求，此时请求便能通过过滤器。
    34.               res.sendRedirect(targetURI);
    35.           }else {
    36.               targetURI = "/desktop" + uri;
    37.               System.out.println("PC端设备正在访问,重新跳转URI:" + targetURI);
    38.               res.sendRedirect(targetURI);
    39.           }
    40.       }
    41.   }
    42.   @Override
    43.   public void destroy() {
    44.   }
    45. }
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
    3. <display-name>device-adapter</display-name>
    4. <welcome-file-list>
    5.   <welcome-file>index.html</welcome-file>
    6.   <welcome-file>index.htm</welcome-file>
    7.   <welcome-file>index.jsp</welcome-file>
    8.   <welcome-file>default.html</welcome-file>
    9.   <welcome-file>default.htm</welcome-file>
    10.   <welcome-file>default.jsp</welcome-file>
    11. </welcome-file-list>
    12. <filter>
    13.     <filter-name>DeviceAdapterFilter</filter-name>
    14.     <filter-class>com.dodoke.filter.DeviceAdapterFilter</filter-class>
    15. </filter>
    16. <filter-mapping>
    17.     <filter-name>DeviceAdapterFilter</filter-name>
    18.     <url-pattern>*.html</url-pattern>
    19. </filter-mapping>
    20. </web-app>