过滤器初识

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

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

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

  3. 在web.xml中对过滤器进行配置，说明拦截URL的范围 ```java 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 {

      }

}

```xml
<!-- 配置过滤器，filter标签用于说明哪个类是过滤器，并在应用启动的时候自动加载 -->
  <filter>
      <filter-name>myFirstFilter</filter-name>
      <filter-class>com.dodoke.firstfilter.MyFirstFilter</filter-class>
  </filter>
  <!--
    filter-mapping标签用于说明过滤器对URL应用的范围,要点有二:
    1、filter-name 过滤器名称与filter.filter-name保持一致
    2、url-pattern 说明过滤器作用范围,/*代表对所有URL进行过滤
  -->
  <filter-mapping>
      <filter-name>myFirstFilter</filter-name>
      <!-- 指明过滤器能够过滤的请求映射范围 -->
      <url-pattern>/*</url-pattern>
  </filter-mapping>

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    public HelloServlet() {
        super();
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().println("Hello,world!!!");
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
}

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>我是默认首页</h1>
</body>
</html>

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

过滤器的生命周期

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

public class MyFirstFilter implements Filter {
    @Override
    public void destroy() {
        System.out.println("过滤器已被销毁");;
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        System.out.println("过滤器已生效");
        chain.doFilter(request, response);
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器初始化成功");
    }
}

过滤器的特性：

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

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

    过滤器的两种开发方式

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

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

    过滤器两种开发方式

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

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

    //filterName 指明过滤器名称，不同的过滤器需要保证过滤器名称不同，否则过滤器失效。 urlPatterns指明过滤哪些URL
@WebFilter(filterName="MyAnnotationFilter",urlPatterns="/*")
public class MyAnnoationFilter implements Filter{
  @Override
  public void destroy() {

  }
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
          throws IOException, ServletException {
      System.out.println("注解形式过滤器已生效");
      chain.doFilter(request, response);
  }
  @Override
  public void init(FilterConfig filterConfig) throws ServletException {

  }
}

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

    案例：开发字符集过滤器

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

    @WebFilter(filterName="CharacterEncodingFilter",urlPatterns="/*")
public class CharacterEncodingFilter implements Filter {
  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
  }
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
          throws IOException, ServletException {
      //注意此处不是我们之前使用的HttpServletRequest和HttpServletResponse
      HttpServletRequest req = (HttpServletRequest)request;
      req.setCharacterEncoding("UTF-8");
      HttpServletResponse res = (HttpServletResponse)response;
      res.setContentType("text/html;charset=UTF-8");
      chain.doFilter(request, response);
  }
  @Override
  public void destroy() {
  }
}

    或采用

    xml配置：
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>com.dodoke.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

    过滤器 - 图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中配置设置过滤器参数

    <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>com.dodoke.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>GBK</param-value>
    </init-param>
    <init-param>
        <param-name>p1</param-name>
        <param-value>v1</param-value>
    </init-param>
    <init-param>
        <param-name>p2</param-name>
        <param-value>v2</param-value>
    </init-param>
</filter>

    @WebFilter(filterName="CharacterEncodingFilter",urlPatterns="/*",
  initParams= {
          @WebInitParam(name="encoding" , value="GBK"),
          @WebInitParam(name="p1" , value="v1"),
          @WebInitParam(name="p2" , value="v2")
  })
public class CharacterEncodingFilter implements Filter {
  private String encoding;
  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
      encoding=filterConfig.getInitParameter("encoding");
      System.out.println("encoding:"+encoding);
  }
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
          throws IOException, ServletException {
      //注意此处不是我们之前使用的HttpServletRequest和HttpServletResponse
      HttpServletRequest req = (HttpServletRequest)request;
      req.setCharacterEncoding("UTF-8");
      HttpServletResponse res = (HttpServletResponse)response;
      res.setContentType("text/html;charset=UTF-8");
      chain.doFilter(request, response);
  }
  @Override
  public void destroy() {
  }
}

    url-pattern设置过滤范围

    url-pattern常用写法：

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

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

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

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    I'm index page!
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    I'm test page!
</body>
</html>

@WebServlet("/servlet/sample1")
public class SampleServlet1 extends HttpServlet {
    private static final long serialVersionUID = 1L;
    public SampleServlet1() {
        super();
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.getWriter().println("I'm " + this.getClass().getSimpleName());
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
}

@WebServlet("/")
public class SampleServlet2 extends HttpServlet {
    private static final long serialVersionUID = 1L;

    public SampleServlet2() {
        super();
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.getWriter().println("I'm " + this.getClass().getSimpleName());
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
}

/*@WebFilter(filterName="UrlPatternFilter" , urlPatterns= {
        "/","/servlet/*","*.jsp"
})*/
//复杂url，还是使用配置比较好
public class UrlPatternFilter implements Filter{
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse res = (HttpServletResponse)response;
        System.out.println("拦截到:" + req.getRequestURL());
        chain.doFilter(request, response);
    }
    @Override
    public void destroy() {

    }
}

<?xml version="1.0" encoding="UTF-8"?>
<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">
  <display-name>url-pattern</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  <filter>
    <filter-name>UrlPatternFilter</filter-name>
    <filter-class>com.imooc.filter.UrlPatternFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>UrlPatternFilter</filter-name>
    <url-pattern>/</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>UrlPatternFilter</filter-name>
    <url-pattern>/servlet/*</url-pattern>
  </filter-mapping>
  <filter-mapping>
    <filter-name>UrlPatternFilter</filter-name>
    <url-pattern>*.jsp</url-pattern>
  </filter-mapping>
</web-app>

映射的问题：

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

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

    过滤链

    过滤链开发注意事项：

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

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

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

    案例：多端设备自动匹配

    <!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>这是客户端页面</h1>
</body>
</html>

    <!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
  <h1>这是移动端页面</h1>
</body>
</html>

    public class DeviceAdapterFilter implements Filter{
  @Override
  public void init(FilterConfig filterConfig) throws ServletException {

  }
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
          throws IOException, ServletException {
      HttpServletRequest req = (HttpServletRequest)request;
      HttpServletResponse res = (HttpServletResponse)response;
      /*原理：将不同端的页面放置在不同的文件夹中，判断请求的路径，增加前缀
       /index.html
       PC: /desktop/index.html
       MOBILE: /mobile/index.html
       /test.html
       PC: /desktop/test.html
       MOBILE: /mobile/test.html
       */

      //注意区分url和uri
      String uri = req.getRequestURI();
      System.out.println("URI:" + uri);
      if(uri.startsWith("/desktop") || uri.startsWith("/mobile")) {
          chain.doFilter(request, response);
      }else {
          //获取请求主体，并全部转为小写
          String userAgent = req.getHeader("user-agent").toLowerCase();
          String targetURI="";
          if(userAgent.indexOf("android")!=-1 || userAgent.indexOf("iphone") != -1) {
              targetURI = "/mobile" + uri;
              System.out.println("移动端设备正在访问,重新跳转URI:" + targetURI);
              //此处将原始URI修改成targetURI后，不进入过滤链。
              //而是利用响应重定向senRedirect(targetURI)使浏览器重新发送请求，此时请求便能通过过滤器。
              res.sendRedirect(targetURI);
          }else {
              targetURI = "/desktop" + uri;
              System.out.println("PC端设备正在访问,重新跳转URI:" + targetURI);
              res.sendRedirect(targetURI);
          }
      }
  }
  @Override
  public void destroy() {
  }
}

    <?xml version="1.0" encoding="UTF-8"?>
<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">
<display-name>device-adapter</display-name>
<welcome-file-list>
  <welcome-file>index.html</welcome-file>
  <welcome-file>index.htm</welcome-file>
  <welcome-file>index.jsp</welcome-file>
  <welcome-file>default.html</welcome-file>
  <welcome-file>default.htm</welcome-file>
  <welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<filter>
    <filter-name>DeviceAdapterFilter</filter-name>
    <filter-class>com.dodoke.filter.DeviceAdapterFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>DeviceAdapterFilter</filter-name>
    <url-pattern>*.html</url-pattern>
</filter-mapping>
</web-app>