什么是JWT? 如何在SpringBoot项目中集成JWT进行身份验证?

八股文_Springboot面试题 0 17

参考回答

JWT（JSON Web Token）是一种基于JSON的开放标准（RFC 7519），用于在网络应用环境间以一个安全的方式传递声明信息。JWT广泛用于用户身份验证和信息交换。JWT通常由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。JWT的主要特点是其数据的自包含性，可以减少服务器端存储的负担，适合分布式架构。

在Spring Boot中集成JWT进行身份验证的步骤如下：

引入依赖：
需要在pom.xml中加入JWT相关依赖，例如jjwt：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.11.5</version>
</dependency>

创建JWT工具类：
创建一个工具类，用于生成、解析和验证JWT。

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public class JwtUtil {

    private String secretKey = "secret";  // 用于签名的秘钥

    // 生成JWT
    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60))  // 过期时间1小时
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();
    }

    // 解析JWT
    public Claims extractClaims(String token) {
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();
    }

    // 获取用户名
    public String extractUsername(String token) {
        return extractClaims(token).getSubject();
    }

    // 判断JWT是否过期
    public boolean isTokenExpired(String token) {
        return extractClaims(token).getExpiration().before(new Date());
    }

    // 验证JWT
    public boolean validateToken(String token, String username) {
        return (username.equals(extractUsername(token)) && !isTokenExpired(token));
    }
}

实现JWT身份验证过滤器：
过滤器用于拦截请求并验证JWT。

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebFilter("/api/*")
public class JwtAuthenticationFilter implements Filter {

    private JwtUtil jwtUtil = new JwtUtil();

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String token = httpRequest.getHeader("Authorization");

        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            String username = jwtUtil.extractUsername(token);
            if (username != null) {
                // 可以在这里将用户名设置到SecurityContext中，进行用户身份验证
            }
        }
        chain.doFilter(request, response);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}

    @Override
    public void destroy() {}
}

配置Spring Security：
配置Spring Security，确保使用JWT过滤器进行身份验证。

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

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/api/login", "/api/register").permitAll()
            .anyRequest().authenticated()
            .and()
            .addFilter(new JwtAuthenticationFilter());
    }
}

创建登录接口生成JWT：
创建一个接口，用于用户登录并生成JWT。

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class AuthController {

    private JwtUtil jwtUtil = new JwtUtil();

    @PostMapping("/login")
    public String login(@RequestParam String username, @RequestParam String password) {
        // 假设密码验证通过
        return jwtUtil.generateToken(username);
    }
}

详细讲解与拓展

1. JWT的组成

JWT包含三部分：

头部（Header）：通常包含令牌的类型（JWT）和签名算法（如HMAC SHA256或RSA）。
载荷（Payload）：包含声明（Claims）。声明是JWT的主体部分，包含了可以用来描述用户的各种信息。比如，sub表示主题，iat表示签发时间等。
签名（Signature）：为了确保令牌没有被篡改，JWT会对头部和载荷使用一个密钥进行签名，常见的算法有HMAC SHA256、RSA。

一个JWT的结构示例：

header.payload.signature

2. JWT生成过程

JWT生成过程分为三个步骤：

将头部和载荷转换为JSON格式，然后编码为Base64Url。
使用签名算法（如HMAC SHA256）对编码后的头部和载荷进行签名。
生成最终的JWT字符串，格式为header.payload.signature。

3. JWT身份验证流程

用户在登录时输入用户名和密码，后端验证成功后生成JWT并返回给用户。
用户在后续请求时，将JWT放在请求头的Authorization字段中（以Bearer开头）。
后端通过过滤器解析JWT，验证是否过期和是否合法，如果合法则允许用户访问受保护的资源。

4. 安全性注意事项

密钥管理：JWT的签名使用的密钥非常关键，泄露密钥会导致JWT的安全性丧失。应妥善管理密钥，避免泄露。
过期时间：JWT通常会设置过期时间（exp），过期后用户必须重新登录。合理配置JWT的过期时间是防止滥用的有效手段。
HTTPS：JWT作为无状态认证方式，可能会在网络中暴露敏感信息，因此建议通过HTTPS传输JWT，避免中间人攻击。

总结

JWT是一种轻量级的身份验证方案，在Spring Boot中可以通过自定义JWT生成、解析工具类，并结合Spring Security进行集成，实现高效、安全的身份验证。在实际项目中，需要注意JWT的过期时间、密钥管理和安全传输等方面的配置，以确保系统的安全性和性能。