JSON Web Tokens（JWT）与SpringSecurity如何配合使用？_jwt token + spring websecurityconfig

JSON Web Tokens（JWT）是一种开放标准（RFC 7519），用于在网络应用环境间传递声明（claims）。JWT通常用于身份验证和信息交换，因为它们可以通过数字签名来验证。在Spring Security中，JWT可用于管理用户的认证和授权。

如何在Spring Security中使用JWT

要在Spring Security中使用JWT进行认证流程，你需要按照以下步骤进行：

1. 添加JWT库依赖

为了处理JWT，你需要添加一个处理JWT操作的库。一个常见的库是java-jwt或jjwt。在Maven的pom.xml文件中添加依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version> <!-- 指定你所需的版本 -->
</dependency>
1
2
3
4
5

2. 创建JWT工具类

创建一个工具类来生成和解析JWT。这个类将包含创建一个新的JWT令牌和从JWT令牌中解析出用户信息的逻辑。

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

public class JwtUtil {

    private static final String SECRET_KEY = "my_secret_key"; // 应使用更安全的密钥，并在配置文件中管理

    // 生成JWT令牌
    public static String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }

    // 从JWT令牌中解析用户名
    public static String getUsernameFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }

    // ... 其他逻辑，如验证令牌有效期
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3. 创建JWT认证过滤器

创建一个自定义的认证过滤器，用于拦截请求，提取JWT令牌，并验证该令牌：

import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    @Override
    protected boolean requiresAuthentication(HttpServletRequest request, HttpServletResponse response) {
        String jwtToken = resolveToken(request);
        if (jwtToken != null && JwtUtil.validateToken(jwtToken)) {
            Authentication auth = getAuthentication(jwtToken);
            if (auth != null) {
                SecurityContextHolder.getContext().setAuthentication(auth);
            }
        }
        return false;
    }
    
    private Authentication getAuthentication(String token) {
        // 使用JwtUtil从令牌中解码出用户名，并创建一个Authentication对象返回
        // ...
    }
    
    private String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7); // 删除"Bearer "前缀
        }
        return null;
    }
    
    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

4. 配置Spring Security

将自定义的JWT认证过滤器与Spring Security集成，并确保其在UsernamePasswordAuthenticationFilter之前运行：

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // ...
            .addFilterBefore(new JwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

5. 处理认证和授权

在控制器中，使用JWT来执行认证和授权时，你可以使用Spring Security的认证注解（如@PreAuthorize），因为在此时用户的认证信息已经存储在Spring Security的SecurityContext中了。

@RestController
public class MyController {

    @GetMapping("/protected")
    @PreAuthorize("isAuthenticated()") // 只有通过JWT认证的用户才能访问
    public ResponseEntity<String> getProtectedResource() {
        // ...
    }
}
1
2
3
4
5
6
7
8
9

总结

整合JWT与Spring Security需要创建用于JWT操作的工具类、自定义过滤器来解析请求中的JWT令牌，并在安全上下文中填充认证信息。然后，你需要将这个过滤器配置到Spring Security中，让其在适当的位置拦截请求。最后，服务端的端点可以根据已经验证的凭据进行保护，使用Spring Security提供的方法级别安全注解来控制访问。

注意在生产环境中，密钥（SECRET_KEY）应该是保密的，并且足够复杂，通常会从安全存储的配置中取得，而不是直接硬编码在代码中。更进一步，你可能还会考虑使用JWT的过期时间，刷新令牌机制和其他的安全策略以确保整体的安全性。

另外，JWT认证的逻辑可以根据个人的应用需求进行扩展与调整，例如，你可能需要处理不同形式的认证（如OAuth2），或者需要支持多种验证方法（将基本身份验证或OAuth2与JWT结合使用）。在不同的场景中，Spring Security提供了足够的灵活性来满足这些需求。

在最佳实践中，我们通常会对所有的JWT处理逻辑进行单元测试和集成测试，确保代码的健壮性和安全性。

Spring Security和JWT的结合使用，为Java应用程序带来了一种强大的方式来确保REST API或者其他形式的Web服务的安全性，同时也提供了一种无状态、易于扩展的解决方案，非常适合现代微服务架构。