12
0
0

案例2-手把手教程-过滤器与记住我

2026-11-12
2026-11-12

案例 2:手把手教程-登录加入过滤器、Cookie 与自动登录

目标:在案例 1 的 login-demo 上继续改造,账号从内存列表迁移到 MySQL,增加登录状态校验过滤器、7 天自动登录与退出登录。

环境:JDK 21、Maven、Tomcat 10.1、MySQL 8。pom 中 jakarta.servlet-api 写的是 6.1,对应 Tomcat 11;在 10.1 上运行需要改成 6.0.0。

动手前先把工程复制一份,或者 git 提交一次。本次修改 6 个已有文件、新增 8 个文件,出错时按步骤回退,比通篇排查省时间。

零、改造范围与文件职责

改造后的目录如下,编号标出每个文件的位置与作用:

login-demo
├── pom.xml                          ① 声明依赖与打包方式
└── src/main
    ├── java/com/iooi/login
    │   ├── User.java                 ② 补充无参构造与 getter/setter
    │   ├── login.java                ③ 改为数据库校验并写入 Cookie
    │   ├── LogoutServlet.java        ④ 新增:退出登录处理
    │   ├── util/DBUtil.java          ⑤ 新增:连接获取与资源释放
    │   ├── util/SessionUtil.java     ⑥ 新增:集中写入登录会话信息
    │   ├── dao/UserDao.java          ⑦ 新增:账号查询与密码校验
    │   ├── dao/TokenDao.java         ⑧ 新增:自动登录凭证的增删查
    │   ├── filter/LoginFilter.java   ⑨ 新增:未登录请求拦截
    │   ├── filter/EncodingFilter.java ⑩ 新增:统一字符编码
    │   └── filter/AutoLoginFilter.java ⑪ 新增:依据 Cookie 恢复登录状态
    └── webapp
        ├── login.jsp                  ⑫ 增加自动登录选项与提示读取
        ├── welcome.jsp                ⑬ 移除页面内登录判断
        └── WEB-INF/web.xml            ⑭ 注册过滤器并设置会话超时

一共 14 个文件,按职责分为六组。分组的意义在于:每组只做一件事,出问题时能定位到某一层,而不是在一堆代码里翻找。

配置层。pom.xml 声明依赖和打包方式,决定 MySQL 驱动是否被打进 WEB-INF/lib;web.xml 负责注册过滤器、设置会话超时和欢迎页。这两个文件不写 Java 代码,但决定了程序运行时能不能找到类和页面。

数据访问层。DBUtil 只提供连接的获取与释放,不出现任何 SQL;UserDao 负责账号表的查询;TokenDao 负责自动登录凭证的增加、查询和删除。这一层只与数据库打交道,不接触 HttpServletRequest、HttpServletResponse 这类 Web 对象。

控制层。login 接收表单参数、调用 UserDao 校验、决定页面跳转;LogoutServlet 负责清理登录状态。控制层负责流程,不写 SQL。

会话辅助。SessionUtil 把登录成功后需要写入 Session 的属性集中在一个方法里。登录和自动登录都要写同样的内容,集中定义可以避免两处遗漏或不一致。

过滤器层。EncodingFilter 统一字符编码;AutoLoginFilter 在请求进入时尝试用 Cookie 恢复身份;LoginFilter 拦截没有登录状态的请求。

页面层。login.jsp 提交表单并显示提示信息,welcome.jsp 只负责展示数据。

这六组的依赖是单向的:页面依赖控制层,控制层依赖数据访问层,数据访问层依赖数据库。过滤器位于最外层,只处理请求的生命周期,不参与业务判断。这种结构的好处很直接:将来把密码改成散列存储,只需要改 UserDao,页面和过滤器都不用动。

三个过滤器在请求进入时的执行顺序如下:

请求 → EncodingFilter → AutoLoginFilter → LoginFilter → welcome.jsp
                        (有 Cookie 时恢复身份)  (无登录状态时拦截)

顺序不是随意排的。EncodingFilter 必须最先执行,因为后续任何代码只要读取参数,编码就必须已经确定;AutoLoginFilter 必须排在 LoginFilter 之前,否则请求先被判定为未登录,自动登录没有执行机会。

一、建库建表

先建两张表:t_user 保存账号,t_login_token 保存自动登录凭证。

分表的理由是两者的生命周期不同。账号是长期数据,凭证只在有效期内有意义;退出登录只需要删除凭证记录,账号数据不受影响。如果合并成一张表,就得在用户表里加 token、token 过期时间这些字段,用户数量一多,查询账号时还会把这些无关字段一起读出来。

CREATE DATABASE IF NOT EXISTS login_demo DEFAULT CHARACTER SET utf8mb4;
USE login_demo;

DROP TABLE IF EXISTS t_login_token;
DROP TABLE IF EXISTS t_user;

CREATE TABLE t_user (
    id       INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(50) NOT NULL,
    role     VARCHAR(20) NOT NULL DEFAULT 'user'
);

INSERT INTO t_user (username, password, role) VALUES
('admin', '123456', 'admin'),
('bam',   '123456', 'user');

CREATE TABLE t_login_token (
    id          INT PRIMARY KEY AUTO_INCREMENT,
    username    VARCHAR(50) NOT NULL,
    token       CHAR(36)  NOT NULL UNIQUE,
    expire_time DATETIME  NOT NULL,
    INDEX idx_token (token)
);

[!TIP]
建表语句里有几处细节值得说明:

username 加了 UNIQUE 约束,保证同一账号不能重复注册,后续做注册功能时可以直接依赖这个约束,不必在 Java 里先查一次再插入。

t_login_token 的 token 字段也加了 UNIQUE,因为它是查询条件,重复值会导致查出不只一条记录。

最后给 token 建了索引。凭证表虽然数据量不大,但每次请求都要按 token 查询,有索引可以直接定位,避免全表扫描。

字符集用 utf8mb4,它支持完整的 Unicode,包括 emoji 和部分生僻汉字;utf8 在 MySQL 中实际上是三字节编码,遇到四字节字符会报错或截断。

密码按明文存储,仅限练习。数据库一旦泄露,所有账号的密码直接暴露,而用户往往在多个站点复用同一个密码,会连带影响其他账号。密码校验逻辑因此全部集中在 UserDao,等学了散列之后只改这一处:注册时存散列值,登录时把输入算一次散列再比对。

验证:执行 ​SELECT username, role FROM t_user;,应返回 admin、bam 两行。

二、pom.xml 加驱动

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.4.0</version>
</dependency>

依赖的 scope 决定了打包行为。jakarta.servlet-api 必须写 provided,mysql 驱动不能写 provided。前者由 Tomcat 提供,打进 war 会和容器的类冲突;后者一旦写成 provided,编译能过,运行时 WEB-INF/lib 里却没有这个 jar,启动报 ClassNotFoundException。

加完刷新 Maven,或执行 mvn -U clean compile。IDEA 的代码提示依赖 Maven 的依赖索引,不刷新时 com.mysql.cj.jdbc.Driver 会标红,但实际打包可能仍然成功,这种“编辑器报错、程序能跑”的不一致最容易误判。

验证:External Libraries 中出现 mysql-connector-j-8.4.0.jar;打包后 target/login-demo/WEB-INF/lib 下也能看到该文件。

三、写 DBUtil

JDBC 访问数据库的完整流程是六步:加载驱动、获取连接、创建语句对象、执行 SQL、处理结果、释放资源。DBUtil 只负责第一步和第六步,中间四步由 DAO 完成。

package com.iooi.login.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class DBUtil {

    private static final String URL =
            "jdbc:mysql://localhost:3306/login_demo"
                    + "?useSSL=false"
                    + "&serverTimezone=Asia/Shanghai"
                    + "&characterEncoding=utf8"
                    + "&allowPublicKeyRetrieval=true";

    private static final String USERNAME = "root";
    private static final String PASSWORD = "root";

    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            throw new ExceptionInInitializerError("MySQL 驱动没加载上:" + e.getMessage());
        }
    }

    private DBUtil() {
    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USERNAME, PASSWORD);
    }

    public static void close(ResultSet rs, Statement st, Connection conn) {
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException ignored) {
        }
        try {
            if (st != null) {
                st.close();
            }
        } catch (SQLException ignored) {
        }
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException ignored) {
        }
    }

    public static void close(Statement st, Connection conn) {
        close(null, st, conn);
    }
}

驱动注册写在静态代码块里。静态块在类第一次被加载时执行,且只执行一次,正好符合“驱动只需注册一次”的要求。如果写在构造方法或普通方法里,每次获取连接都会重复注册,早期 JDBC 版本会因此产生重复驱动实例。

URL 后面的参数各自对应一个常见故障:

参数 缺少时的表现
useSSL=false 连接时输出大量 SSL 警告,启动变慢
serverTimezone=Asia/Shanghai 报 The server time zone value ... is unrecognized,服务器时区为中文时尤其常见
characterEncoding=utf8 中文写入数据库后变成问号
allowPublicKeyRetrieval=true MySQL 8 报 Public Key Retrieval is not allowed

这里用 DriverManager 直接获取连接,每次查询新建、用完关闭。优点是实现简单,缺点是并发量上来之后频繁建立连接开销很大。生产环境通常用连接池复用连接;连接管理全部封在 DBUtil,替换成 Druid 或 HikariCP 时 DAO 一行都不用改,这也是单独抽出工具类的原因。

先用一个临时 main 确认连接可用:

public static void main(String[] args) throws Exception {
    System.out.println(DBUtil.getConnection());
}

验证:打印出连接对象再继续。连接拿不到时先排查驱动、账号密码和库名,后面的步骤全部依赖这一环。

四、改 User,写 UserDao

User 类需要补上无参构造和 setter。原类只有带参构造,从 ResultSet 装配对象时无法先创建空对象再逐个填字段。

这也是 JavaBean 的基本约定:公开的无参构造、私有字段、公有的 getter 和 setter。很多框架依赖这套约定,例如 EL 表达式取值时调用的是 getter 而不是直接读字段,MyBatis 反射装配对象时要求有无参构造。

package com.iooi.login;

public class User {

    private String username;
    private String password;
    private String role;

    /** 新增:给"先建空对象、再 setter 填值"用 */
    public User() {
    }

    public User(String username, String password, String role) {
        this.username = username;
        this.password = password;
        this.role = role;
    }

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

    public String getRole() {
        return role;
    }

    /** 新增 */
    public void setRole(String role) {
        this.role = role;
    }
}

字段名和 getter 名必须对应。JSP 中写 ${sessionScope.user.username},容器实际调用的是 getUsername();如果把字段改成 userName 却保留 getUsername(),页面仍然能取到值,但如果只改 getter 不改字段,装配时又会用错列名。

4.1 什么是 DAO

DAO 是 Data Access Object 的缩写,中文一般叫数据访问对象。它的职责只有一条:在数据库记录和 Java 对象之间做转换。

向上,它接收 Java 参数,返回实体对象;向下,它拼接 SQL、执行、读取结果集。项目里所有 SQL 语句都集中在这一层。

分层之后,一次请求的调用关系是这样的:

JSP(显示数据)
  ↓
Servlet(接收参数、组织流程)
  ↓
DAO(执行 SQL、装配对象)
  ↓
数据库

为什么要单独抽一层,而不是在 Servlet 里直接写 SQL,有四个原因:

  • 职责分离。Servlet 关注“请求从哪来、参数对不对、失败跳哪个页面”,DAO 关注“这条 SQL 怎么写”。两者混在一起,一个方法里既有判断又有数据库操作,读起来很费劲。
  • 改动范围可控。换数据库、改表名、加字段,只需要改 DAO;页面和控制层不受影响。密码从明文换成散列,也只动 DAO 内部的两个方法。
  • 便于测试。DAO 可以脱离 Web 容器单独调用,写一个 main 方法就能验证 SQL 是否正确,不用启动 Tomcat、不用登录。
  • 避免资源泄漏。Connection、PreparedStatement、ResultSet 的关闭逻辑集中在 DAO 的 finally 中,不会因为某个 Servlet 忘了关而泄漏。

DAO 的命名有约定:类名由实体名加 Dao 组成,方法名体现具体动作,例如 findByUsername、findByUsernameAndPassword、insert、deleteByToken。返回值用实体对象或 null,集合查询返回 List。

一个容易被忽略的约定是不要返回 ResultSet。ResultSet 与 Connection 绑定,一旦方法结束、连接关闭,结果集随之失效;返回给调用方只会得到一个无法读取的对象。装配成实体再返回,才能真正脱离数据库连接。

本案例没有引入 Service 层。Service 的职责是组合多个 DAO、处理事务和业务规则;目前的登录只涉及一次查询,加 Service 只会多一层转发。等做注册、文章发布这类需要多条 SQL 的功能时,再引入 Service 比较合适。

4.2 账号查询

账号查询放在 UserDao,密码比对只出现在这一个类里。

package com.iooi.login.dao;

import com.iooi.login.User;
import com.iooi.login.util.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class UserDao {

    /** 登录校验:用户名和密码同时对上才返回 User,否则 null */
    public User findByUsernameAndPassword(String username, String password) {
        String sql = "SELECT username, password, role FROM t_user "
                + "WHERE username = ? AND password = ?";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            conn = DBUtil.getConnection();
            ps = conn.prepareStatement(sql);
            ps.setString(1, username);
            ps.setString(2, password);
            rs = ps.executeQuery();
            return rs.next() ? toUser(rs) : null;
        } catch (Exception e) {
            throw new RuntimeException("登录查询失败", e);
        } finally {
            DBUtil.close(rs, ps, conn);
        }
    }

    /** 只按用户名查:自动登录时手里只有 token 换来的用户名 */
    public User findByUsername(String username) {
        String sql = "SELECT username, password, role FROM t_user WHERE username = ?";

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            conn = DBUtil.getConnection();
            ps = conn.prepareStatement(sql);
            ps.setString(1, username);
            rs = ps.executeQuery();
            return rs.next() ? toUser(rs) : null;
        } catch (Exception e) {
            throw new RuntimeException("按用户名查询失败", e);
        } finally {
            DBUtil.close(rs, ps, conn);
        }
    }

    /** ResultSet → User,抽出来避免写两遍 */
    private User toUser(ResultSet rs) throws Exception {
        User user = new User();
        user.setUsername(rs.getString("username"));
        // 查出来的密码不往 Session 里带,这里抹掉
        user.setPassword(null);
        user.setRole(rs.getString("role"));
        return user;
    }
}

SQL 使用 PreparedStatement 加占位符,不用字符串拼接。拼接的写法是 "WHERE username='" + username + "'",当用户名传入 ' OR '1'='1 时,最终语句的 WHERE 条件变成恒真,密码校验直接失效,这就是 SQL 注入。PreparedStatement 把参数作为独立的值传给数据库,参数内容不参与 SQL 语法解析,即使包含引号和 OR 也只会被当作普通字符串。

资源在 finally 中按 ResultSet、Statement、Connection 的顺序关闭。这个顺序与创建顺序相反:后创建的先关闭。漏关连接时,并发请求积累到一定数量,MySQL 会报 Too many connections,而报错位置通常不在出问题的那次查询上,排查起来很麻烦。

装配结果时把 password 置为 null。改造前的 login 把整个 User 对象放进 Session,密码会跟着登录态一直留在服务端内存里;一旦有人导出堆转储或者打印 Session 内容,密码就随之暴露。登录校验完成之后,密码字段没有继续保留的必要。

验证:mvn -q compile 通过;用临时 main 调用 findByUsernameAndPassword("admin", "123456"),返回对象而不是 null。

五、改 login,账号改为数据库校验

doPost 中只替换校验部分:原来遍历 USERS 的循环换成一次查询,取参、失败提示、成功跳转的流程保持不变。

package com.iooi.login;

import com.iooi.login.dao.UserDao;
import com.iooi.login.util.SessionUtil;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;

@WebServlet("/login")
public class login extends HttpServlet {

    private final UserDao userDao = new UserDao();

    /** 直接敲地址访问 /login 是 GET,没有 doGet 会报 405 */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.sendRedirect(req.getContextPath() + "/login.jsp");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {

        req.setCharacterEncoding("UTF-8");

        String username = req.getParameter("username");
        String password = req.getParameter("password");

        if (isBlank(username) || isBlank(password)) {
            req.setAttribute("errMsg", "用户名和密码不能为空");
            req.setAttribute("username", username);
            req.getRequestDispatcher("/login.jsp").forward(req, resp);
            return;
        }

        username = username.trim();

        // 原来遍历 USERS 的 for 循环,换成这一句
        User matched = userDao.findByUsernameAndPassword(username, password);

        if (matched == null) {
            req.setAttribute("errMsg", "用户名或密码错误,请重新输入");
            req.setAttribute("username", username);
            req.getRequestDispatcher("/login.jsp").forward(req, resp);
            return;
        }

        // 登录成功:先销毁旧 Session,再建新的
        HttpSession oldSession = req.getSession(false);
        if (oldSession != null) {
            oldSession.invalidate();
        }
        HttpSession session = req.getSession(true);
        SessionUtil.fillLoginSession(session, matched);

        resp.sendRedirect(req.getContextPath() + "/welcome.jsp");
    }

    private boolean isBlank(String s) {
        return s == null || s.trim().isEmpty();
    }
}

登录后要写入 Session 的属性集中到 SessionUtil,登录和自动登录两处共用:

package com.iooi.login.util;

import com.iooi.login.User;
import jakarta.servlet.http.HttpSession;

import java.util.Arrays;
import java.util.List;

public class SessionUtil {

    /** 登录成功后统一往 Session 放的东西,只在这里定义一次 */
    public static void fillLoginSession(HttpSession session, User user) {
        session.setAttribute("user", user);
        session.setAttribute("menus", menusOf(user));
    }

    private static List<String> menusOf(User user) {
        if ("admin".equals(user.getRole())) {
            return Arrays.asList("首页", "设置", "用户管理", "网站配置", "文章审核");
        }
        return Arrays.asList("首页", "设置", "我的文章", "我的主页", "我的收藏");
    }
}

5.1 请求转发与重定向的区别

登录失败用 forward,登录成功用 sendRedirect,两者是完全不同的机制:

对比项 请求转发 forward 重定向 sendRedirect
发生位置 服务器内部 浏览器重新发起
请求次数 1 次 2 次
地址栏 不变,仍显示 /login 变成目标地址
request 域数据 保留 丢失
能否跳转到外部站点 不能 能
典型用途 校验失败后回显提示 操作成功后跳转,避免刷新重复提交

关键差别在于 request 域的数据是否保留。 失败场景必须用 forward,因为 setAttribute("errMsg", ...) 存的数据只在当前 request 中有效,重定向之后浏览器发的是新请求,提示信息会丢。成功场景用重定向,是因为地址栏会变成 welcome.jsp,用户刷新页面时不会重复提交表单。

5.2 Session 如何识别同一个用户

HTTP 本身是无状态协议,两次请求之间没有关联。Session 能在多次请求之间保留数据,靠的是一个叫 JSESSIONID 的 Cookie。

第一次访问时,服务器创建 Session 对象,放进一个以 ID 为键的 Map,并在响应头里写入 Set-Cookie: JSESSIONID=xxx。浏览器后续请求会自动带上这个 Cookie,服务器据此找到对应的 Session 对象。

几个相关结论:

  • Session 数据存在服务器内存,浏览器只持有编号。关掉浏览器后编号丢失,服务器上的对象要等到超时时间到达才被回收。
  • 超时指“指定时间内没有任何请求” 。用户关掉浏览器不算超时,服务器无法感知这个动作。
  • 登录时更换 Session ID 用于防止会话固定。如果登录前后使用同一个 ID,攻击者在用户登录前获取该 ID,等用户登录后就能凭它获得已登录状态。
  • 重启 Tomcat 会丢失全部 Session。内存中的 Session 不持久化,用户需要重新登录;改用 Redis 集中存储才能解决。

验证:admin / 123456 进入 welcome.jsp 并显示管理员菜单;密码错误时停在登录页,红字提示,用户名保留在输入框。

// 写:放进响应头 Set-Cookie
Cookie cookie = new Cookie("remember", token);
cookie.setMaxAge(7 * 24 * 60 * 60);      // 单位秒;-1 是关浏览器就失效
cookie.setPath("/login-demo");           // 哪个路径下才发送
cookie.setHttpOnly(true);                // JS 读不到
response.addCookie(cookie);

// 读:可能为 null(第一次访问就是 null)
Cookie[] cookies = request.getCookies();

// 删:没有 delete,把 MaxAge 设 0 再写一遍就是删
Cookie kill = new Cookie("remember", "");
kill.setMaxAge(0);
kill.setPath("/login-demo");
response.addCookie(kill);

Cookie 只能放 UUID 这类无意义的标识,不能放角色、余额、密码这类可信数据。它存在浏览器端,用户可以查看、修改和删除。

Cookie 的几个属性需要区分清楚:

属性 作用
Name / Value 键值对,value 只接受 ASCII,中文要编码
Domain 生效的域名,默认是当前域名
Path 生效的路径前缀,只有匹配的请求才会携带
Max-Age 有效秒数;负数表示会话 Cookie,关闭浏览器即失效;0 表示立即删除
HttpOnly 禁止 JavaScript 读取,降低 XSS 窃取风险
Secure 只在 HTTPS 连接中发送

按有效期可以分成两类。Max-Age 为负数的叫会话 Cookie,只存在于浏览器进程内存中,关掉浏览器就消失;设置了正数的是持久 Cookie,会写入磁盘,重启浏览器仍然存在。JSESSIONID 默认是会话 Cookie,这正是“关掉浏览器再打开需要重新登录”的原因。

Session 和 Cookie 的关系可以概括为:Session 的数据在服务器,Cookie 只是传递编号的载体。用户自己的自动登录 Cookie 与 JSESSIONID 是两个独立的东西,前者用于长期免登录,后者用于当次会话定位。

6.2 写 TokenDao

package com.iooi.login.dao;

import com.iooi.login.util.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.time.LocalDateTime;

public class TokenDao {

    public void save(String username, String token, LocalDateTime expireTime) {
        String sql = "INSERT INTO t_login_token (username, token, expire_time) VALUES (?, ?, ?)";
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = DBUtil.getConnection();
            ps = conn.prepareStatement(sql);
            ps.setString(1, username);
            ps.setString(2, token);
            ps.setTimestamp(3, Timestamp.valueOf(expireTime));
            ps.executeUpdate();
        } catch (Exception e) {
            throw new RuntimeException("保存 token 失败", e);
        } finally {
            DBUtil.close(ps, conn);
        }
    }

    /** token 换用户名;无效或过期返回 null */
    public String findUsernameByToken(String token) {
        String sql = "SELECT username FROM t_login_token "
                + "WHERE token = ? AND expire_time > NOW()";
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DBUtil.getConnection();
            ps = conn.prepareStatement(sql);
            ps.setString(1, token);
            rs = ps.executeQuery();
            return rs.next() ? rs.getString("username") : null;
        } catch (Exception e) {
            throw new RuntimeException("查询 token 失败", e);
        } finally {
            DBUtil.close(rs, ps, conn);
        }
    }

    public void deleteByToken(String token) {
        String sql = "DELETE FROM t_login_token WHERE token = ?";
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = DBUtil.getConnection();
            ps = conn.prepareStatement(sql);
            ps.setString(1, token);
            ps.executeUpdate();
        } catch (Exception e) {
            throw new RuntimeException("删除 token 失败", e);
        } finally {
            DBUtil.close(ps, conn);
        }
    }

    public void deleteByUsername(String username) {
        String sql = "DELETE FROM t_login_token WHERE username = ?";
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = DBUtil.getConnection();
            ps = conn.prepareStatement(sql);
            ps.setString(1, username);
            ps.executeUpdate();
        } catch (Exception e) {
            throw new RuntimeException("清理旧 token 失败", e);
        } finally {
            DBUtil.close(ps, conn);
        }
    }
}

过期判断写在 SQL 里(expire_time > NOW()),不在 Java 中比较时间。这样做有两个好处:判断与查询在同一次数据库交互中完成,不需要先把记录取回再判断;时间基准统一由数据库提供,不受应用服务器时区或时钟偏差影响。

token 使用 UUID 而不是自增 ID。自增 ID 可以被顺序猜测,攻击者拿到一个合法 token 后,改一个数字就可能命中别人的凭证;UUID 是随机生成的 128 位值,碰撞概率可以忽略。

6.3 login 中补四段代码

import 区增加相关类型:

import com.iooi.login.dao.TokenDao;

import jakarta.servlet.http.Cookie;
import java.time.LocalDateTime;
import java.util.UUID;

类开头增加常量与 DAO 实例:

    /** Cookie 名只在这里写一次,过滤器引用同一个常量 */
    public static final String REMEMBER_COOKIE = "remember";
    private static final int REMEMBER_DAYS = 7;

    private final TokenDao tokenDao = new TokenDao();

doPost 取参数处,多取一个勾选框:

        String rememberMe = req.getParameter("rememberMe");

登录成功后、重定向之前处理 Cookie:

        if ("1".equals(rememberMe)) {
            saveRememberCookie(req, resp, username);
        } else {
            removeRememberCookie(req, resp);
        }

再补三个方法:

    /** 生成 token、入库、写 Cookie */
    private void saveRememberCookie(HttpServletRequest req,
                                    HttpServletResponse resp,
                                    String username) {
        // 先清掉这个用户之前的旧 token,别让一个人攒一堆有效凭证
        tokenDao.deleteByUsername(username);

        String token = UUID.randomUUID().toString();
        tokenDao.save(username, token, LocalDateTime.now().plusDays(REMEMBER_DAYS));

        Cookie cookie = new Cookie(REMEMBER_COOKIE, token);
        cookie.setMaxAge(REMEMBER_DAYS * 24 * 60 * 60);
        // 必须显式指定,默认路径是 /login-demo/login,换个页面就收不到了
        cookie.setPath(req.getContextPath());
        cookie.setHttpOnly(true);
        resp.addCookie(cookie);
    }

    /** 没勾记住我,或者退出登录:把 Cookie 删掉 */
    public static void removeRememberCookie(HttpServletRequest req, HttpServletResponse resp) {
        Cookie cookie = new Cookie(REMEMBER_COOKIE, "");
        cookie.setMaxAge(0);
        cookie.setPath(req.getContextPath());
        resp.addCookie(cookie);
    }

    /** 记住上次登录的用户名,只用于表单回填,不含任何凭证 */
    private void saveLastUsernameCookie(HttpServletRequest req,
                                        HttpServletResponse resp,
                                        String username) {
        Cookie cookie = new Cookie("lastUsername", username);
        cookie.setMaxAge(30 * 24 * 60 * 60);
        cookie.setPath(req.getContextPath());
        cookie.setHttpOnly(true);
        resp.addCookie(cookie);
    }

最后把用户名回填的调用放在 if/else 之后、重定向之前:

        saveLastUsernameCookie(req, resp, username);

三个细节。

Cookie 的 Path 不设置时,默认取当前请求路径的上一级目录。登录接口是 /login-demo/login,默认值恰好是 /login-demo;一旦接口路径改成 /login-demo/user/login,默认 Path 会变成 /login-demo/user,浏览器就不再向 welcome.jsp 发送这个 Cookie,表现为“登录时写入了、下一页读不到”。

Cookie 的 value 不能包含中文、空格、分号、逗号。用户名回填因此只对 ASCII 账号有效;中文账号需要写入前用 URLEncoder 编码,读取时再解码,否则写入阶段就会抛 IllegalArgumentException。

token 存 UUID 而不是用户名。Cookie 可被手工修改,如果存 username=admin,任何人改一下就成了管理员;UUID 改了查不到记录,等同于未登录。

验证:勾选自动登录后登录,F12 → Application → Cookies → localhost,应出现 JSESSIONID、remember、lastUsername 三条,其中 remember 的 Expires 是 7 天后,而不是 Session。

七、写 LogoutServlet

退出需要清理三处:数据库中的 token、Session、浏览器中的 Cookie。

package com.iooi.login;

import com.iooi.login.dao.TokenDao;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;

@WebServlet("/logout")
public class LogoutServlet extends HttpServlet {

    private final TokenDao tokenDao = new TokenDao();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {

        // 1. 先删库里的 token,保证旧 Cookie 被复制走也失效
        Cookie[] cookies = req.getCookies();
        if (cookies != null) {
            for (Cookie cookie : cookies) {
                if (login.REMEMBER_COOKIE.equals(cookie.getName())) {
                    tokenDao.deleteByToken(cookie.getValue());
                }
            }
        }

        // 2. 销毁 Session
        HttpSession session = req.getSession(false);
        if (session != null) {
            session.invalidate();
        }

        // 3. 让浏览器删掉两个 Cookie
        login.removeRememberCookie(req, resp);

        Cookie last = new Cookie("lastUsername", "");
        last.setMaxAge(0);
        last.setPath(req.getContextPath());
        resp.addCookie(last);

        resp.sendRedirect(req.getContextPath() + "/login.jsp?msg="
                + java.net.URLEncoder.encode("已退出登录", "UTF-8"));
    }
}

顺序上先删 token,再销毁 Session,最后删 Cookie。原因是删除 Cookie 之后,请求里就没有 token 值了;如果先删 Cookie,数据库中的记录会一直留到过期,等于留下一个仍然有效但无人使用的凭证。先按值删除记录,再让浏览器丢弃 Cookie,才能保证凭证立即失效。

只销毁 Session 是不够的。自动登录 Cookie 仍然存在,下一次请求会被 AutoLoginFilter 重新识别为已登录,用户会认为退出功能失效。

验证:登录后点退出,回到登录页并显示“已退出登录”;F12 中 remember 和 lastUsername 已过期或为空。

八、写 LoginFilter

8.1 过滤器的作用与生命周期

Filter 是 Servlet 规范提供的组件,可以在请求到达 Servlet 或 JSP 之前进行拦截和处理。与直接在 Servlet 里写判断相比,过滤器的优势是作用范围可以覆盖一批路径,而不必在每个 Servlet 中重复实现。

生命周期有三个方法:

  • init(FilterConfig):应用启动时调用一次,适合读取初始化参数。
  • doFilter(ServletRequest, ServletResponse, FilterChain):每个匹配的请求调用一次,多线程并发执行。
  • destroy():应用停止或重新加载时调用一次。

需要特别注意的是 doFilter 的并发性。过滤器的实例只有一个,所有请求共用,因此不能把与单次请求相关的数据存到实例字段里,否则不同用户的请求会相互覆盖。本案例中 AutoLoginFilter 持有两个 DAO 实例,这是安全的,因为 DAO 本身无状态,每次方法调用自己获取连接、自己关闭。

FilterChain 代表后续的过滤器链。调用 chain.doFilter(request, response) 表示放行,请求继续交给下一个过滤器;如果不调用,请求就停在当前过滤器。放行语句之前的代码在请求进入时执行,之后的代码在目标 Servlet 处理完毕返回时执行,这就是过滤器可以做耗时统计的原因。

url-pattern 的写法有四种:/* 匹配所有请求;/admin/* 匹配某个目录;*.jsp 按扩展名匹配;/login 精确匹配。本案例三个过滤器都用 /*,具体放行规则写在代码的白名单里,这样调整白名单不需要改配置。

8.2 拦截逻辑

package com.iooi.login.filter;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;
import java.net.URLEncoder;
import java.util.Arrays;
import java.util.List;

public class LoginFilter implements Filter {

    /** 白名单:去掉项目名之后的路径前缀,目录要带结尾的 / */
    private static final List<String> WHITE_LIST = Arrays.asList(
            "/login",
            "/login.jsp",
            "/logout",
            "/css/",
            "/js/",
            "/images/",
            "/favicon.ico"
    );

    @Override
    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        // 1. /login-demo/welcome.jsp 剥掉 /login-demo,得到 /welcome.jsp
        String uri = request.getRequestURI();
        String contextPath = request.getContextPath();
        String path = uri.substring(contextPath.length());

        // 2. 白名单放行
        if (isWhite(path)) {
            chain.doFilter(request, response);
            return;
        }

        // 3. 看 Session 里有没有登录标记,注意是 false
        HttpSession session = request.getSession(false);
        Object user = (session == null) ? null : session.getAttribute("user");

        if (user == null) {
            String msg = URLEncoder.encode("请先登录", "UTF-8");
            response.sendRedirect(contextPath + "/login.jsp?msg=" + msg);
            return;                 // 关键:必须 return
        }

        // 4. 已登录,交给下一个过滤器或目标页面
        chain.doFilter(request, response);
    }

    private boolean isWhite(String path) {
        for (String white : WHITE_LIST) {
            if (path.startsWith(white)) {
                return true;
            }
        }
        return false;
    }
}

代码中有四处容易出问题的地方。

校验必须用 ​​getSession(false)​ 。不带参数时,没有 Session 会新建一个,等于给每个未登录访客都留下一个空 Session 对象;爬虫或扫描器大量访问时,内存会被这些无意义的对象占满。

必须先去掉 contextPath。getRequestURI() 返回 /login-demo/welcome.jsp,白名单里写的是 /login.jsp,不剥离前缀永远匹配不上;而且项目名会随部署方式变化,写死完整路径的代码在换 war 包名字之后会整体失效。

重定向之后要 return。sendRedirect 只是往响应中写入 302 状态码和 Location 头,当前方法不会因此停止;继续执行 chain.doFilter 会让目标页面往已经提交的响应里写内容,报 IllegalStateException: response already committed。

白名单放行同样要 return,否则代码继续往下执行,登录页也会被判定为未登录,重定向回自身,形成无限重定向,浏览器最终报 ERR_TOO_MANY_REDIRECTS。

8.3 在 web.xml 中注册

@WebFilter 注解使用方便,但无法控制多个过滤器的先后顺序,容器按类名或扫描顺序组装链,不同容器表现可能不一致。要保证 AutoLoginFilter 在 LoginFilter 之前执行,只能用 web.xml 声明。

同一个 Filter 类不要同时使用注解和 web.xml。两者同时存在时会被注册两次,同一个请求依次经过两个同类型的过滤器,表现为 Cookie 被写两遍、日志重复输出。

这一节先注册一个过滤器:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
         https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0"
         metadata-complete="false">

    <display-name>login-demo</display-name>

    <filter>
        <filter-name>loginFilter</filter-name>
        <filter-class>com.iooi.login.filter.LoginFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>loginFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>

    <welcome-file-list>
        <welcome-file>login.jsp</welcome-file>
    </welcome-file-list>

</web-app>

session-config 的单位是分钟,30 表示 30 分钟无请求后失效,-1 表示永不超时,实际项目不建议设为 -1。

metadata-complete 必须保持 false。这个属性的含义是“部署描述文件是否已经完整描述了所有组件”;设为 true 后容器不再扫描注解,@WebServlet("/login") 和 @WebServlet("/logout") 会一起失效,访问 /login 直接 404。

验证:重启 Tomcat,直接访问 http://localhost:8080/login-demo/welcome.jsp,应被重定向到 login.jsp?msg=请先登录;先登录再访问则正常显示。

九、写 EncodingFilter

package com.iooi.login.filter;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;

import java.io.IOException;

public class EncodingFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {

        // 必须在第一次 getParameter 之前,过滤器天然比 Servlet 先跑
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");

        chain.doFilter(request, response);
    }
}

乱码的根源在于字符编码在读取参数时就已经确定。浏览器提交表单时按页面声明的 UTF-8 编码发送请求体,服务器默认按 ISO-8859-1 解码,中文因此变成乱码。setCharacterEncoding 的作用是指定解码方式,必须在第一次 ​​getParameter​​ ** 之前调用**;参数一旦被读取并解码,后续再设置不会生效。

过滤器天然在 Servlet 之前执行,所以把编码设置放在这里最合适,既能覆盖所有请求,也不需要在每个 Servlet 中重复写。

响应编码由 setCharacterEncoding 和页面指令共同决定。JSP 中的 contentType="text/html;charset=UTF-8" 同时设置了响应类型和编码,对页面输出已经够用;过滤器中的设置主要覆盖 Servlet 直接输出内容的情况。

它只处理请求体,也就是 POST 表单,不影响 URL 查询串。GET 参数的中文由 Tomcat 的 URIEncoding 负责,Tomcat 8 以后默认就是 UTF-8。

注册时放在过滤链最前面:

    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>com.iooi.login.filter.EncodingFilter</filter-class>
    </filter>

    <!-- 这段放到 loginFilter 的 filter-mapping 上面 -->
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

放在登录校验之后没有意义:参数可能已经被读取并解码,再设置也改不回来。

验证:向 t_user 增加一个中文用户名(如「测试用户」、密码 123456),用它登录,页面显示正常。把 EncodingFilter 的 mapping 移到 loginFilter 下面再登录一次,会出现乱码,顺序的作用很直观。

十、写 AutoLoginFilter

自动登录有两种常见实现。

第一种是把用户名和密码直接写进 Cookie,下次请求自动提交。这种做法不可接受:Cookie 可以被读取,等于把密码明文长期存放在浏览器中;修改密码之后旧 Cookie 仍然有效,无法撤销。

第二种是发放一次性凭证,也是本案例采用的做法:登录成功时生成随机 UUID,写入数据库并设置有效期,同时把 UUID 写进 Cookie。后续请求只携带 UUID,由服务器查表确认身份。凭证可以随时删除,有效期可以控制,泄露后影响范围有限。

package com.iooi.login.filter;

import com.iooi.login.User;
import com.iooi.login.dao.TokenDao;
import com.iooi.login.dao.UserDao;
import com.iooi.login.login;
import com.iooi.login.util.SessionUtil;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;

public class AutoLoginFilter implements Filter {

    private final TokenDao tokenDao = new TokenDao();
    private final UserDao userDao = new UserDao();

    @Override
    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        String path = request.getRequestURI().substring(request.getContextPath().length());

        // 登录页、退出、静态资源不参与自动登录,否则登录表单永远看不到
        if (path.startsWith("/login") || path.startsWith("/logout")
                || path.startsWith("/css/") || path.startsWith("/js/")
                || path.startsWith("/images/")) {
            chain.doFilter(request, response);
            return;
        }

        // 已经登录过,省一次数据库往返
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("user") != null) {
            chain.doFilter(request, response);
            return;
        }

        String token = readCookie(request, login.REMEMBER_COOKIE);
        if (token == null || token.trim().isEmpty()) {
            chain.doFilter(request, response);
            return;
        }

        String username = tokenDao.findUsernameByToken(token);

        if (username == null) {
            // token 过期、伪造或已退出:同时清掉无效 Cookie
            login.removeRememberCookie(request, response);
            chain.doFilter(request, response);
            return;
        }

        User user = userDao.findByUsername(username);
        if (user == null) {
            login.removeRememberCookie(request, response);
            chain.doFilter(request, response);
            return;
        }

        // 身份有效,恢复登录态,后面的 LoginFilter 就不会拦了
        HttpSession newSession = request.getSession(true);
        SessionUtil.fillLoginSession(newSession, user);

        chain.doFilter(request, response);
    }

    private String readCookie(HttpServletRequest request, String name) {
        Cookie[] cookies = request.getCookies();
        if (cookies == null) {
            return null;
        }
        for (Cookie cookie : cookies) {
            if (name.equals(cookie.getName())) {
                return cookie.getValue();
            }
        }
        return null;
    }
}

执行流程是:读取 Cookie 中的 UUID,查 t_login_token 换取用户名,再查 t_user 获取用户信息,最后写入 Session。Cookie 被改成任意字符串时查不到记录,按未登录处理。

token 失效时同时删除 Cookie。否则浏览器每次请求都会带着一个无效值,服务器每次都要多查一次数据库,而且用户无法自行感知这个残留值。

每个请求最多查询两次数据库,练习工程可以接受。生产环境通常会缩短有效期、限制单个账号的凭证数量,或者改用签名令牌减少查询,这些属于后续优化。

10.1 注册,注意位置

web.xml 最终版,整份替换:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
         https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0"
         metadata-complete="false">

    <display-name>login-demo</display-name>

    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>com.iooi.login.filter.EncodingFilter</filter-class>
    </filter>

    <filter>
        <filter-name>autoLoginFilter</filter-name>
        <filter-class>com.iooi.login.filter.AutoLoginFilter</filter-class>
    </filter>

    <filter>
        <filter-name>loginFilter</filter-name>
        <filter-class>com.iooi.login.filter.LoginFilter</filter-class>
    </filter>

    <!-- 顺序 = 执行顺序:编码 → 自动登录 → 登录校验 -->
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter-mapping>
        <filter-name>autoLoginFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter-mapping>
        <filter-name>loginFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>

    <welcome-file-list>
        <welcome-file>login.jsp</welcome-file>
    </welcome-file-list>

</web-app>

顺序写反会导致自动登录永远不执行。AutoLoginFilter 排在 LoginFilter 之后时,LoginFilter 先执行,发现 Session 中没有 user,直接把请求重定向到登录页,自动登录永远轮不到执行,结果就是“勾选了自动登录,重新打开浏览器仍然要求登录”。

验证:勾选自动登录并登录,关闭整个浏览器后重新打开,直接访问 welcome.jsp,应直接进入,不再要求输入密码。

十一、改两个 JSP

JSP 本质上也是 Servlet。容器第一次访问某个 JSP 时,会把它翻译成一个 Java 类并编译,之后的请求由这个类处理。页面中的 HTML 原样输出,<% %> 中的代码在服务端执行,EL 表达式负责取值。

EL 取值的顺序是 page、request、session、application,从范围小的开始查找。${requestScope.errMsg} 明确指定从 request 域取,避免与 Session 中的同名属性冲突,这类显式声明在调试时很有用。

脚本段 <% %> 能写任意 Java 代码,但会让页面难以维护;现在的写法是 JSP 只负责展示,逻辑放在 Servlet 和 DAO 中。

11.1 login.jsp

需要增加三处:自动登录勾选框、param.msg 提示(过滤器重定向时携带)、用户名回填。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="jakarta.tags.core" %>
<%@ taglib prefix="fn" uri="jakarta.tags.functions" %>
<html>
<head>
    <title>简易登录</title>
</head>
<body>
<h2>用户登录</h2>

<%-- 过滤器重定向过来时带 ?msg=xxx --%>
<c:if test="${not empty param.msg}">
    <p style="color:red">${fn:escapeXml(param.msg)}</p>
</c:if>

<%-- 登录失败转发回来时的提示 --%>
<c:if test="${not empty requestScope.errMsg}">
    <p style="color:red">${fn:escapeXml(requestScope.errMsg)}</p>
</c:if>

<form action="${pageContext.request.contextPath}/login" method="post">
    用户名:<input type="text" name="username"
                 value="${fn:escapeXml(empty requestScope.username ? cookie.lastUsername.value : requestScope.username)}">
    <br>
    密&nbsp;&nbsp;&nbsp;码:<input type="password" name="password">
    <br>
    <label>
        <input type="checkbox" name="rememberMe" value="1"
               ${not empty cookie.remember.value ? 'checked' : ''}>
        7 天内自动登录
    </label>
    <br>
    <input type="submit" value="登录">
</form>

</body>
</html>

${empty requestScope.username ? cookie.lastUsername.value : requestScope.username} 是一个三元表达式:登录失败时优先显示刚输入的值,正常打开页面时读 Cookie。EL 中的 cookie.名称.value 可以直接读取 Cookie,不需要脚本段。

param.msg 读取的是 URL 查询参数。过滤器重定向时拼接了 ?msg=请先登录,页面通过这个参数显示提示,而不是靠 request 域传递,因为重定向之后 request 域已经失效。

原文件中 fn 的 uri 写的是 http://java.sun.com/jsp/jstl/functions,在 JSTL 3.0 下属于旧命名空间,会报 taglib 找不到,应改成 jakarta.tags.functions。JSTL 3.0 随 Jakarta EE 9 更换了命名空间,c、fn、fmt 等标签库的 uri 都改成了 jakarta.tags.*。

${not empty cookie.remember.value ? 'checked' : ''} 把 checked 直接输出到标签属性中,比在属性中间嵌入 c:if 更简洁。

11.2 welcome.jsp

改造前这个页面在内部判断 sessionScope.user,为空时用 JavaScript 弹出提示并返回登录页。过滤器接管之后,能进入该页面的请求都已经通过校验,这段判断可以整段删除。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="jakarta.tags.core" %>
<html>
<head>
    <title>欢迎页</title>
</head>
<body>

<h2>欢迎你,${sessionScope.user.username}</h2>
<p>当前角色:${sessionScope.user.role}</p>

<ul>
    <c:forEach var="menu" items="${sessionScope.menus}">
        <li>${menu}</li>
    </c:forEach>
</ul>

<p>
    <a href="${pageContext.request.contextPath}/logout">退出登录</a>
</p>

</body>
</html>

页面内做登录判断有三个问题:逻辑重复,每增加一个受保护页面就要复制一遍;依赖 JavaScript,用户禁用脚本时会停在空白页;页面已经开始渲染,而鉴权本应发生在渲染之前,否则可能出现“提示已发出但内容已经输出”的情况。

同文件中 taglib 的 uri 仍是 http://java.sun.com/jsp/jstl/core,与 login.jsp 不一致,统一为 jakarta.tags.core。

验证:登录后 welcome.jsp 只显示用户名、角色、菜单列表和退出链接,不再出现 alert 弹窗。

十二、六个必测场景

操作 预期结果 不符时的排查方向
清空 Cookie,访问 /login-demo/welcome.jsp 重定向到 login.jsp?msg=请先登录 过滤器未注册,或白名单漏掉 login.jsp 导致循环重定向
使用 admin 与错误密码 红字提示,用户名保留 失败分支使用了 sendRedirect
使用 admin / 123456 进入 welcome.jsp,显示管理员菜单 查库结果或 Session 属性名与 JSP 不一致
勾选自动登录,关闭浏览器后重开并访问 welcome.jsp 直接进入 AutoLoginFilter 顺序在 LoginFilter 之后,或 Cookie 的 Path、Max-Age 有误
退出后再访问 welcome.jsp 回到登录页并提示已退出 只销毁了 Session,没有清理 Cookie 与 token
手工把 remember 改成乱码后访问 回到登录页,该 Cookie 被清除 查询返回 null 的分支没有删除 Cookie

最后一条同时验证两件事:不把 Cookie 内容当作可信身份,以及失效凭证会被及时清理。

十三、报错对照表

现象 原因 修法
ClassNotFoundException: com.mysql.cj.jdbc.Driver 驱动没有进入 WEB-INF/lib 刷新 Maven 后重新打包,确认依赖没有写 provided
Access denied for user 'root'@'localhost' 密码错误或账号权限不足 修改 DBUtil 中的 PASSWORD,确认 MySQL 正在运行
Public Key Retrieval is not allowed MySQL 8 的 caching_sha2_password 认证方式 URL 增加 allowPublicKeyRetrieval=true
The server time zone value ... is unrecognized 未指定时区 URL 增加 serverTimezone=Asia/Shanghai
Unknown database 'login_demo' 建库语句未执行 重新执行第一节的 SQL
ERR_TOO_MANY_REDIRECTS 白名单漏掉 login.jsp,或重定向后没有 return 检查 WHITE_LIST 与两处 return
IllegalStateException: response already committed sendRedirect 之后仍在写响应或放行 补充 return
登录成功但欢迎页取不到 user Session 属性名与 JSP 不一致 统一使用 SessionUtil,属性名写 user
Cookie 已写入但读不到 Path 不匹配、Max-Age 为 0、域名不同 Path 设为 req.getContextPath(),Max-Age 设为正数
Cookie value 含中文抛异常 value 只接受 ASCII 字符 写入前用 URLEncoder 编码
过滤器执行两遍 注解与 web.xml 重复注册 去掉 @WebFilter,只保留 web.xml
访问 /login 报 405 只有 doPost,浏览器直接访问使用的是 GET 补充 doGet,重定向回登录页
JSTL 标签原样输出 taglib uri 使用了旧的 java.sun.com 地址 统一为 jakarta.tags.core、jakarta.tags.functions
Port 8080 ... already in use 上一次 Tomcat 未退出 lsof -i :8080 找到进程后结束,或更换端口

十四、后续可以做的

  • 注册功能:UserDao 增加 insert 方法,处理用户名唯一约束冲突,不能直接抛 500。
  • 密码改散列:只修改 UserDao 的两个查询方法,登录时对输入做一次 MD5 再比对。
  • 权限过滤:新增 AdminFilter 判断 user.role,映射到 /admin/*,非管理员返回 403。
  • 自动登录加强:token 只存哈希值、有效期缩短,每次自动登录后轮换一个新 token。
  • 连接池:DBUtil 换成 Druid,DAO 不改动,可以直接看出分层的效果。
  • Session 存 Redis:多台 Tomcat 共享登录态,属于分布式的入门问题。

支持与分享

如果这篇文章对你有帮助,欢迎分享给更多人或者给予支持!

案例2-手把手教程-过滤器与记住我
/archives/post-1794498739115
作者
Bam
发布于
2026-11-12
许可协议
CC BY-NC-SA 4.0

评论