JavaWeb-使用Filter过滤器进行权限检查_java的过滤器对接口的放行和验权

1. 什么是Filter过滤器

1. Filter 过滤器它是 JavaWeb 的三大组件之一。三大组件分别是：Servlet 程序、Listener 监听器、Filter 过滤器。

2. Filter 过滤器它是 JavaEE 的规范，也就是接口。

3. Filter过滤器的作用是：拦截请求，过滤响应（只有少数高级操作才使用）。

拦截请求常见的场景有：权限检查、日记操作、事务管理等。

2. Filter初体验

要求：在你的 Web 工程下，有一个 admin 目录。这个 admin 目录下的所有资源（html页面、jpg图片、jsp文件等等）都必须是用户登录之后才允许访问。

思考：根据之前我们学过的内容，我们知道：用户登录之后都会把用户登录的信息保存到 Session 域中。所以要检查用户是否登录，可以判断 Session 中是否包含用户登录的信息即可。

// 传统方法：使用jsp 页面实现拦截
...
<%
	Object user = session.getAttribute("user");
	// 如果等于null，说明还没有登录
	if (user == null) {
		request.getRequestDispatcher("/login.jsp").forward(request, response);
		return;
	}
%>
...
1
2
3
4
5
6
7
8
9
10
11

但是上面这种基于 jsp 的方式只能拦截 jsp 文件，它无法实现对其他类型的文件的权限拦截，那么就要使用我们现在的Filter过滤器了。

Filter 的工作流程图：

首先，我们需要创建一个类去实现Filter接口，其中需要我们重写 doFilter 方法，该方法是专门用于进行权限检查的，只有满足条件的请求才可以放行。

package com.zjuedu.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.IOException;


public class AdminFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    /**
     * doFilter 方法，专门用于拦截请求，过滤响应。可以做权限检查
     * @param request
     * @param response
     * @param chain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpSession session = req.getSession();

        Object user = session.getAttribute("user");
        // 如果等于null，说明还没有登录
        if (user == null) {
            req.getRequestDispatcher("/login.jsp").forward(request, response);
            return;
        } else {
            // 让程序继续往下访问用户请求的资源【放行】
            chain.doFilter(request, response);
        }
    }

    @Override
    public void destroy() {

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

然后，跟配置 Servlet 程序一样，需要在 web.xml 中配置该 Filter 过滤器：

<!-- filter标签用于配置一个filter过滤器 -->
<filter>
    <!-- 给 filter 起一个名称 -->
    <filter-name>AdminFilter</filter-name>
    <!-- 配置 filter 的全类名 -->
    <filter-class>com.zjuedu.filter.AdminFilter</filter-class>
</filter>
<!-- filter-mapping 配置 Filter 过滤器的拦截路径 -->
<filter-mapping>
    <!-- filter-name 表示当前的拦截路径给哪个 filter 使用 -->
    <filter-name>AdminFilter</filter-name>
    <!-- url-pattern 配置拦截路径
        / 表示请求地址为: http://ip:port/工程路径/ 映射到IDEA的 web 目录
        /admin/* 表示拦截的请求地址为 http://ip:port/工程路径/admin/*
    -->
    <url-pattern>/admin/*</url-pattern>
</filter-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

此时配置完毕，客户端如果没有成功登录，只要访问任何 admin 目录下的内容都会被拦截。

小结：Filter 过滤器的使用步骤：

1. 编写一个类去实现 Filter 接口
2. 实现过滤方法 doFilter()
3. 到 web.xml 中去配置 Filter 的拦截路径

3. Filter的生命周期

Filter 的生命周期围绕着如下的顺序去执行方法【与Servlet基本一致】：

1. 构造器方法：Web工程启动的时候就开始执行
2. init 初始化方法：Web工程启动的时候就开始执行（紧随构造器方法）
3. doFilter 过滤方法：每次拦截到请求就会执行
4. destory 销毁方法：停止Web工程的时候就会执行

4. FilterConfig类

FilterConfig 类见明知意，它是 Filter 过滤器的配置文件类。
Tomcat 每次创建 Filter 的时候，同时也会创建该类对应的一个FilterConfig 类，这里包含了 Filter 配置文件的配置信息。

FilterConfig 类的作用就是获取 filter 过滤器的配置内容【与ServletConfig基本一致】

1. 获取在 web.xml 中配置的 Filter 的别名 filter-name
2. 获取在 web.xml 中配置的 init-param 初始化内容【常用】
3. 获取 ServletContext 对象

<filter>
    <!-- 给 filter 起一个名称 -->
    <filter-name>AdminFilter</filter-name>
    <!-- 配置 filter 的全类名 -->
    <filter-class>com.zjuedu.filter.AdminFilter</filter-class>
    <!-- 配置 filter 的初始化参数 -->
    <init-param>
        <param-name>username</param-name>
        <param-value>root</param-value>
    </init-param>
    <!-- 配置 filter 的初始化参数 -->
    <init-param>
        <param-name>url</param-name>
        <param-value>jdcb:mysql://localhost:3306/test</param-value>
    </init-param>
</filter>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 我们在AdminFilter类的init() 函数中做测试
@Override
public void init(FilterConfig filterConfig) throws ServletException {
     // 获取在web.xml 中为 Filter 设置的别名
     System.out.println("filter-name的值是：" + filterConfig.getFilterName());

     // 获取在web.xml 中配置的init-param初始化参数
     String username = filterConfig.getInitParameter("username");
     String url = filterConfig.getInitParameter("url");
     System.out.println("filter 初始化参数为：" + username);
     System.out.println("filter 初始化参数为：" + url);
     
     // 获取ServletContext 对象
     ServletContext servletContext = filterConfig.getServletContext();
     System.out.println(servletContext);
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

启动Tomcat，输出结果为：

5. FilterChain过滤器链

FilterChain 就是过滤器链，当涉及到多个过滤器时，工作方式如同函数调用一样，如下图：

这里通过定义一个Filter1、Filter2 过滤器和目标资源 target.jsp 来演示过滤器链：

Filter1 过滤器：

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

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Filter1 前置代码...");
        chain.doFilter(request, response);
        System.out.println("Filter1 后置代码...");
    }

    @Override
    public void destroy() { }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Filter2 过滤器：

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

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Filter2 前置代码...");
        chain.doFilter(request, response);
        System.out.println("Filter2 后置代码...");
    }

    @Override
    public void destroy() { }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在web.xml文件中进行配置：

<!-- filter在xml中的配置顺序，决定了filter链中的先后顺序 -->
<filter>
    <filter-name>Filter1</filter-name>
    <filter-class>com.zjuedu.filter.Filter1</filter-class>
</filter>
<filter-mapping>
    <filter-name>Filter1</filter-name>
    <url-pattern>/target.jsp</url-pattern>
</filter-mapping>
<!-- filter在xml中的配置顺序，决定了filter链中的先后顺序 -->
<filter>
    <filter-name>Filter2</filter-name>
    <filter-class>com.zjuedu.filter.Filter2</filter-class>
</filter>
<filter-mapping>
    <filter-name>Filter2</filter-name>
    <url-pattern>/target.jsp</url-pattern>
</filter-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

定义一个目标文件 target.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Target</title>
</head>
<body>
    <%
        System.out.println("target.jsp执行了...");
    %>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11

现在，启动Tomcat服务器，访问URL【http://localhost:8080/15_filter/target.jsp】：

再次强调：

1. 在过滤器链中的工作方式非常类似函数调用，只有通过了所有的Filter，才能访问到最终的资源。如果中间某个Filter没有满足过滤条件，则后续的Filter也不会再继续工作，直接返回。
2. Filter 在 web.xml 中配置的顺序决定了 Filter 在过滤器链中的前后位置。

6. Filter的拦截路径

6.1 精确匹配

<url-pattern>/xxx.yyy</url-pattern>
1

以上路径表示，请求的地址必须为：http://ip:port:/工程路径/xxx.yyy 才可以拦截到。

6.2 目录匹配

<url-pattern>/admin/*</url-pattern>
1

以上路径表示，请求的地址必须为：http://ip:port:/工程路径/admin/* 才可以拦截到。

6.3 后缀名匹配

<url-pattern>*.html</url-pattern>
1

或

<url-pattern>*.do</url-pattern>
1

或

<url-pattern>*.action</url-pattern>
1

以上路径表示，请求的地址必须以：.html | .do | .action 结尾才可以拦截到。
注意：后缀名匹配，一定不要以 / 打头，否则会报错！

Filter 过滤器它只关心请求的路径是否匹配，不关心请求的资源到底是否存在！！！