最近在整理技术文档时，突然想到一个有趣的比喻：有时候，一个看似简单的技术栈或框架，一旦深入进去，可能会像进入一个复杂的“丛林”，当你终于掌握它并“走出来”时，却发现外面的技术世界早已天翻地覆。这让我想起了很多开发者面对老旧系统、遗留代码或某个特定技术深坑时的状态。今天，我们就以这个比喻为引，来系统性地探讨一个经典且容易让人“陷入”的技术场景——基于传统 Session 的 Web 应用身份认证与授权，并对比“走出来”后看到的现代技术世界：无状态、分布式的 JWT 与 OAuth2 体系。

本文将带你完整走一遍从“被困”到“走出”的全过程。如果你是刚接触 Web 安全的新手，可以理解整套认证授权的演进脉络；如果你正在维护老系统，可以对照排查其中的安全隐患与性能瓶颈；如果你想在新项目中采用现代方案，本文将提供从原理到 Spring Security 实战的完整指南。

1. 背景与核心概念：从“丛林”到“新世界”

在 Web 开发早期，应用大多是单体架构，用户通过浏览器登录后，服务器会在内存中创建一个Session对象来存储用户状态（如用户ID、角色）。这个 Session 有一个唯一的 ID（Session ID），通过 Cookie 传递给浏览器。此后，浏览器的每次请求都会带上这个 Cookie，服务器通过 Session ID 找到对应的 Session，从而识别用户。

这就像那盘“桌游”：规则简单（登录->存Session->校验Session），自成一派，在单服务器、小规模用户时运行良好。但它的“丛林”陷阱也随之而来：

1. 状态存储：Session 存储在服务器内存（或 Redis），服务器是有状态的。
2. 扩展性差：当需要部署多台服务器做负载均衡时，Session 需要共享，否则用户可能被分配到没有其 Session 的服务器，导致重复登录。
3. CSRF 攻击：基于 Cookie 的机制容易受到跨站请求伪造攻击。
4. 移动端不友好：原生 App 处理 Cookie 不如浏览器自然。

而当技术世界演进到微服务、前后端分离、跨域应用的时代时，无状态（Stateless）认证成为了“新世界”的通行证。其核心代表是JWT (JSON Web Token)和OAuth 2.0授权框架。服务器不再保存会话状态，而是将认证信息加密后放入 Token，发给客户端。客户端后续请求在 Header 中携带此 Token，服务器只需验证 Token 的有效性和签名即可。

2. 环境准备与版本说明

为了清晰地对比两种模式，我们将创建一个 Spring Boot 项目，分别实现传统的 Session 认证和现代的 JWT 认证。

环境要求：

• 操作系统：Windows 10/11, macOS, 或 Linux (Ubuntu 20.04+)
• Java：JDK 11 或 17 (推荐 17)
• 构建工具：Maven 3.6+ 或 Gradle 7.x
• IDE：IntelliJ IDEA, VS Code 或 Eclipse
• 数据库：H2 Database (内存数据库，便于演示) 或 MySQL 8.0

项目初始化：使用 Spring Initializr 创建项目，选择以下依赖：

• Spring Web
• Spring Security
• Spring Data JPA
• H2 Database (或 MySQL Driver)
• Lombok (简化代码)

生成的pom.xml关键依赖如下（Maven 示例）：

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.7.18</version> <!-- 使用一个稳定的版本 --> <relativePath/> </parent> <groupId>com.example</groupId> <artifactId>auth-demo</artifactId> <version>0.0.1-SNAPSHOT</version> <name>auth-demo</name> <description>Demo project for Session vs JWT Auth</description> <properties> <java.version>17</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <!-- JWT 相关依赖，用于后半部分 --> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.11.5</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>0.11.5</version> <scope>runtime</scope> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>0.11.5</version> <scope>runtime</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <scope>test</scope> </dependency> </dependencies> <!-- 省略 build 和 plugin 配置 --> </project>

项目结构预览：

src/main/java/com/example/authdemo/ ├── config/ # 安全配置类 ├── controller/ # 控制器 ├── dto/ # 数据传输对象 ├── entity/ # JPA 实体 ├── repository/ # 数据访问层 ├── service/ # 业务逻辑层 └── util/ # 工具类（如JWT）

3. “丛林”深处：传统 Session 认证实战与原理拆解

我们先实现一个最经典的 Session 认证流程，理解其运作机制和固有局限。

3.1 核心原理与流程

sequenceDiagram participant C as Client (Browser) participant S as Server participant D as Session Store (Memory/Redis) C->>S: 1. POST /login (username, password) S->>S: 2. 验证凭证 S->>D: 3. 创建Session对象，存储用户信息 D-->>S: 4. 生成唯一Session ID S-->>C: 5. 响应Set-Cookie: JSESSIONID=xxx C->>S: 6. 后续请求自动携带Cookie S->>D: 7. 根据Session ID查找Session D-->>S: 8. 返回用户信息 S-->>C: 9. 处理业务，返回响应

1. 登录：客户端提交凭证。
2. 验证与创建会话：服务器验证成功，在服务端存储会话数据（内存、数据库、Redis），生成唯一 Session ID。
3. 下发凭证：通过Set-Cookie头将 Session ID 写入浏览器 Cookie。
4. 携带凭证：浏览器后续对同域请求自动携带此 Cookie。
5. 验证会话：服务器从 Cookie 中取出 Session ID，查找对应的会话数据，完成身份识别。

3.2 实战：Spring Security 默认 Session 配置

Spring Security 默认就启用了 Session 管理。我们创建一个简单的用户和接口来观察。

实体与存储：

// file: src/main/java/com/example/authdemo/entity/User.java package com.example.authdemo.entity; import lombok.Data; import javax.persistence.*; @Entity @Data @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(unique = true, nullable = false) private String username; @Column(nullable = false) private String password; private String role; // 例如：USER, ADMIN }

// file: src/main/java/com/example/authdemo/repository/UserRepository.java package com.example.authdemo.repository; import com.example.authdemo.entity.User; import org.springframework.data.jpa.repository.JpaRepository; import java.util.Optional; public interface UserRepository extends JpaRepository<User, Long> { Optional<User> findByUsername(String username); }

安全配置（默认Session）：

// file: src/main/java/com/example/authdemo/config/SecurityConfig.java package com.example.authdemo.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.security.web.SecurityFilterChain; @Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeHttpRequests(authz -> authz .antMatchers("/public/**").permitAll() .antMatchers("/admin/**").hasRole("ADMIN") .anyRequest().authenticated() // 其他所有请求都需要认证 ) .formLogin(form -> form .loginPage("/login") // 自定义登录页，默认是 /login .permitAll() ) .logout(logout -> logout .permitAll() ) // 默认启用 Session 管理，CSRF 保护也是开启的 .csrf().disable(); // 为了方便测试API，先禁用CSRF，生产环境慎用！ return http.build(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } // 需要实现 UserDetailsService，这里简化为返回内存用户 // 实际项目应从数据库加载 }

测试控制器：

// file: src/main/java/com/example/authdemo/controller/TestController.java package com.example.authdemo.controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import javax.servlet.http.HttpSession; @RestController @RequestMapping("/api") public class TestController { @GetMapping("/session-info") public String getSessionInfo(HttpSession session) { return "Session ID: " + session.getId() + ", Creation Time: " + session.getCreationTime() + ", Last Accessed: " + session.getLastAccessedTime(); } @GetMapping("/admin/hello") public String adminHello() { return "Hello Admin!"; } @GetMapping("/user/hello") public String userHello() { return "Hello User!"; } }

运行与验证：

1. 启动应用，访问http://localhost:8080/login(Spring Security 默认提供简单登录页)。
2. 使用配置的用户名密码登录（需要先实现UserDetailsService或使用内存用户）。
3. 登录成功后，访问/api/session-info，可以看到服务器返回的 Session 信息。同时检查浏览器开发者工具的Application->Cookies，会发现一个名为JSESSIONID的 Cookie。
4. 访问/api/admin/hello或/api/user/hello，请求会自动携带JSESSIONIDCookie，服务器通过它识别用户身份和权限。

3.3 “丛林”的困境：Session 的局限性

1. 扩展性问题（Session 共享）：多实例部署时，必须将 Session 存储到外部（如 Redis）。这增加了架构复杂度和网络开销。

   # application.yml 配置 Redis 存储 Session spring: session: store-type: redis redis: host: localhost port: 6379

2. CSRF 攻击：虽然 Spring Security 默认提供了 CSRF 防护（需要配合表单提交的_csrftoken），但对于纯 API 项目，管理起来比较麻烦，通常选择禁用，这又带来了安全风险。
3. 移动端/跨域不友好：原生 App 需要手动管理 Cookie。在前后端分离且跨域的场景下，Cookie 的处理需要额外配置（CORS）。
4. 服务器内存压力：用户量巨大时，存储所有用户的 Session 对服务器内存是巨大挑战。

4. 走出“丛林”：JWT 无状态认证实战

JWT 是“新世界”的轻量级凭证。它是一串加密的字符串，由三部分组成：Header（头部）、Payload（负载）、Signature（签名）。服务器签发后，客户端保存（通常放在localStorage或Authorization头），后续请求时携带，服务器只需验证签名即可，无需查询会话存储。

4.1 JWT 结构解析

一个 JWT 看起来像这样：xxxxx.yyyyy.zzzzz

• Header：声明类型和加密算法，如{"alg": "HS256", "typ": "JWT"}，Base64Url 编码。
• Payload：存放实际传递的数据（Claims），如用户ID、角色、过期时间，Base64Url 编码。注意：Payload 只是编码，并非加密，不要存放敏感信息。
• Signature：对前两部分的签名，防止数据篡改。HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

4.2 实战：集成 JWT 到 Spring Security

我们将改造上面的项目，用 JWT 替代 Session。

第一步：创建 JWT 工具类

// file: src/main/java/com/example/authdemo/util/JwtUtil.java package com.example.authdemo.util; import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import io.jsonwebtoken.security.Keys; import org.springframework.beans.factory.annotation.Value; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import java.security.Key; import java.util.Date; import java.util.HashMap; import java.util.Map; import java.util.function.Function; @Component public class JwtUtil { @Value("${jwt.secret}") // 从配置读取密钥 private String secret; @Value("${jwt.expiration}") // 过期时间(毫秒) private Long expiration; private Key key; @PostConstruct public void init() { // 将字符串密钥转换为安全的 Key 对象 this.key = Keys.hmacShaKeyFor(secret.getBytes()); } // 从token中获取用户名 public String extractUsername(String token) { return extractClaim(token, Claims::getSubject); } // 从token中获取过期时间 public Date extractExpiration(String token) { return extractClaim(token, Claims::getExpiration); } public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) { final Claims claims = extractAllClaims(token); return claimsResolver.apply(claims); } private Claims extractAllClaims(String token) { return Jwts.parserBuilder() .setSigningKey(key) .build() .parseClaimsJws(token) .getBody(); } // 检查token是否过期 private Boolean isTokenExpired(String token) { return extractExpiration(token).before(new Date()); } // 为用户生成token public String generateToken(UserDetails userDetails) { Map<String, Object> claims = new HashMap<>(); // 可以将角色等信息放入claims claims.put("roles", userDetails.getAuthorities()); return createToken(claims, userDetails.getUsername()); } private String createToken(Map<String, Object> claims, String subject) { return Jwts.builder() .setClaims(claims) .setSubject(subject) .setIssuedAt(new Date(System.currentTimeMillis())) .setExpiration(new Date(System.currentTimeMillis() + expiration)) .signWith(key, SignatureAlgorithm.HS256) .compact(); } // 验证token public Boolean validateToken(String token, UserDetails userDetails) { final String username = extractUsername(token); return (username.equals(userDetails.getUsername()) && !isTokenExpired(token)); } }

第二步：创建 JWT 认证过滤器

这个过滤器会拦截请求，从Authorization头中提取 JWT，并进行验证。

// file: src/main/java/com/example/authdemo/filter/JwtAuthenticationFilter.java package com.example.authdemo.filter; import com.example.authdemo.util.JwtUtil; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.web.authentication.WebAuthenticationDetailsSource; import org.springframework.stereotype.Component; import org.springframework.web.filter.OncePerRequestFilter; import javax.servlet.FilterChain; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; @Component public class JwtAuthenticationFilter extends OncePerRequestFilter { @Autowired private JwtUtil jwtUtil; @Autowired private UserDetailsService userDetailsService; @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException { final String authorizationHeader = request.getHeader("Authorization"); String username = null; String jwt = null; // 检查请求头是否包含Bearer Token if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) { jwt = authorizationHeader.substring(7); // 去掉"Bearer " username = jwtUtil.extractUsername(jwt); } // 如果用户名不为空，且当前SecurityContext中没有认证信息 if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) { UserDetails userDetails = this.userDetailsService.loadUserByUsername(username); // 验证token有效性 if (jwtUtil.validateToken(jwt, userDetails)) { // 创建认证令牌，并设置到SecurityContext中 UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken( userDetails, null, userDetails.getAuthorities()); authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); SecurityContextHolder.getContext().setAuthentication(authenticationToken); } } chain.doFilter(request, response); } }

第三步：修改安全配置，集成 JWT 过滤器并禁用 Session

// file: src/main/java/com/example/authdemo/config/JwtSecurityConfig.java package com.example.authdemo.config; import com.example.authdemo.filter.JwtAuthenticationFilter; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.http.SessionCreationPolicy; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.security.web.SecurityFilterChain; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; @Configuration @EnableWebSecurity public class JwtSecurityConfig { @Autowired private JwtAuthenticationFilter jwtAuthenticationFilter; @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .csrf().disable() // JWT无需CSRF保护 .authorizeHttpRequests(authz -> authz .antMatchers("/api/auth/**").permitAll() // 认证接口放行 .antMatchers("/api/admin/**").hasRole("ADMIN") .anyRequest().authenticated() ) // 关键配置：设置Session创建策略为STATELESS（无状态） .sessionManagement(session -> session .sessionCreationPolicy(SessionCreationPolicy.STATELESS) ) // 在UsernamePasswordAuthenticationFilter之前添加我们的JWT过滤器 .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class); return http.build(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } // 暴露AuthenticationManager Bean，用于登录认证 @Bean public AuthenticationManager authenticationManager(AuthenticationConfiguration authConfig) throws Exception { return authConfig.getAuthenticationManager(); } }

第四步：创建认证接口（登录）

// file: src/main/java/com/example/authdemo/controller/AuthController.java package com.example.authdemo.controller; import com.example.authdemo.dto.LoginRequest; import com.example.authdemo.util.JwtUtil; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.Authentication; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/api/auth") public class AuthController { @Autowired private AuthenticationManager authenticationManager; @Autowired private JwtUtil jwtUtil; // 假设有一个自定义的 UserDetailsService 实现，这里省略 @PostMapping("/login") public ResponseEntity<?> login(@RequestBody LoginRequest loginRequest) { // 1. 使用Spring Security的AuthenticationManager进行认证 Authentication authentication = authenticationManager.authenticate( new UsernamePasswordAuthenticationToken( loginRequest.getUsername(), loginRequest.getPassword() ) ); // 2. 认证成功，将认证信息设置到上下文（可选，JWT过滤器会处理） // SecurityContextHolder.getContext().setAuthentication(authentication); // 3. 生成JWT Token final UserDetails userDetails = (UserDetails) authentication.getPrincipal(); final String jwt = jwtUtil.generateToken(userDetails); // 4. 返回Token return ResponseEntity.ok(new AuthResponse(jwt)); } // 简单的DTO static class AuthResponse { private final String token; public AuthResponse(String token) { this.token = token; } public String getToken() { return token; } } } // file: src/main/java/com/example/authdemo/dto/LoginRequest.java package com.example.authdemo.dto; import lombok.Data; @Data public class LoginRequest { private String username; private String password; }

第五步：配置文件

# file: src/main/resources/application.yml spring: datasource: url: jdbc:h2:mem:testdb driver-class-name: org.h2.Driver username: sa password: jpa: database-platform: org.hibernate.dialect.H2Dialect hibernate: ddl-auto: update show-sql: true h2: console: enabled: true # 启用H2控制台，访问 /h2-console jwt: secret: mySecretKeyWhichIsVeryLongAndSecureAtLeast32BytesLong! # 密钥，必须足够长且复杂 expiration: 86400000 # Token有效期，单位毫秒 (24小时)

运行与验证（使用 JWT）：

1. 启动应用。
2. 使用 Postman 或 curl 调用登录接口：

   curl -X POST http://localhost:8080/api/auth/login \ -H "Content-Type: application/json" \ -d '{"username":"admin","password":"your_password"}'

   响应应包含一个 JWT Token：{"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."}
3. 使用获取到的 Token 访问受保护接口：

   curl -X GET http://localhost:8080/api/admin/hello \ -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

   应该成功收到"Hello Admin!"的响应。服务器不再依赖 Session，仅靠 Token 即可完成认证。

5. 常见问题与排查思路

在从 Session 迁移到 JWT 或无状态架构的过程中，你会遇到各种问题。下表列出了一些典型问题及解决思路：

6. 最佳实践与工程建议

掌握了基础实现后，要在生产环境中安全、高效地使用，还需要遵循以下最佳实践：

1. 密钥安全管理：

   • 绝对不要将 JWT Secret 硬编码在代码中或提交到版本库。
   • 使用环境变量、配置中心（如 Apollo、Nacos）或云服务商的安全密钥管理服务来存储密钥。
   • 密钥长度至少 32 字节，并使用安全的随机生成器。

2. Token 生命周期管理：

   • 采用 Access Token + Refresh Token 双 Token 机制。
   • Access Token：短期有效（如 15-30 分钟），用于业务 API 调用。
   • Refresh Token：长期有效（如 7 天），存储于安全的 HttpOnly Cookie 或服务端，仅用于获取新的 Access Token。
   • 这样即使 Access Token 泄露，影响时间也较短。Refresh Token 的刷新和撤销逻辑需要精心设计。

3. 避免在 Payload 中存储敏感信息：JWT 的 Payload 仅是 Base64 编码，任何人拿到 Token 都可以解码看到内容。切勿存放密码、手机号等敏感信息。

4. 选择合适的签名算法：

   • HS256 (HMAC with SHA-256)：对称加密，服务端用一个密钥签名和验证。性能好，但密钥分发和管理需谨慎。
   • RS256 (RSA Signature with SHA-256)：非对称加密，服务端用私钥签名，客户端或用其他服务用公钥验证。更安全，适合微服务间认证。

5. 做好日志与监控：

   • 记录 Token 的签发、验证失败、过期刷新等关键事件。
   • 监控异常登录行为（如短时间内同一用户大量获取 Token）。

6. 前端安全存储：

   • 对于 SPA 应用，将 Access Token 存储在内存或sessionStorage中（页面关闭即失效）。
   • 避免存储在localStorage，以防 XSS 攻击窃取。如果必须存，请确保有完善的 XSS 防御。
   • Refresh Token 应通过安全的、HttpOnly的 Cookie 发送，防止 JavaScript 访问。

7. API 网关统一认证：在微服务架构中，可以在 API 网关层统一进行 JWT 的验证和路由，避免每个微服务重复实现认证逻辑。

从“被困在 Session 丛林”到“掌握 JWT 新世界”，本质是从有状态到无状态、从中心化存储到去中心化验证的思想转变。这种转变带来了巨大的扩展性和灵活性，适合现代分布式应用。然而，没有银弹，JWT 也引入了令牌管理、即时失效等新挑战。理解两者的原理、实现和优劣，才能根据你的实际业务场景（如企业内部系统、高并发互联网应用、微服务集群）做出最合适的技术选型。建议从本文的示例项目出发，逐步尝试双 Token 机制、集成 Redis 黑名单、尝试 RS256 算法，最终构建出一套健壮、安全的身份认证体系。