一篇搞定Java过滤器

jiezi

5 年前

我们可以通过使用前面的技术，做出一些简单的登陆注册以及配合数据库实现对数据增删改查的 Demo，程序是基本运行起来了，但是却存在着一个重大的安全问题，那就登陆权限验证，一般来说登陆的正确流程是这样的：用户在客户端发出请求 -> 后台判断是否登录 -> 是则不限制，否则跳转回登录页面，判断是否登录和我们前面所学习的 Header 中获取 referer 再判断达从而到防盗链的效果有相似的感觉，就是起一个判断过滤的样子，而 Filter 则是一个更好的解决这样问题的技术，当然强大的功能不止这一点，下面我们就好好来说一说！

过滤器，顾名思义就是起到过滤筛选作用的一种事物，只不过相较于现实生活中的过滤器，这里的过滤器过滤的对象是 客户端访问的 web 资源，也可以理解为一种预处理手段，对资源进行拦截后，将其中我们认为的杂质（用户自己定义的）过滤，符合条件的放行，不符合的则拦截下来

当然，过滤器既可以拦截 request，也可以拦截返回的 response，我们来看一张图

过滤器的本质就是一个实现了 Filter 接口的 Java 类

我们先自己创建一个类，实现 Filter 接口（javax.servlet），重写其中的所有方法

@WebFilter("/*")
public class FilterDemo1 implements Filter {public void destroy() { }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        // 放行代码
        chain.doFilter(req, resp);
    }

    public void init(FilterConfig config) throws ServletException {}}

我们先不探究其中的方法，我们先看一下如何配置 filter

<filter>
    <filter-name>filterDemo1</filter-name>
    <filter-class>package cn.ideal.web.filter.FilterDemo1</filter-class>
</filter>

<filter-mapping>
    <filter-name>filterDemo1</filter-name>
    <!-- 拦截路径 -->
    <url-pattern>/*</url-pattern>
</filter-mapping>

<filter-name></filter-name>：指定 filter 名字

<filter-class></filter-class>：指定 filter 全类名（带包名）

<filter-name></filter-name>：这里的标签是为了与上面 filter 中的名字对应，从而指向到对应的文件中

<url-pattern></url-pattern>：设置 filter 所拦截的路径 ※ 这里决定了什么样的资源会被过滤器拦截处理

格式	解释
/test.jsp	只有访问 test.jsp 这个资源的时候才会执行过滤器
/test/*	访问 test 下所有资源你的时候，执行过滤器
*.jsp	所有 jsp 格式的资源被访问的时候，执行过滤器
/*	任意资源被访问，均执行过滤器

由于过滤器内设置的是比较通用的一些设置，所以一般来说使用 /* 这种格式，不过也可以根据需求情况选择

拦截方式配置 也就是 资源被访问的形式，有这么几个属性

REQUEST：默认值，浏览器直接请求资源
FORWARD：转发访问资源 : RequestDispatcher.forward();
INCLUDE：包含访问资源 : RequestDispatcher.include();
ERROR：错误跳转资源 : 被声明式异常处理机制调用的时候

补充：声明式异常处理即：在 web.xml 中通过配置来确定不同的异常类型将如何被处理，最后跳转到哪个页面，也就是我们常常看到的一些 404 错误页面

<error-page>
      <!-- 异常的类 -->
         <exception-type>xxx</exception-type>
      <!-- 异常发生时跳转的页面 -->
        <location>xxx</location>
</error-page>

与 servlet 相似的配置，我们可以指定它的名字和拦截路径

@WebFilter("filterName="FilterDemo1",urlPatters="/*")

但是直接在类上声明注解，显然那我们是不需要指定其名字的，而通过查看源码又可以知道，urlPatters 又可以被 value 指定，而 value 又可以省略，所以我们可以简写为

@WebFilter("/*")

若想在 filter 注解中配置 dispatcher，我们需要设置 dispatcherTypes 属性

@WebFilter(value = "/*",dispatcherTypes ={DispatcherType.FORWARD,DispatcherType.FORWARD} )

讲完了配置，下面我们就回归主题来说一说过滤器的生命周期，也就是上面实现接口而重写的那些方法们

首先是 init(FilterConfig config) 方法和 void destroy() 方法，Servlet 也有这两个方法，两者分别在 服务器启动和关闭的 时候被 创建以及销毁 ，两者均执行一次，用于 加载以及释放资源

其实就这两个方法来说在 Servlet 的基础上还是很好理解的

再者就是我们过滤器的核心方法了：

void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)

doFilter 方法就是我们真正进行拦截的方法，通过前两个参数我们可以知道，不论是 Request 亦或是 Respone 我们都可以对其进行过滤操作，那么第三个参数是什么意思呢？

我们打开 FilterChain 的源码

public interface FilterChain {void doFilter(ServletRequest var1, ServletResponse var2) throws IOException, ServletException;
}

嗯！FilterChain 是一个接口，接口内也定义了一个 doFilter 方法，它存在的意义是什呢？

这是一种链式结构，我们在这里称作过滤器链，其作用就是为了配置多个过滤器，多个过滤器下的执行流程是这样的

那么，多个过滤器谁前谁后呢？这还与我们前面的配置有关

注解配置：按照类名字符串比较，值小的先执行
- Eg：AFilterDemo 优先于 BFilterDemo
web.xml 配置：<filter-mapping>中谁在上面，谁优先执行

执行过滤器
执行放行后的资源，可能是下一个过滤器，也可能是 web 资源(JSP/Servlet)
执行过滤器放行代码 chain.doFilter(req, resp); 下边的代码

我们前面的的知识已经能简单的满足我们对于登录以及简单注册的实现，但是如果我们知道地址，直接通过 url 访问一些资源，很显然这是很不合理的，所以我们需要对登录状态进行验证，未登录则转发到的登录界面，登录则可以依据登录状态自由访问一些页面

我们写一个简单的模拟程序，为了可读性，以及篇幅问题，我们省略数据库连接的部分，采用固定的密码

这是 index.jsp 页面，也就是需要登录后才能放开访问权限的页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>$Title$</title>
</head>
<body>
<h1> 这是首页，只有登录后才能查看 </h1>
</body>
</html>

这是 login.jsp 页面，也就是登录页面，非常简单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/web-test/loginServlet" method="post">
    <table>
        <tr>
            <td> 用户名:</td>
            <td><input type="text" name="username"></td>
        </tr>
        <tr>
            <td> 密码:</td>
            <td><input type="password" name="password"></td>
        </tr>
        <tr>
            <td><input type="submit" value="登录"></td>
        </tr>
    </table>
</form>
</body>
</html>

我们创一个 domain 包，写一个 User 实体，补充其 get、set 方法

package cn.ideal.domain;

public class User {
    private String username;
    private String password;

    public String getUsername() {return username;}

    public void setUsername(String username) {this.username = username;}

    public String getPassword() {return password;}

    public void setPassword(String password) {this.password = password;}

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

下面开始编写 LoginServlet，也就是处理登录验证问题的代码

package cn.ideal.web.servlet;

import cn.ideal.dao.UserDao;
import cn.ideal.domain.User;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 设置编码
        request.setCharacterEncoding("utf-8");

        // 获取请求参数
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        // 封装 user 对象
        User loginUser = new User();
        loginUser.setUsername(username);
        loginUser.setPassword(password);

        UserDao dao = new UserDao();
        User user = dao.login(loginUser);

        if (user == null){
            // 登陆失败
            request.getRequestDispatcher("/failServlet").forward(request,response);
        }else{
            // 登录成功
            request.getSession().setAttribute("user",user);
            request.getRequestDispatcher("/index.jsp").forward(request,response);
        }

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doPost(request,response);
    }
}

我们根据 user 是否等于 null 来判断用户名密码是否正确，那么我们你就来写一下这个返回了一个 User 对象的 login 方法

我们在 dao 层中创建一个 UserDao 类，正式一些的项目会写成接口的形式，在 impl 层中再写实现，为了掩饰我们简化这一步

package cn.ideal.dao;

import cn.ideal.domain.User;

public class UserDao {public User login(User loginUser) {// 定义真实用户名密码(代替数据库读取)
        String trueUsername = "admin";
        String truePassword = "admin";

        if (loginUser.getUsername().equals(trueUsername) && loginUser.getPassword().equals(truePassword)) {
            // 登陆成功
            return loginUser;
        } else {return null;}
    }
}

关键来了，这也就是我们所讲的过滤器方法，这里所需要注意的就是登陆成功后，记得写入状态

request.getSession().setAttribute("user",user);

package cn.ideal.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter("/*")
public class LoginFilter implements Filter {public void destroy() { }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        // 获取资源请求路径
        String requestURI = request.getRequestURI();

        // 排除包含登录确实所需要的资源，给予放行
        if (requestURI.contains("/login.jsp") || requestURI.contains("/loginServlet")) {chain.doFilter(request,response);
        }else{
            // 不包含，即验证用户是否已经登录
            Object user = request.getSession().getAttribute("user");
            if (user != null){
                // 登陆了，放行
                chain.doFilter(request,response);
            }else{
                // 没有登录，跳转回登录页面
                request.getRequestDispatcher("/login.jsp").forward(request,response);
            }
        }
    }

    public void init(FilterConfig config) throws ServletException {}}

如果我们想要对用户提交的一些信息进行过滤，在 servlet 中进行一些代码的编写也算一种方法，但是最为合适的还是 fiter，它更加通用，下面我们使用代理模式增强 request 从而使用 filter 进行敏感词的过滤

我们就在刚才的 index 页面上加以修改

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>$Title$</title>
</head>
<body>
<h1> 这是首页，只有登录后才能查看 </h1>
<form action="/web-test/replaceServlet" method="post">
    <table>
        <tr>
            <td><input type="text" name="words"></td>
        </tr>
        <tr>
            <td><input type="submit" value="敏感字检测"></td>
        </tr>
    </table>
</form>
</body>
</html>

我们把传入的参数读取进来

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {request.setCharacterEncoding("UTF-8");
        String words = request.getParameter("words");
        System.out.println(words);
    }

package cn.ideal.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.*;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

@WebFilter("/*")
public class ReplaceFilter implements Filter {public void destroy() { }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        // 创建代理对象，增强 getParameter
        ServletRequest proxy_req = (ServletRequest) Proxy.newProxyInstance(req.getClass().getClassLoader(), req.getClass().getInterfaces(), new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 判断是不是 getParameter 方法
                if (method.getName().equals("getParameter")){
                    // 获取返回值
                    String value = (String)method.invoke(req, args);
                    if (value != null){for (String s : list){if (value.contains(s)){value = value.replaceAll(s,"***");
                            }
                        }
                    }
                    return value;
                }
                return method.invoke(req,args);
            }
        });
        chain.doFilter(proxy_req, resp);
    }

    private List<String> list = new ArrayList<String>();

    public void init(FilterConfig config) throws ServletException {

        try {
            // 获取文件真实路径
            ServletContext servletContext = config.getServletContext();
            String realPath = servletContext.getRealPath("/WEB-INF/classes/replace.txt");
            // 读取文件
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(realPath),"UTF-8"));
            // 将每一行数据添加到 list 中
            String line = null;
            while((line = br.readLine())!=null){list.add(line);
            }
        } catch (FileNotFoundException e) {e.printStackTrace();
        } catch (IOException e) {e.printStackTrace();
        }
    }
}

如果内容中有什么不足，或者错误的地方，欢迎大家给我留言提出意见, 蟹蟹大家！^_^

如果能帮到你的话，那就来关注我吧！（系列文章均会在公众号第一时间更新）

在这里的我们素不相识，却都在为了自己的梦而努力 ❤

一个坚持推送原创 Java 技术的公众号：理想二旬不止

一篇搞定Java过滤器

Filter：过滤器

引言

(一) 过滤器概述

(二) 第一个过滤器程序

(三) filter 配置

第一种：web.xml 配置

filter

filter-mapping

拦截路径设置

拦截方式配置：dispatcher

第二种：使用注解配置

(四) 过滤器的生命周期

过滤器的简单执行流程

(五) Filter 的应用

(1) 登录权限验证

(2) 敏感词过滤

结尾：