Spring中的JWT集成:无状态认证方案
开场白
大家好,欢迎来到今天的讲座!今天我们要聊聊Spring中的JWT(JSON Web Token)集成,以及如何实现一个无状态的认证方案。如果你已经对JWT有所了解,那太好了;如果你还不熟悉,也不用担心,我会尽量用通俗易懂的语言来解释。
首先,让我们想象一下你正在开发一个电商网站。用户可以注册、登录、浏览商品、添加到购物车,最后完成支付。在这个过程中,我们如何确保用户的操作是安全的?如何防止未经授权的访问?这就是认证和授权的作用了。
传统的认证方式通常依赖于服务器端的会话(Session),每次用户登录后,服务器会为该用户创建一个会话,并将这个会话存储在内存或数据库中。这种方式虽然简单,但在分布式系统中却存在一些问题:
- 扩展性差:每个服务器都需要维护自己的会话数据,当用户请求被路由到不同的服务器时,可能会导致会话丢失。
- 性能瓶颈:随着用户数量的增加,会话数据的存储和管理会成为性能瓶颈。
- 单点故障:如果会话数据存储在一个地方,一旦该存储节点出现问题,所有用户的会话都会失效。
那么,有没有一种更好的解决方案呢?答案就是——JWT!
什么是JWT?
JWT(JSON Web Token)是一种开放标准(RFC 7519),用于在网络应用之间安全地传输信息。它是一个自包含的令牌,包含了用户的身份信息和其他元数据。JWT的最大特点是它可以在客户端和服务器之间传递,而不需要服务器端存储任何会话信息。因此,JWT非常适合用于无状态的认证方案。
JWT的结构非常简单,由三部分组成,分别是:
- Header(头部):描述了令牌的类型(通常是JWT)以及所使用的签名算法(如HMAC SHA-256或RSA)。
- Payload(负载):包含了声明(claims),即你要传递的信息。常见的声明包括
iss
(发行人)、exp
(过期时间)、sub
(主题)等。 - Signature(签名):用于验证令牌的完整性和来源。签名是通过对头部和负载进行编码后,使用密钥进行加密生成的。
一个典型的JWT看起来像这样:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
这三部分通过.
分隔开,分别对应Header、Payload和Signature。
JWT的工作流程
- 用户登录:用户提交用户名和密码,服务器验证通过后,生成一个JWT并返回给客户端。
- 客户端存储JWT:客户端将JWT存储在本地(如浏览器的LocalStorage或Cookie中),并在后续的请求中将其作为Authorization头的一部分发送给服务器。
- 服务器验证JWT:服务器接收到请求后,解析JWT并验证其签名。如果签名有效且未过期,则允许访问受保护的资源。
- 无状态认证:由于JWT是自包含的,服务器不需要存储任何会话信息,因此整个认证过程是无状态的。
在Spring中集成JWT
接下来,我们来看看如何在Spring Boot项目中集成JWT。我们将使用spring-security
来保护API,并结合JWT实现无状态认证。
1. 添加依赖
首先,在pom.xml
中添加必要的依赖项:
<dependencies>
<!-- Spring Security -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- JWT -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<!-- Lombok (可选) -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
2. 创建JWT工具类
为了方便生成和验证JWT,我们可以创建一个工具类JwtUtil
。这个类将包含生成JWT、解析JWT以及验证签名的方法。
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
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;
// 生成JWT
public String generateToken(String username) {
Map<String, Object> claims = new HashMap<>();
return createToken(claims, username);
}
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 * 1000))
.signWith(SignatureAlgorithm.HS256, secret)
.compact();
}
// 从JWT中提取用户名
public String extractUsername(String token) {
return extractClaim(token, Claims::getSubject);
}
// 从JWT中提取声明
public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
final Claims claims = extractAllClaims(token);
return claimsResolver.apply(claims);
}
// 解析JWT并验证签名
private Claims extractAllClaims(String token) {
return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
}
// 验证JWT是否有效
public Boolean isTokenValid(String token, String username) {
final String extractedUsername = extractUsername(token);
return (extractedUsername.equals(username) && !isTokenExpired(token));
}
// 检查JWT是否已过期
private Boolean isTokenExpired(String token) {
return extractExpiration(token).before(new Date());
}
// 从JWT中提取过期时间
private Date extractExpiration(String token) {
return extractClaim(token, Claims::getExpiration);
}
}
3. 配置Spring Security
接下来,我们需要配置Spring Security,以便在每个请求中验证JWT。我们可以通过自定义SecurityConfig
类来实现这一点。
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.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
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.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private UserDetailsService userDetailsService;
@Autowired
private JwtRequestFilter jwtRequestFilter;
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.csrf().disable()
.authorizeRequests()
.antMatchers("/authenticate").permitAll() // 允许任何人访问登录接口
.anyRequest().authenticated() // 其他所有请求都需要认证
.and()
.sessionManagement()
.sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 禁用会话
http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}
@Override
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
4. 创建JWT过滤器
为了让Spring Security能够自动验证每个请求中的JWT,我们需要创建一个自定义的过滤器JwtRequestFilter
。这个过滤器会在每个请求到达控制器之前检查是否有有效的JWT。
import org.springframework.beans.factory.annotation.Autowired;
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 JwtRequestFilter extends OncePerRequestFilter {
@Autowired
private UserDetailsService userDetailsService;
@Autowired
private JwtUtil jwtUtil;
@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;
if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
jwt = authorizationHeader.substring(7);
username = jwtUtil.extractUsername(jwt);
}
if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
if (jwtUtil.isTokenValid(jwt, userDetails.getUsername())) {
UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
userDetails, null, userDetails.getAuthorities());
usernamePasswordAuthenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
}
}
chain.doFilter(request, response);
}
}
5. 创建认证控制器
最后,我们需要创建一个控制器来处理用户的登录请求,并返回JWT。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.web.bind.annotation.*;
@RestController
public class AuthenticateController {
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private JwtUtil jwtUtil;
@Autowired
private UserDetailsService userDetailsService;
@PostMapping("/authenticate")
public ResponseEntity<?> createAuthenticationToken(@RequestBody AuthenticationRequest authenticationRequest) throws Exception {
try {
authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(authenticationRequest.getUsername(), authenticationRequest.getPassword())
);
} catch (BadCredentialsException e) {
throw new Exception("Incorrect username or password", e);
}
final UserDetails userDetails = userDetailsService.loadUserByUsername(authenticationRequest.getUsername());
final String jwt = jwtUtil.generateToken(userDetails.getUsername());
return ResponseEntity.ok(new AuthenticationResponse(jwt));
}
// 请求体类
static class AuthenticationRequest {
private String username;
private String password;
// Getters and Setters
}
// 响应体类
static class AuthenticationResponse {
private final String jwt;
public AuthenticationResponse(String jwt) {
this.jwt = jwt;
}
// Getter for jwt
}
}
总结
通过以上步骤,我们成功地在Spring Boot项目中集成了JWT,并实现了一个无状态的认证方案。相比于传统的基于会话的认证方式,JWT具有以下优势:
- 无状态:服务器不需要存储会话信息,减少了内存占用和性能开销。
- 易于扩展:适合分布式系统,多个服务器可以共享同一个JWT密钥,无需同步会话数据。
- 跨域支持:JWT可以轻松地在跨域请求中传递,适用于前后端分离的应用架构。
当然,JWT也有一些局限性,比如一旦签发的令牌无法撤销(除非设置较短的过期时间)。因此,在实际项目中,我们还需要根据具体需求权衡利弊,选择合适的认证方案。
希望今天的讲座对你有所帮助!如果你有任何问题,欢迎随时提问。谢谢大家!