深入解析 JWT：原理、应用与 Spring Security 集成

最新推荐文章于 2025-05-09 17:53:03 发布

一个差不多的先生

最新推荐文章于 2025-05-09 17:53:03 发布

阅读量809

点赞数 22

CC 4.0 BY-SA版权

文章标签： spring java 后端

本文链接：https://blog.csdn.net/Myqijiahai/article/details/145916525

深入解析 JWT：原理、应用与 Spring Security 集成

在现代 Web 开发中，JWT（JSON Web Token）已成为一种广泛使用的无状态认证机制，尤其适用于前后端分离的架构。本文将详细介绍 JWT 的原理、应用场景以及如何与 Spring Security 集成，帮助你构建安全、高效的认证系统。

一、JWT 简介

1.1 什么是 JWT？

JWT 是一种基于 Token 的认证授权机制，其核心是一个经过签名的 JSON 对象。JWT 的全称是 JSON Web Token，它通过数字签名的方式在用户和服务器之间传递安全可靠的信息。

1.2 JWT 的结构

JWT 由三部分组成，分别是 Header（头部）、Payload（负载）和 Signature（签名）：

Header：通常包含 Token 的类型（如 JWT）和签名算法（如 HS256）。
Payload：包含声明（Claims），如用户 ID、用户名、角色等信息。
Signature：用于验证 Token 的完整性和真实性，防止篡改。

1.3 JWT 的优势

无状态：JWT 是无状态的，服务器无需存储用户的会话信息，减轻了服务器的负担。
跨域支持：JWT 可以轻松实现跨域认证，适用于前后端分离的架构。
可扩展性：JWT 的负载部分可以包含任意信息，便于扩展。

二、JWT 工作原理

2.1 用户登录

用户通过用户名和密码登录，服务器验证用户信息后，生成一个 JWT 并返回给客户端。

2.2 客户端存储 JWT

客户端将 JWT 存储在浏览器的 localStorage、sessionStorage 或 HTTP Cookie 中。

2.3 请求携带 JWT

客户端在每次请求时，将 JWT 放在 HTTP 请求的 Authorization 头部中，格式为 Bearer <token>。

2.4 服务器验证 JWT

服务器接收到请求后，解析并验证 JWT 的合法性（如签名是否正确、Token 是否过期等）。如果验证通过，允许访问受保护的资源。

三、JWT 应用场景

3.1 单点登录（SSO）

JWT 是实现单点登录的理想选择。用户登录后，服务器生成一个 JWT，客户端在访问其他服务时携带该 Token，无需重复登录。

3.2 微服务认证

在微服务架构中，JWT 可以用于服务间的认证。每个服务通过验证 JWT 来确认请求的合法性。

3.3 第三方登录

JWT 也适用于第三方登录场景，如使用 Google 或 GitHub 登录。通过 OAuth2 获取用户信息后，生成 JWT 并用于后续认证。

四、JWT 与 Spring Security 集成

4.1 添加依赖

在 pom.xml 文件中添加 JWT 和 Spring Security 的依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

4.2 配置 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;

    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }

    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.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }

    private Boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }

    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() + 1000 * 60 * 60 * 10)) // 10小时
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }

    public Boolean validateToken(String token, String username) {
        final String extractedUsername = extractUsername(token);
        return (extractedUsername.equals(username) && !isTokenExpired(token));
    }
}

4.3 配置 Spring Security

创建一个 SecurityConfig 类，配置 Spring Security 以支持 JWT 认证：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Autowired
    private UserDetailsService userDetailsService;

    @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.4 创建 JWT 请求过滤器

创建一个 JwtRequestFilter 类，用于在每个请求中解析 JWT，并将其设置到 Spring Security 上下文中：

@Component
public class JwtRequestFilter 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;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = 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);
    }
}