发布于 由admin

Spring中的JWT(JSON Web Token)集成：无状态认证方案

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

开场白

大家好，欢迎来到今天的讲座！今天我们要聊聊Spring中的JWT（JSON Web Token）集成，以及如何实现一个无状态的认证方案。如果你已经对JWT有所了解，那太好了；如果你还不熟悉，也不用担心，我会尽量用通俗易懂的语言来解释。

首先，让我们想象一下你正在开发一个电商网站。用户可以注册、登录、浏览商品、添加到购物车，最后完成支付。在这个过程中，我们如何确保用户的操作是安全的？如何防止未经授权的访问？这就是认证和授权的作用了。

传统的认证方式通常依赖于服务器端的会话（Session），每次用户登录后，服务器会为该用户创建一个会话，并将这个会话存储在内存或数据库中。这种方式虽然简单，但在分布式系统中却存在一些问题：

  1. 扩展性差：每个服务器都需要维护自己的会话数据，当用户请求被路由到不同的服务器时，可能会导致会话丢失。
  2. 性能瓶颈：随着用户数量的增加，会话数据的存储和管理会成为性能瓶颈。
  3. 单点故障：如果会话数据存储在一个地方，一旦该存储节点出现问题，所有用户的会话都会失效。

那么，有没有一种更好的解决方案呢？答案就是——JWT！

什么是JWT？

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在网络应用之间安全地传输信息。它是一个自包含的令牌，包含了用户的身份信息和其他元数据。JWT的最大特点是它可以在客户端和服务器之间传递，而不需要服务器端存储任何会话信息。因此，JWT非常适合用于无状态的认证方案。

JWT的结构非常简单，由三部分组成，分别是：

  1. Header（头部）：描述了令牌的类型（通常是JWT）以及所使用的签名算法（如HMAC SHA-256或RSA）。
  2. Payload（负载）：包含了声明（claims），即你要传递的信息。常见的声明包括iss（发行人）、exp（过期时间）、sub（主题）等。
  3. Signature（签名）：用于验证令牌的完整性和来源。签名是通过对头部和负载进行编码后，使用密钥进行加密生成的。

一个典型的JWT看起来像这样：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

这三部分通过.分隔开，分别对应Header、Payload和Signature。

JWT的工作流程

  1. 用户登录：用户提交用户名和密码，服务器验证通过后，生成一个JWT并返回给客户端。
  2. 客户端存储JWT：客户端将JWT存储在本地（如浏览器的LocalStorage或Cookie中），并在后续的请求中将其作为Authorization头的一部分发送给服务器。
  3. 服务器验证JWT：服务器接收到请求后，解析JWT并验证其签名。如果签名有效且未过期，则允许访问受保护的资源。
  4. 无状态认证：由于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也有一些局限性，比如一旦签发的令牌无法撤销（除非设置较短的过期时间）。因此，在实际项目中，我们还需要根据具体需求权衡利弊，选择合适的认证方案。

希望今天的讲座对你有所帮助！如果你有任何问题，欢迎随时提问。谢谢大家！

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注