Java Spring Web中Cookie-Session、JWT、Spring Session + Redis

一、 经典永流传：Cookie与Session的协作
这是最传统、最广为人知的方案。其核心原理是利用HTTP协议本身的特性。

1. 原理解析：
Session创建：当客户端第一次请求服务器时，服务器会创建一个HttpSession对象，为其生成一个唯一的SessionID。

Cookie传递：服务器在HTTP响应头中通过Set-Cookie: JSESSIONID=xxxxxx命令，将SessionID返回给浏览器。

身份凭证：浏览器将此Cookie保存，并在后续的每一次请求中自动通过Cookie: JSESSIONID=xxxxxx请求头将其带回服务器。

会话检索：服务器从请求中解析出SessionID，从而找到对应的HttpSession对象，获取其中存储的用户状态信息（如用户ID、用户名等）。

2. Spring Boot示例代码：
Spring Boot应用默认就支持此模式，无需额外配置。
@RestController
@SessionAttributes(“user”) // 可选的，用于在控制器内跨请求临时存储模型属性
public class TraditionalSessionController {

@PostMapping(“/login”)
public String login(@RequestParam String username,
HttpServletRequest request) {
// 模拟用户验证
if (“admin”.equals(username)) {
// 获取Session，如果不存在则创建（create参数默认为true）
HttpSession session = request.getSession();
// 向Session中存储用户信息
session.setAttribute(“user”, username);
session.setMaxInactiveInterval(1800); // 设置Session30分钟后过期
return “Login successful. Session ID: ” + session.getId();
}
return “Login failed”;
}

@GetMapping(“/profile”)
public String getProfile(HttpServletRequest request) {
// 从请求中获取当前Session，如果不存在则不创建（false）
HttpSession session = request.getSession(false);
if (session != null) {
String user = (String) session.getAttribute(“user”);
if (user != null) {
return “Hello, ” + user + “. Your session ID is: ” + session.getId();
}
}
return “Please login first”;
}

@GetMapping(“/logout”)
public String logout(HttpServletRequest request) {
HttpSession session = request.getSession(false);
if (session != null) {
session.invalidate(); // 使当前Session失效
}
return “Logged out”;
}
}

3. 优缺点：
优点：简单易用，内置支持；Session数据存储在服务器端，相对安全。

缺点：

扩展性差：在集群或分布式环境下，默认的Session是内存存储，无法在不同服务器实例间共享。需要通过Tomcat Session复制等复杂方案解决，效率低下。

CSRF风险：基于Cookie，需额外注意防范跨站请求伪造攻击。

对移动端/NativeApp不友好：移动端应用有时难以高效地管理Cookie。

4. 使用场景建议：
简单的单体应用，无需横向扩展。

开发原型、内部工具、用户量不大的项目。

你对服务器有完全的控制权，且不需要考虑复杂的分布式部署。

二、 现代无状态典范：JSON Web Token (JWT)
JWT是一种开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间作为JSON对象安全地传输信息。

1. 原理解析：
无状态：服务器不存储任何会话信息。所有必要的用户状态都编码在Token本身中。

Token结构：Header.Payload.Signature

Header：通常包含令牌类型（如JWT）和所使用的签名算法（如HMAC SHA256或RSA）。

Payload：包含声明（Claims）。声明是关于实体（通常是用户）和附加数据的语句。例如用户ID、过期时间等。

Signature：对前两部分的签名，防止数据被篡改。

流程：用户登录后，服务器生成一个JWT并返回给客户端。客户端在后续请求的Authorization头中携带此Token（如 Bearer <token>）。服务器验证签名并解析Payload即可获取用户信息，无需查询数据库或Session存储。

2. Spring Boot示例代码（使用jjwt库）：
首先，添加依赖：
<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>

然后，编写工具类和控制器：

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.security.Key;
import java.util.Date;

@Component
public class JwtUtil {
// 在实际生产中，这个密钥必须很长、很复杂，且从安全配置中读取，绝不能硬编码！
private static final String SECRET = “ThisIsASecretKeyThatIsVeryLongAndSecureEnoughForHS512”;
private Key key;

@PostConstruct
public void init() {
this.key = Keys.hmacShaKeyFor(SECRET.getBytes());
}

public String generateToken(String username) {
return Jwts.builder()
.setSubject(username)
.setIssuedAt(new Date())
.setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10)) // 10小时有效期
.signWith(key, SignatureAlgorithm.HS512)
.compact();
}

public String extractUsername(String token) {
return Jwts.parserBuilder()
.setSigningKey(key)
.build()
.parseClaimsJws(token)
.getBody()
.getSubject();
}

public boolean validateToken(String token) {
try {
Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
return true;
} catch (JwtException | IllegalArgumentException e) {
// 记录日志或处理异常
return false;
}
}
}

@RestController
public class JwtController {

@Autowired
private JwtUtil jwtUtil;

@PostMapping(“/auth/login”)
public ResponseEntity<String> login(@RequestParam String username) {
// … 验证用户名和密码
if (“admin”.equals(username)) {
String token = jwtUtil.generateToken(username);
return ResponseEntity.ok().body(token); // 将Token返回给客户端
}
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
}

@GetMapping(“/api/protected”)
public ResponseEntity<String> protectedResource(@RequestHeader(“Authorization”) String authHeader) {
// 检查Authorization头
if (authHeader != null && authHeader.startsWith(“Bearer “)) {
String token = authHeader.substring(7);
if (jwtUtil.validateToken(token)) {
String username = jwtUtil.extractUsername(token);
return ResponseEntity.ok(“Accessing protected resource for: ” + username);
}
}
return ResponseEntity.status(HttpStatus.FORBIDDEN).body(“Invalid or missing token”);
}
}

3. 优缺点：
优点：

无状态与扩展性：服务器无需存储会话，天生适合分布式和微服务架构。任何服务节点只需持有密钥即可验证Token。

多端支持：完美支持Web、移动端（App）、API客户端。

灵活性：Payload可以携带自定义信息。

缺点：

Token无法废止：一旦签发，在到期前始终有效。实现“登出”或“强制下线”非常困难，通常需借助黑名单（与有状态存储无异）或设置极短的过期时间。

安全性：Token如果被盗用，攻击者可以完全冒充用户。因此必须使用HTTPS传输。

性能：每次请求都需要进行签名验证和解析，比从内存中读取Session开销稍大。Token体积也可能比一个SessionID的Cookie大。

4. 使用场景建议：
分布式系统、微服务架构，需要跨服务认证。

为移动应用（Native App）、第三方API消费者提供认证。

单点登录（SSO）场景。

你能够接受无法简单废止Token所带来的安全权衡。

三、 分布式应用的救星：Spring Session + Redis
这个方案是对传统Session模式的升级，旨在解决其扩展性问题。它将会话数据外部化到一个共享的存储中（如Redis），使得应用集群中的所有实例都可以访问相同的会话数据。

1. 原理解析：
抽象层：Spring Session提供了一个SessionRepository接口，抽象了HttpSession的实现。

存储后端：通过实现此接口（如RedisIndexedSessionRepository），将会话数据存储到Redis等外部数据源中。

SessionID映射：它仍然使用Cookie（默认JSESSIONID）来跟踪会话，但这个ID对应的是Redis中的一个条目，而不是本地服务器内存中的一个对象。

2. Spring Boot示例代码：
首先，添加依赖：
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
</dependency>
<dependency>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId> <!– 或使用Jedis –>
</dependency>

在application.properties中配置Redis：

spring.redis.host=localhost
spring.redis.port=6379
# 配置使用Redis作为Session存储
spring.session.store-type=redis
server.servlet.session.timeout=1800s # Session过期时间

编写控制器

@RestController
public class SpringSessionController {

@PostMapping(“/redis-login”)
public String login(@RequestParam String username, HttpServletRequest request) {
HttpSession session = request.getSession();
session.setAttribute(“user”, username);
return “Login successful (Redis). Session ID: ” + session.getId();
}

@GetMapping(“/redis-profile”)
public String getProfile(HttpServletRequest request) {
HttpSession session = request.getSession(false);
if (session != null) {
String user = (String) session.getAttribute(“user”);
return “Hello (from Redis), ” + user + “. Your session ID is: ” + session.getId();
}
return “Please login first”;
}
}

3. 优缺点：
优点：

无缝扩展：完美解决传统Session在集群环境下的共享问题。

代码透明：对应用代码侵入性极低，开发者几乎无感知。

强大灵活：支持多种存储（Redis, MongoDB, JDBC等）；提供RESTful API管理会话；易于集成Spring Security。

缺点：

引入外部依赖：需要部署和维护Redis等中间件，增加了架构的复杂性。

网络开销：每次会话读写都需要一次网络IO，虽然Redis极快，但相比本地内存仍有延迟。

4. 使用场景建议：
任何需要水平扩展的多实例Spring Boot应用集群。

需要高可用性的生产环境。

你希望保留传统Session编程模型的简单性，同时又需要分布式能力。这是目前绝大多数中型以上Spring Cloud微服务项目的首选方案。

四、 其他补充与进阶考量
Spring Security Context持久化：
在分布式环境下，不仅是HttpSession，Spring Security的SecurityContext（存储认证对象Authentication）也需要共享。Spring Session会自动处理这一点，确保在一个实例上登录后，其他实例也能通过SessionID获取到正确的认证信息。

OAuth2：
对于大型开放平台或非常复杂的授权场景（如允许用户使用微信、GitHub登录），OAuth2是行业标准。Spring生态下的Spring Authorization Server或整合Keycloak等方案是更专业的选择。JWT通常是OAuth2中Access Token的一种实现形式。