Spring Boot中的JWT集成：无状态认证方案

欢迎来到“轻松玩转JWT”讲座

大家好，欢迎来到今天的讲座！今天我们要聊的是Spring Boot中如何集成JWT（JSON Web Token），实现无状态认证。我们知道，在现代的Web应用中，用户认证是一个非常重要的环节。传统的Session-based认证方式虽然简单易用，但在分布式系统中却显得有些力不从心。而JWT则提供了一种轻量级、无状态的解决方案，非常适合微服务架构。

什么是JWT？

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在各方之间安全地传输信息。它由三部分组成，分别是：

1. Header（头部）：包含令牌的类型（通常是JWT）和加密算法（如HS256或RS256）。
2. Payload（载荷）：包含声明（claims），即你要传递的信息。常见的声明包括用户ID、用户名、过期时间等。

3. Signature（签名）：用于验证消息在此过程中是否被篡改。签名是通过对Header和Payload进行Base64编码后，使用指定的算法和密钥生成的。

   JWT的结构看起来像这样：

<base64url-encoded-header>.<base64url-encoded-payload>.<base64url-encoded-signature>

为什么选择JWT？

• 无状态：JWT不需要服务器端存储用户的会话信息，因此非常适合分布式系统。
• 跨域支持：JWT可以轻松地通过HTTP头或URL参数传递，适合跨域请求。
• 安全性：JWT可以通过签名确保数据的完整性，甚至可以通过公私钥对进行加密。
• 可扩展性：JWT的Payload可以携带自定义信息，方便扩展。

Spring Boot中的JWT集成

接下来，我们来看看如何在Spring Boot项目中集成JWT。我们将分为以下几个步骤：

1. 添加依赖

首先，我们需要在pom.xml中添加必要的依赖。这里我们使用jjwt库来处理JWT的生成和解析，同时使用spring-security来保护我们的API。

<dependencies>
    <!-- Spring Security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

    <!-- JWT Library -->
    <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>
</dependencies>

2. 创建JWT工具类

为了简化JWT的生成和解析，我们可以创建一个工具类JwtUtil。这个类将负责生成JWT、解析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 validateToken(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来保护我们的API，并使用JWT进行认证。我们可以通过自定义SecurityConfig类来实现这一点。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
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;

@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。这个过滤器会在每次请求时检查Authorization头，解析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.validateToken(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. 创建认证控制器

最后，我们需要创建一个控制器AuthController，用于处理用户的登录请求并返回JWT。

import org.springframework.beans.factory.annotation.Autowired;
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 AuthController {

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

    // DTOs for the request and response
    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;
        }

        // Getters
    }
}

总结

通过以上步骤，我们已经成功地在Spring Boot项目中集成了JWT，实现了无状态认证。JWT的优势在于它的轻量级和无状态特性，非常适合现代的微服务架构。通过这种方式，我们可以轻松地保护我们的API，并且无需担心会话管理的问题。

常见问题解答

1. JWT的安全性如何？

   • JWT的安全性取决于你使用的签名算法和密钥管理。建议使用强密码学算法（如HS256或RS256），并定期更换密钥。此外，避免在JWT中存储敏感信息，如密码或个人身份信息。

2. JWT的过期时间如何设置？

   • 你可以通过配置expiration属性来设置JWT的过期时间。通常建议设置较短的过期时间（如15分钟），并在客户端实现自动刷新机制。

3. 如何处理JWT的刷新？

   • 你可以为用户提供一个专门的刷新接口，允许他们在JWT过期前获取新的令牌。刷新令牌可以设置较长的过期时间，并且需要额外的安全措施（如IP地址绑定或设备指纹）。

希望今天的讲座对你有所帮助！如果你有任何问题或想法，欢迎在评论区留言讨论。下次再见！ ?

参考文献

• RFC 7519: JSON Web Token (JWT)
• Spring Security Documentation
• JWT.IO: The JSON Web Token Playground