第二季第三课 - Spring Boot OAuth2 JWT 入门

html

使用 OAuth2 和 JWT 保护您的 Spring Boot 应用程序：全面指南
目录

简介 ..............................................1
开始使用 Spring Boot OAuth2 JWT .................2

理解 OAuth2 和 JWT ....................3
设置开发环境 ...........4


在 Spring Boot 中配置安全性 ....................5

添加安全依赖 ......................6
创建 RSA 密钥对 ..............................7
实现 SecurityConfig ......................8


生成和解码 JWT 令牌 .......................10

理解 JWT 结构 ....................11
实现 JWT 编码器和解码器 ..........12
处理认证 ........................13


测试实现 ............................14

运行应用程序 .......................15
验证 JWT 生成 ........................16


结论 .............................................18
附加资源 .......................19

---
简介
在当今数字环境中，网络应用程序的安全性至关重要，因为威胁不断演变，数据泄露可能带来严重后果。Spring Boot 是广泛使用的 Java 框架，提供了强大的安全功能，简化了构建安全应用程序的过程。在这些功能中，OAuth2 和 JWT (JSON Web Tokens) 因其在管理身份验证和授权方面的有效性而脱颖而出。
本指南深入探讨在 Spring Boot 应用程序中配置 OAuth2 与 JWT。我们将探讨设置安全配置、生成用于令牌签名的 RSA 密钥对、实现 JWT 编码器和解码器，以及确保无状态的 RESTful API。无论您是初学者还是经验丰富的开发人员，本全面指南都将为您提供有效保护 Spring Boot 应用程序所需的知识。
使用 OAuth2 和 JWT 的优势：

可扩展性：支持具有多个客户端的大规模应用程序。
无状态性：JWT 令牌消除了服务器端会话的需要。
灵活性：便于与各种身份提供者集成。

缺点：

复杂性：初始设置对新手来说可能比较复杂。
令牌管理：必须正确处理令牌过期和撤销。




功能
OAuth2
JWT




目的
授权框架
用于安全数据传输的令牌标准


状态管理
无状态
无状态


使用场景
委托访问
安全信息交换



了解何时何地实现这些技术至关重要。OAuth2 非常适合需要委托访问的场景，例如授予第三方应用程序对用户资源的有限访问权限。另一方面，JWT 则非常适合作为 JSON 对象在各方之间安全传输信息。
---
第一章：开始使用 Spring Boot OAuth2 JWT
1.1 理解 OAuth2 和 JWT
OAuth2 是一种授权框架，允许应用程序在 HTTP 服务上获取对用户帐户的有限访问。它将用户认证委托给托管用户帐户的服务，并授权第三方应用程序访问用户帐户。
JWT (JSON Web Tokens) 是紧凑、URL 安全的令牌，代表在两方之间安全传输的声明。每个 JWT 由三个部分组成：Header、Payload 和 Signature。
JWT 的优势：

紧凑性：适用于 URL、请求头和 Cookie 中的使用。
自包含：包含关于用户的所有必要信息。
安全性：使用秘密或公钥/私钥对进行签名。

1.2 设置开发环境
首先，确保您已安装以下工具：

Java Development Kit (JDK) 11 或更高版本
Maven：用于项目管理和构建自动化。
Spring Boot：使用 Spring Initializr 或您偏好的方法设置项目。
OpenSSL：用于生成 RSA 密钥对。

在 Windows 上安装 OpenSSL：

使用 Windows Subsystem for Linux (WSL)：

从 Microsoft Store 安装 Ubuntu。
打开 Ubuntu 终端并执行 OpenSSL 命令。


直接安装：

从官方网站下载 OpenSSL 二进制文件。
将 OpenSSL 添加到系统的 PATH 环境变量中。



---
第二章：在 Spring Boot 中配置安全性
2.1 添加安全依赖
首先，在您的 pom.xml 中添加必要的依赖项：




		
		
			
			
Java
			
			
&lt;dependencies&gt;
    &lt;!-- Spring Security --&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;!-- OAuth2 Resource Server --&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;!-- JWT Support --&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.security&lt;/groupId&gt;
        &lt;artifactId&gt;spring-security-oauth2-jose&lt;/artifactId&gt;
    &lt;/dependency&gt;
&lt;/dependencies&gt;

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
&lt;dependencies&gt;
    &lt;!-- Spring Security --&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;!-- OAuth2 Resource Server --&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;!-- JWT Support --&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.security&lt;/groupId&gt;
        &lt;artifactId&gt;spring-security-oauth2-jose&lt;/artifactId&gt;
    &lt;/dependency&gt;
&lt;/dependencies&gt;
 
					
				
			
		


这些依赖项促进了 OAuth2 资源服务器功能和 JWT 支持在您的 Spring Boot 应用程序中的实现。
2.2 创建 RSA 密钥对
RSA (Rivest–Shamir–Adleman) 是一种广泛用于安全数据传输的非对称加密算法。我们将使用 RSA 密钥来签名和验证 JWT 令牌。
使用 OpenSSL 生成 RSA 密钥：

生成私钥：

        



		
		
			
			
Java
			
			
openssl genrsa -out keypair.pem 2048

			
				
					
				
					1
2
3
				
						 
openssl genrsa -out keypair.pem 2048
 
					
				
			
		


    
提取公钥：

        



		
		
			
			
Java
			
			
openssl rsa -in keypair.pem -pubout -out public.pem

			
				
					
				
					1
2
3
				
						 
openssl rsa -in keypair.pem -pubout -out public.pem
 
					
				
			
		


    
转换为 PKCS8 格式：

        



		
		
			
			
Java
			
			
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out private.pem

			
				
					
				
					1
2
3
				
						 
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out private.pem
 
					
				
			
		


    

生成的 private.pem 和 public.pem 文件将存储在项目的 src/main/resources/certs/ 目录中。
commands.txt 内容：




		
		
			
			
Java
			
			
openssl genrsa -out keypair.pem 2048
openssl rsa -in keypair.pem -pubout -out public.pem
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out private.pem

			
				
					
				
					1
2
3
4
5
				
						 
openssl genrsa -out keypair.pem 2048
openssl rsa -in keypair.pem -pubout -out public.pem
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out private.pem
 
					
				
			
		


2.3 实现 SecurityConfig
创建一个安全配置类，以定义您的应用程序如何处理安全方面。




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.security;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.studyeasy.SpringRestdemo.config.RsaKeyProperties;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.oauth2.jwt.*;
import org.springframework.security.config.http.SessionCreationPolicy;

@Configuration
public class SecurityConfig {

    private final RsaKeyProperties rsaKeys;

    public SecurityConfig(RsaKeyProperties rsaKeys) {
        this.rsaKeys = rsaKeys;
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests(auth -> auth
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt
                    .decoder(jwtDecoder())
                    .encoder(jwtEncoder())
                )
            )
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        return http.build();
    }

    @Bean
    public JwtDecoder jwtDecoder() {
        return NimbusJwtDecoder.withPublicKey(rsaKeys.publicKey()).build();
    }

    @Bean
    public JwtEncoder jwtEncoder() {
        JWK jwk = new RSAKey.Builder(rsaKeys.publicKey()).privateKey(rsaKeys.privateKey()).build();
        JWKSource<SecurityContext> jwks = new ImmutableJWKSet<>(new JWKSet(jwk));
        return new NimbusJwtEncoder(jwks);
    }
}

			
				
					
				
					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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
				
						 
package org.studyeasy.SpringRestdemo.security;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.studyeasy.SpringRestdemo.config.RsaKeyProperties;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.oauth2.jwt.*;
import org.springframework.security.config.http.SessionCreationPolicy;
 
@Configuration
public class SecurityConfig {
 
    private final RsaKeyProperties rsaKeys;
 
    public SecurityConfig(RsaKeyProperties rsaKeys) {
        this.rsaKeys = rsaKeys;
    }
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests(auth -> auth
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt
                    .decoder(jwtDecoder())
                    .encoder(jwtEncoder())
                )
            )
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        return http.build();
    }
 
    @Bean
    public JwtDecoder jwtDecoder() {
        return NimbusJwtDecoder.withPublicKey(rsaKeys.publicKey()).build();
    }
 
    @Bean
    public JwtEncoder jwtEncoder() {
        JWK jwk = new RSAKey.Builder(rsaKeys.publicKey()).privateKey(rsaKeys.privateKey()).build();
        JWKSource<SecurityContext> jwks = new ImmutableJWKSet<>(new JWKSet(jwk));
        return new NimbusJwtEncoder(jwks);
    }
}
 
					
				
			
		


解释：

SecurityFilterChain：定义安全过滤链，禁用 CSRF，要求所有请求进行身份验证，并将会话策略设置为无状态。
JwtDecoder：使用公钥解码传入的 JWT 令牌。
JwtEncoder：使用公钥和私钥编码 JWT 令牌。

---
第三章：生成和解码 JWT 令牌
3.1 理解 JWT 结构
JWT 由三个部分组成：

Header：指定签名算法和令牌类型。
Payload：包含关于实体（通常是用户）和附加数据的声明或声明。
Signature：确保令牌未被篡改。

示例 JWT：




		
		
			
			
Java
			
			
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiJ1c2VyMTIzIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNjAxMjM0NTY3fQ.
QmFzZTY0U2lnbmF0dXJl

			
				
					
				
					1
2
3
4
5
				
						 
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiJ1c2VyMTIzIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNjAxMjM0NTY3fQ.
QmFzZTY0U2lnbmF0dXJl
 
					
				
			
		


3.2 实现 JWT 编码器和解码器
RsaKeyProperties.java：




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.config;

import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "rsa")
public class RsaKeyProperties {
    private RSAPublicKey publicKey;
    private RSAPrivateKey privateKey;

    // Getters and Setters

    public RSAPublicKey getPublicKey() {
        return publicKey;
    }

    public void setPublicKey(RSAPublicKey publicKey) {
        this.publicKey = publicKey;
    }

    public RSAPrivateKey getPrivateKey() {
        return privateKey;
    }

    public void setPrivateKey(RSAPrivateKey privateKey) {
        this.privateKey = privateKey;
    }
}

			
				
					
				
					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
32
33
				
						 
package org.studyeasy.SpringRestdemo.config;
 
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
 
@Component
@ConfigurationProperties(prefix = "rsa")
public class RsaKeyProperties {
    private RSAPublicKey publicKey;
    private RSAPrivateKey privateKey;
 
    // Getters and Setters
 
    public RSAPublicKey getPublicKey() {
        return publicKey;
    }
 
    public void setPublicKey(RSAPublicKey publicKey) {
        this.publicKey = publicKey;
    }
 
    public RSAPrivateKey getPrivateKey() {
        return privateKey;
    }
 
    public void setPrivateKey(RSAPrivateKey privateKey) {
        this.privateKey = privateKey;
    }
}
 
					
				
			
		


application.properties：




		
		
			
			
Java
			
			
rsa.public-key=classpath:certs/public.pem
rsa.private-key=classpath:certs/private.pem

			
				
					
				
					1
2
3
4
				
						 
rsa.public-key=classpath:certs/public.pem
rsa.private-key=classpath:certs/private.pem
 
					
				
			
		


解释：

RsaKeyProperties：将 application.properties 中指定的 RSA 公钥和私钥绑定到 Java 对象。
JWT 编码器和解码器：在 SecurityConfig.java 中使用 RSA 密钥进行配置。

3.3 处理认证
要管理认证，您需要覆盖 Spring Security 提供的默认认证管理器。
SecurityConfig.java (更新)：




		
		
			
			
Java
			
			
@Bean
public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
    return config.getAuthenticationManager();
}

			
				
					
				
					1
2
3
4
5
6
				
						 
@Bean
public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
    return config.getAuthenticationManager();
}
 
					
				
			
		


此 bean 允许您在需要的地方注入 AuthenticationManager，便于用户认证过程。
---
第四章：测试实现
4.1 运行应用程序
运行 Spring Boot 应用程序：

导航到项目目录：

        



		
		
			
			
Java
			
			
cd S02L03 - Spring Boot OAuth2 JWT getting started

			
				
					
				
					1
2
3
				
						 
cd S02L03 - Spring Boot OAuth2 JWT getting started
 
					
				
			
		


    
执行 Maven Wrapper：

        



		
		
			
			
Java
			
			
./mvnw spring-boot:run

			
				
					
				
					1
2
3
				
						 
./mvnw spring-boot:run
 
					
				
			
		


    

预期输出：




		
		
			
			
Java
			
			
2023-10-10 10:00:00.000  INFO 12345 --- [           main] o.s.boot.SpringApplication               : Starting Spring Boot application...
2023-10-10 10:00:05.000  INFO 12345 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-10-10 10:00:05.000  INFO 12345 --- [           main] o.s.b.a.e.web.EndpointLinksResolver      : Exposing 1 endpoint(s) beneath base path '/actuator'

			
				
					
				
					1
2
3
4
5
				
						 
2023-10-10 10:00:00.000  INFO 12345 --- [           main] o.s.boot.SpringApplication               : Starting Spring Boot application...
2023-10-10 10:00:05.000  INFO 12345 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-10-10 10:00:05.000  INFO 12345 --- [           main] o.s.b.a.e.web.EndpointLinksResolver      : Exposing 1 endpoint(s) beneath base path '/actuator'
 
					
				
			
		


4.2 验证 JWT 生成
运行应用程序后，尝试访问受保护的端点。由于应用程序配置为所有请求都需要认证，访问没有有效 JWT 的端点将导致未经授权的错误。
示例请求：




		
		
			
			
Java
			
			
GET http://localhost:8080/account

			
				
					
				
					1
2
3
				
						 
GET http://localhost:8080/account
 
					
				
			
		


预期响应：




		
		
			
			
Java
			
			
{
    "error": "Unauthorized",
    "message": "Full authentication is required to access this resource",
    "status": 401,
    "timestamp": "2023-10-10T10:05:00Z"
}

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
{
    "error": "Unauthorized",
    "message": "Full authentication is required to access this resource",
    "status": 401,
    "timestamp": "2023-10-10T10:05:00Z"
}
 
					
				
			
		


要获取有效的 JWT，请实现一个认证控制器，认证用户并发放令牌。
AccountController.java：




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.controller;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/auth")
public class AccountController {

    private final AuthenticationManager authManager;
    private final JwtEncoder jwtEncoder;

    public AccountController(AuthenticationManager authManager, JwtEncoder jwtEncoder) {
        this.authManager = authManager;
        this.jwtEncoder = jwtEncoder;
    }

    @PostMapping("/login")
    public String login(@RequestBody AuthRequest authRequest) {
        Authentication authentication = authManager.authenticate(
            new UsernamePasswordAuthenticationToken(
                authRequest.getUsername(),
                authRequest.getPassword()
            )
        );

        return jwtEncoder.encode(JwtClaimsSet.builder()
            .subject(authentication.getName())
            .issuedAt(Instant.now())
            .expiresAt(Instant.now().plusSeconds(3600))
            .build()
        ).getTokenValue();
    }
}

			
				
					
				
					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
32
33
34
35
36
37
38
				
						 
package org.studyeasy.SpringRestdemo.controller;
 
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.*;
 
@RestController
@RequestMapping("/auth")
public class AccountController {
 
    private final AuthenticationManager authManager;
    private final JwtEncoder jwtEncoder;
 
    public AccountController(AuthenticationManager authManager, JwtEncoder jwtEncoder) {
        this.authManager = authManager;
        this.jwtEncoder = jwtEncoder;
    }
 
    @PostMapping("/login")
    public String login(@RequestBody AuthRequest authRequest) {
        Authentication authentication = authManager.authenticate(
            new UsernamePasswordAuthenticationToken(
                authRequest.getUsername(),
                authRequest.getPassword()
            )
        );
 
        return jwtEncoder.encode(JwtClaimsSet.builder()
            .subject(authentication.getName())
            .issuedAt(Instant.now())
            .expiresAt(Instant.now().plusSeconds(3600))
            .build()
        ).getTokenValue();
    }
}
 
					
				
			
		


AuthRequest.java：




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.controller;

public class AuthRequest {
    private String username;
    private String password;

    // Getters and Setters
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						 
package org.studyeasy.SpringRestdemo.controller;
 
public class AuthRequest {
    private String username;
    private String password;
 
    // Getters and Setters
}
 
					
				
			
		


工作流程：

用户认证：用户向 /auth/login 发送包含凭据的 POST 请求。
令牌发放：认证成功后，服务器发放 JWT。
访问受保护资源：用户在 Authorization 头中以 Bearer 令牌形式包含 JWT，以访问受保护的端点。

示例登录请求：




		
		
			
			
Java
			
			
POST http://localhost:8080/auth/login
Content-Type: application/json

{
    "username": "user123",
    "password": "password"
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						 
POST http://localhost:8080/auth/login
Content-Type: application/json
 
{
    "username": "user123",
    "password": "password"
}
 
					
				
			
		


示例响应：




		
		
			
			
Java
			
			
"eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."

			
				
					
				
					1
2
3
				
						 
"eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."
 
					
				
			
		


使用 JWT 访问受保护的端点：




		
		
			
			
Java
			
			
GET http://localhost:8080/account
Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...

			
				
					
				
					1
2
3
4
				
						 
GET http://localhost:8080/account
Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
 
					
				
			
		


预期成功响应：




		
		
			
			
Java
			
			
{
    "accountId": "12345",
    "balance": 1000.00,
    "currency": "USD"
}

			
				
					
				
					1
2
3
4
5
6
7
				
						 
{
    "accountId": "12345",
    "balance": 1000.00,
    "currency": "USD"
}
 
					
				
			
		


---
第五章：结论
保护您的 Spring Boot 应用程序对于保障数据安全和确保客户端与服务器之间的可信互动至关重要。通过实现 OAuth2 和 JWT，您建立了一个既可扩展又安全的强大身份验证和授权机制。
在本指南中，我们涵盖了：

设置 OAuth2 和 JWT：集成 OAuth2 作为授权框架，并利用 JWT 进行基于令牌的身份验证。
生成 RSA 密钥对：创建 RSA 密钥，对 JWT 令牌进行签名和验证，增强安全性。
配置 Spring Security：定义安全配置以管理身份验证、授权和会话管理。
实现 JWT 编码器和解码器：通过自定义编码器和解码器确保令牌的无缝生成和验证。
测试应用程序：通过认证用户并使用 JWT 令牌访问受保护资源，验证安全设置。

通过遵循这些步骤，您可以增强 Spring Boot 应用程序的安全性，为用户提供安全可靠的体验。
SEO 优化关键词：Spring Boot 安全, OAuth2 JWT 集成, Spring Security 配置, JWT 令牌生成, RSA 密钥对 Spring Boot, 安全 RESTful APIs, Spring Boot OAuth2 教程, JSON Web Tokens Spring, 无状态认证 Spring, Spring Boot 认证
---
附加资源

Spring Security 参考
OAuth2 文档
JWT.io 介绍
Spring Boot 官方指南
OpenSSL 文档
理解 RSAPrivateKey 和 RSAPublicKey
Nimbus JOSE + JWT 库

---
注意：本文由 AI 生成。
功能	OAuth2	JWT
目的	授权框架	用于安全数据传输的令牌标准
状态管理	无状态	无状态
使用场景	委托访问	安全信息交换