案例2-手把手教程-过滤器与记住我
案例 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 并显示管理员菜单;密码错误时停在登录页,红字提示,用户名保留在输入框。
六、自动登录:token 表 + Cookie
6.1 Cookie 的读写与删除
// 写:放进响应头 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>
密 码:<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 共享登录态,属于分布式的入门问题。

