此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Security 6.4.1！spring-doc.cadn.net.cn

测试 OAuth 2.0

当谈到 OAuth 2.0 时，前面介绍的相同原则仍然适用：最终，这取决于你被测试的方法在SecurityContextHolder.spring-doc.cadn.net.cn

例如，对于如下所示的控制器：spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(Principal user) {
    return user.getName();
}
@GetMapping("/endpoint")
fun foo(user: Principal): String {
    return user.name
}

它没有什么特定于 OAuth2 的，因此您可能能够简单地用@WithMockUser并且没事。spring-doc.cadn.net.cn

但是，如果您的控制器绑定到 Spring Security 的 OAuth 2.0 支持的某些方面，如下所示：spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(@AuthenticationPrincipal OidcUser user) {
    return user.getIdToken().getSubject();
}
@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal user: OidcUser): String {
    return user.idToken.subject
}

那么 Spring Security 的 test 支持就可以派上用场了。spring-doc.cadn.net.cn

测试 OIDC 登录

使用 Spring MVC Test 测试上述方法需要使用授权服务器模拟某种授权流。 当然，这将是一项艰巨的任务，这就是为什么 Spring Security 支持删除此样板的原因。spring-doc.cadn.net.cn

例如，我们可以告诉 Spring Security 包含一个默认的OidcUser使用oidcLogin RequestPostProcessor这样：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint").with(oidcLogin()));
mvc.get("/endpoint") {
    with(oidcLogin())
}

这将做的是配置关联的MockHttpServletRequest替换为OidcUser这包括一个简单的OidcIdToken,OidcUserInfo和Collection的授予权限。spring-doc.cadn.net.cn

具体来说，它将包括一个OidcIdToken替换为subclaim 设置为user:spring-doc.cadn.net.cn

assertThat(user.getIdToken().getClaim("sub")).isEqualTo("user");
assertThat(user.idToken.getClaim<String>("sub")).isEqualTo("user")

一OidcUserInfo未设置索赔：spring-doc.cadn.net.cn

assertThat(user.getUserInfo().getClaims()).isEmpty();
assertThat(user.userInfo.claims).isEmpty()

以及Collection只有一个授权的授权，SCOPE_read:spring-doc.cadn.net.cn

assertThat(user.getAuthorities()).hasSize(1);
assertThat(user.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
assertThat(user.authorities).hasSize(1)
assertThat(user.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))

Spring Security 执行必要的工作来确保OidcUser实例可用于这@AuthenticationPrincipal注解.spring-doc.cadn.net.cn

此外，它还将OidcUser更改为OAuth2AuthorizedClient它存入 mock 中OAuth2AuthorizedClientRepository. 如果您的测试使用@RegisteredOAuth2AuthorizedClient注解..spring-doc.cadn.net.cn

配置权限

在许多情况下，您的方法受到过滤器或方法安全性的保护，并且需要您的Authentication以授予某些权限来允许该请求。spring-doc.cadn.net.cn

在这种情况下，您可以使用authorities()方法：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(oidcLogin()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );
mvc.get("/endpoint") {
    with(oidcLogin()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

配置声明

虽然授予的权限在整个 Spring Security 中非常普遍，但我们在 OAuth 2.0 的情况下也有声明。spring-doc.cadn.net.cn

例如，假设您有一个user_id声明，该声明指示用户在系统中的 ID。 您可以在控制器中像这样访问它：spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(@AuthenticationPrincipal OidcUser oidcUser) {
    String userId = oidcUser.getIdToken().getClaim("user_id");
    // ...
}
@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal oidcUser: OidcUser): String {
    val userId = oidcUser.idToken.getClaim<String>("user_id")
    // ...
}

在这种情况下，您需要使用idToken()方法：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(oidcLogin()
                .idToken(token -> token.claim("user_id", "1234"))
        )
    );
mvc.get("/endpoint") {
    with(oidcLogin()
        .idToken {
            it.claim("user_id", "1234")
        }
    )
}

因为OidcUser从OidcIdToken.spring-doc.cadn.net.cn

其他配置

还有其他方法可用于进一步配置身份验证;这仅取决于您的控制者期望的数据：spring-doc.cadn.net.cn

如果您满足以下条件，最后一个选项很方便： 1. 拥有自己的OidcUser或 2. 需要更改 name 属性spring-doc.cadn.net.cn

例如，假设您的授权服务器在user_nameclaim 而不是sub索赔。 在这种情况下，您可以配置OidcUser手工：spring-doc.cadn.net.cn

OidcUser oidcUser = new DefaultOidcUser(
        AuthorityUtils.createAuthorityList("SCOPE_message:read"),
        OidcIdToken.withTokenValue("id-token").claim("user_name", "foo_user").build(),
        "user_name");

mvc
    .perform(get("/endpoint")
        .with(oidcLogin().oidcUser(oidcUser))
    );
val oidcUser: OidcUser = DefaultOidcUser(
    AuthorityUtils.createAuthorityList("SCOPE_message:read"),
    OidcIdToken.withTokenValue("id-token").claim("user_name", "foo_user").build(),
    "user_name"
)

mvc.get("/endpoint") {
    with(oidcLogin().oidcUser(oidcUser))
}

测试 OAuth 2.0 登录

与测试 OIDC 登录一样，测试 OAuth 2.0 登录也存在模拟授权流程的类似挑战。 正因为如此， Spring Security 还为非 OIDC 用例提供了测试支持。spring-doc.cadn.net.cn

假设我们有一个控制器，它将登录用户作为OAuth2User:spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(@AuthenticationPrincipal OAuth2User oauth2User) {
    return oauth2User.getAttribute("sub");
}
@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal oauth2User: OAuth2User): String? {
    return oauth2User.getAttribute("sub")
}

在这种情况下，我们可以告诉 Spring Security 包含一个默认的OAuth2User使用oauth2Login RequestPostProcessor这样：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint").with(oauth2Login()));
mvc.get("/endpoint") {
    with(oauth2Login())
}

这将做的是配置关联的MockHttpServletRequest替换为OAuth2User这包括一个简单的Mapof 属性和Collection的授予权限。spring-doc.cadn.net.cn

具体来说，它将包括一个Map键/值对为sub/user:spring-doc.cadn.net.cn

assertThat((String) user.getAttribute("sub")).isEqualTo("user");
assertThat(user.getAttribute<String>("sub")).isEqualTo("user")

以及Collection只有一个授权的授权，SCOPE_read:spring-doc.cadn.net.cn

assertThat(user.getAuthorities()).hasSize(1);
assertThat(user.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
assertThat(user.authorities).hasSize(1)
assertThat(user.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))

Spring Security 执行必要的工作来确保OAuth2User实例可用于这@AuthenticationPrincipal注解.spring-doc.cadn.net.cn

此外，它还将OAuth2User更改为OAuth2AuthorizedClient它存放在 mock 中OAuth2AuthorizedClientRepository. 如果您的测试使用@RegisteredOAuth2AuthorizedClient注解.spring-doc.cadn.net.cn

配置权限

在许多情况下，您的方法受到过滤器或方法安全性的保护，并且需要您的Authentication以授予某些权限来允许该请求。spring-doc.cadn.net.cn

在这种情况下，您可以使用authorities()方法：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(oauth2Login()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );
mvc.get("/endpoint") {
    with(oauth2Login()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

配置声明

虽然授予的权限在整个 Spring Security 中非常普遍，但我们在 OAuth 2.0 的情况下也有声明。spring-doc.cadn.net.cn

例如，假设您有一个user_id属性，该属性指示用户在系统中的 ID。 您可以在控制器中像这样访问它：spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(@AuthenticationPrincipal OAuth2User oauth2User) {
    String userId = oauth2User.getAttribute("user_id");
    // ...
}
@GetMapping("/endpoint")
fun foo(@AuthenticationPrincipal oauth2User: OAuth2User): String {
    val userId = oauth2User.getAttribute<String>("user_id")
    // ...
}

在这种情况下，您需要使用attributes()方法：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(oauth2Login()
                .attributes(attrs -> attrs.put("user_id", "1234"))
        )
    );
mvc.get("/endpoint") {
    with(oauth2Login()
        .attributes { attrs -> attrs["user_id"] = "1234" }
    )
}

其他配置

还有其他方法可用于进一步配置身份验证;这仅取决于您的控制者期望的数据：spring-doc.cadn.net.cn

  • clientRegistration(ClientRegistration)- 用于配置关联的OAuth2AuthorizedClient使用给定的ClientRegistrationspring-doc.cadn.net.cn

  • oauth2User(OAuth2User)- 为了配置完整的OAuth2User实例spring-doc.cadn.net.cn

如果您满足以下条件，最后一个选项很方便： 1. 拥有自己的OAuth2User或 2. 需要更改 name 属性spring-doc.cadn.net.cn

例如，假设您的授权服务器在user_nameclaim 而不是sub索赔。 在这种情况下，您可以配置OAuth2User手工：spring-doc.cadn.net.cn

OAuth2User oauth2User = new DefaultOAuth2User(
        AuthorityUtils.createAuthorityList("SCOPE_message:read"),
        Collections.singletonMap("user_name", "foo_user"),
        "user_name");

mvc
    .perform(get("/endpoint")
        .with(oauth2Login().oauth2User(oauth2User))
    );
val oauth2User: OAuth2User = DefaultOAuth2User(
    AuthorityUtils.createAuthorityList("SCOPE_message:read"),
    mapOf(Pair("user_name", "foo_user")),
    "user_name"
)

mvc.get("/endpoint") {
    with(oauth2Login().oauth2User(oauth2User))
}

测试 OAuth 2.0 客户端

无论您的用户如何进行身份验证，您可能还有其他令牌和客户端注册可用于您正在测试的请求。 例如，您的控制器可能依赖客户端凭证授予来获取根本不与用户关联的令牌：spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(@RegisteredOAuth2AuthorizedClient("my-app") OAuth2AuthorizedClient authorizedClient) {
    return this.webClient.get()
        .attributes(oauth2AuthorizedClient(authorizedClient))
        .retrieve()
        .bodyToMono(String.class)
        .block();
}
@GetMapping("/endpoint")
fun foo(@RegisteredOAuth2AuthorizedClient("my-app") authorizedClient: OAuth2AuthorizedClient?): String? {
    return this.webClient.get()
        .attributes(oauth2AuthorizedClient(authorizedClient))
        .retrieve()
        .bodyToMono(String::class.java)
        .block()
}

使用授权服务器模拟此握手可能很麻烦。 相反，您可以使用oauth2Client RequestPostProcessor要添加OAuth2AuthorizedClient转换为 mockOAuth2AuthorizedClientRepository:spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint").with(oauth2Client("my-app")));
mvc.get("/endpoint") {
    with(
        oauth2Client("my-app")
    )
}

这将做的是创建一个OAuth2AuthorizedClient它有一个简单的ClientRegistration,OAuth2AccessToken和资源所有者名称。spring-doc.cadn.net.cn

具体来说，它将包括一个ClientRegistration客户端 ID 为 “test-client” 且客户端密钥为 “test-secret”：spring-doc.cadn.net.cn

assertThat(authorizedClient.getClientRegistration().getClientId()).isEqualTo("test-client");
assertThat(authorizedClient.getClientRegistration().getClientSecret()).isEqualTo("test-secret");
assertThat(authorizedClient.clientRegistration.clientId).isEqualTo("test-client")
assertThat(authorizedClient.clientRegistration.clientSecret).isEqualTo("test-secret")

资源所有者名称 “user”：spring-doc.cadn.net.cn

assertThat(authorizedClient.getPrincipalName()).isEqualTo("user");
assertThat(authorizedClient.principalName).isEqualTo("user")

以及一个OAuth2AccessToken只有一个范围，read:spring-doc.cadn.net.cn

assertThat(authorizedClient.getAccessToken().getScopes()).hasSize(1);
assertThat(authorizedClient.getAccessToken().getScopes()).containsExactly("read");
assertThat(authorizedClient.accessToken.scopes).hasSize(1)
assertThat(authorizedClient.accessToken.scopes).containsExactly("read")

然后，可以使用@RegisteredOAuth2AuthorizedClient在 Controller 方法中。spring-doc.cadn.net.cn

配置范围

在许多情况下，OAuth 2.0 访问令牌附带一组范围。 如果您的控制器检查这些内容，请像这样说：spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(@RegisteredOAuth2AuthorizedClient("my-app") OAuth2AuthorizedClient authorizedClient) {
    Set<String> scopes = authorizedClient.getAccessToken().getScopes();
    if (scopes.contains("message:read")) {
        return this.webClient.get()
            .attributes(oauth2AuthorizedClient(authorizedClient))
            .retrieve()
            .bodyToMono(String.class)
            .block();
    }
    // ...
}
@GetMapping("/endpoint")
fun foo(@RegisteredOAuth2AuthorizedClient("my-app") authorizedClient: OAuth2AuthorizedClient): String? {
    val scopes = authorizedClient.accessToken.scopes
    if (scopes.contains("message:read")) {
        return webClient.get()
            .attributes(oauth2AuthorizedClient(authorizedClient))
            .retrieve()
            .bodyToMono(String::class.java)
            .block()
    }
    // ...
}

然后，您可以使用accessToken()方法：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(oauth2Client("my-app")
            .accessToken(new OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read"))))
        )
    );
mvc.get("/endpoint") {
    with(oauth2Client("my-app")
            .accessToken(OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read")))
    )
}

其他配置

还有其他方法可用于进一步配置身份验证;这仅取决于您的控制者期望的数据：spring-doc.cadn.net.cn

如果您想使用真正的ClientRegistrationspring-doc.cadn.net.cn

例如，假设您想要使用应用程序的ClientRegistration定义，如application.yml.spring-doc.cadn.net.cn

在这种情况下，您的测试可以自动装配ClientRegistrationRepository并查找您的测试所需的 ID：spring-doc.cadn.net.cn

@Autowired
ClientRegistrationRepository clientRegistrationRepository;

// ...

mvc
    .perform(get("/endpoint")
        .with(oauth2Client()
            .clientRegistration(this.clientRegistrationRepository.findByRegistrationId("facebook"))));
@Autowired
lateinit var clientRegistrationRepository: ClientRegistrationRepository

// ...

mvc.get("/endpoint") {
    with(oauth2Client("my-app")
        .clientRegistration(clientRegistrationRepository.findByRegistrationId("facebook"))
    )
}

测试 JWT 身份验证

要在资源服务器上发出授权请求，您需要一个不记名令牌。spring-doc.cadn.net.cn

如果您的资源服务器配置了 JWT，则这意味着需要对不记名令牌进行签名，然后根据 JWT 规范进行编码。 所有这些都可能相当令人生畏，尤其是当这不是您测试的重点时。spring-doc.cadn.net.cn

幸运的是，有许多简单的方法可以克服此困难，并允许您的测试专注于授权，而不是表示不记名令牌。 我们现在看看其中的两个：spring-doc.cadn.net.cn

jwt() RequestPostProcessor

第一种方法是通过jwt RequestPostProcessor. 其中最简单的如下所示：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint").with(jwt()));
mvc.get("/endpoint") {
    with(jwt())
}

这将做的是创建一个 mockJwt，通过任何身份验证 API 正确传递它，以便授权机制可以对其进行验证。spring-doc.cadn.net.cn

默认情况下，JWT它创建的具有以下特征：spring-doc.cadn.net.cn

{
  "headers" : { "alg" : "none" },
  "claims" : {
    "sub" : "user",
    "scope" : "read"
  }
}

以及由此产生的Jwt，将按以下方式通过：spring-doc.cadn.net.cn

assertThat(jwt.getTokenValue()).isEqualTo("token");
assertThat(jwt.getHeaders().get("alg")).isEqualTo("none");
assertThat(jwt.getSubject()).isEqualTo("sub");
assertThat(jwt.tokenValue).isEqualTo("token")
assertThat(jwt.headers["alg"]).isEqualTo("none")
assertThat(jwt.subject).isEqualTo("sub")

当然，这些值可以配置。spring-doc.cadn.net.cn

任何标头或声明都可以使用其相应的方法进行配置：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt -> jwt.header("kid", "one").claim("iss", "https://idp.example.org"))));
mvc.get("/endpoint") {
    with(
        jwt().jwt { jwt -> jwt.header("kid", "one").claim("iss", "https://idp.example.org") }
    )
}
mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt -> jwt.claims(claims -> claims.remove("scope")))));
mvc.get("/endpoint") {
    with(
        jwt().jwt { jwt -> jwt.claims { claims -> claims.remove("scope") } }
    )
}

这scope和scp此处声明的处理方式与普通 Bearer Token 请求中的处理方式相同。 但是，只需提供GrantedAuthority测试所需的实例：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(jwt().authorities(new SimpleGrantedAuthority("SCOPE_messages"))));
mvc.get("/endpoint") {
    with(
        jwt().authorities(SimpleGrantedAuthority("SCOPE_messages"))
    )
}

或者，如果您有一个自定义的Jwt自Collection<GrantedAuthority>converter 中，你也可以使用它来派生 authorities：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(jwt().authorities(new MyConverter())));
mvc.get("/endpoint") {
    with(
        jwt().authorities(MyConverter())
    )
}

您还可以指定完整的Jwt，其中Jwt.Builder非常方便：spring-doc.cadn.net.cn

Jwt jwt = Jwt.withTokenValue("token")
    .header("alg", "none")
    .claim("sub", "user")
    .claim("scope", "read")
    .build();

mvc
    .perform(get("/endpoint")
        .with(jwt().jwt(jwt)));
val jwt: Jwt = Jwt.withTokenValue("token")
    .header("alg", "none")
    .claim("sub", "user")
    .claim("scope", "read")
    .build()

mvc.get("/endpoint") {
    with(
        jwt().jwt(jwt)
    )
}

authentication() RequestPostProcessor

第二种方法是使用authentication() RequestPostProcessor. 本质上，您可以实例化自己的JwtAuthenticationToken并在测试中提供它，如下所示：spring-doc.cadn.net.cn

Jwt jwt = Jwt.withTokenValue("token")
    .header("alg", "none")
    .claim("sub", "user")
    .build();
Collection<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("SCOPE_read");
JwtAuthenticationToken token = new JwtAuthenticationToken(jwt, authorities);

mvc
    .perform(get("/endpoint")
        .with(authentication(token)));
val jwt = Jwt.withTokenValue("token")
    .header("alg", "none")
    .claim("sub", "user")
    .build()
val authorities: Collection<GrantedAuthority> = AuthorityUtils.createAuthorityList("SCOPE_read")
val token = JwtAuthenticationToken(jwt, authorities)

mvc.get("/endpoint") {
    with(
        authentication(token)
    )
}

请注意，作为这些的替代方案，您还可以模拟JwtDecoderbean 本身带有一个@MockBean注解。spring-doc.cadn.net.cn

测试 Opaque Token Authentication

与 JWT 类似，不透明令牌需要授权服务器来验证其有效性，这可能会使测试更加困难。 为了帮助解决这个问题，Spring Security 提供了对不透明令牌的 test 支持。spring-doc.cadn.net.cn

假设我们有一个控制器，它将身份验证检索为BearerTokenAuthentication:spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(BearerTokenAuthentication authentication) {
    return (String) authentication.getTokenAttributes().get("sub");
}
@GetMapping("/endpoint")
fun foo(authentication: BearerTokenAuthentication): String {
    return authentication.tokenAttributes["sub"] as String
}

在这种情况下，我们可以告诉 Spring Security 包含一个默认的BearerTokenAuthentication使用opaqueToken RequestPostProcessor方法，如下所示：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint").with(opaqueToken()));
mvc.get("/endpoint") {
    with(opaqueToken())
}

这将做的是配置关联的MockHttpServletRequest替换为BearerTokenAuthentication这包括一个简单的OAuth2AuthenticatedPrincipal,Mapof 属性和Collection的授予权限。spring-doc.cadn.net.cn

具体来说，它将包括一个Map键/值对为sub/user:spring-doc.cadn.net.cn

assertThat((String) token.getTokenAttributes().get("sub")).isEqualTo("user");
assertThat(token.tokenAttributes["sub"] as String).isEqualTo("user")

以及Collection只有一个授权的授权，SCOPE_read:spring-doc.cadn.net.cn

assertThat(token.getAuthorities()).hasSize(1);
assertThat(token.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
assertThat(token.authorities).hasSize(1)
assertThat(token.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))

Spring Security 执行必要的工作来确保BearerTokenAuthenticationinstance 可用于您的控制器方法。spring-doc.cadn.net.cn

配置权限

在许多情况下，您的方法受到过滤器或方法安全性的保护，并且需要您的Authentication以授予某些权限来允许该请求。spring-doc.cadn.net.cn

在这种情况下，您可以使用authorities()方法：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(opaqueToken()
            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
        )
    );
mvc.get("/endpoint") {
    with(opaqueToken()
        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
    )
}

配置声明

虽然授予的权限在整个 Spring Security 中非常常见，但在 OAuth 2.0 的情况下，我们也有属性。spring-doc.cadn.net.cn

例如，假设您有一个user_id属性，该属性指示用户在系统中的 ID。 您可以在控制器中像这样访问它：spring-doc.cadn.net.cn

@GetMapping("/endpoint")
public String foo(BearerTokenAuthentication authentication) {
    String userId = (String) authentication.getTokenAttributes().get("user_id");
    // ...
}
@GetMapping("/endpoint")
fun foo(authentication: BearerTokenAuthentication): String {
    val userId = authentication.tokenAttributes["user_id"] as String
    // ...
}

在这种情况下，您需要使用attributes()方法：spring-doc.cadn.net.cn

mvc
    .perform(get("/endpoint")
        .with(opaqueToken()
                .attributes(attrs -> attrs.put("user_id", "1234"))
        )
    );
mvc.get("/endpoint") {
    with(opaqueToken()
        .attributes { attrs -> attrs["user_id"] = "1234" }
    )
}

其他配置

还有其他方法可用于进一步配置身份验证;这仅取决于您的控制者期望的数据。spring-doc.cadn.net.cn

其中之一是principal(OAuth2AuthenticatedPrincipal)，可用于配置完整的OAuth2AuthenticatedPrincipal实例，该实例位于BearerTokenAuthenticationspring-doc.cadn.net.cn

如果您满足以下条件，这将非常方便： 1. 拥有自己的OAuth2AuthenticatedPrincipal或 2. 想要指定不同的委托人名称spring-doc.cadn.net.cn

例如，假设您的授权服务器在user_name属性而不是sub属性。 在这种情况下，您可以配置OAuth2AuthenticatedPrincipal手工：spring-doc.cadn.net.cn

Map<String, Object> attributes = Collections.singletonMap("user_name", "foo_user");
OAuth2AuthenticatedPrincipal principal = new DefaultOAuth2AuthenticatedPrincipal(
        (String) attributes.get("user_name"),
        attributes,
        AuthorityUtils.createAuthorityList("SCOPE_message:read"));

mvc
    .perform(get("/endpoint")
        .with(opaqueToken().principal(principal))
    );
val attributes: Map<String, Any> = Collections.singletonMap("user_name", "foo_user")
val principal: OAuth2AuthenticatedPrincipal = DefaultOAuth2AuthenticatedPrincipal(
    attributes["user_name"] as String?,
    attributes,
    AuthorityUtils.createAuthorityList("SCOPE_message:read")
)

mvc.get("/endpoint") {
    with(opaqueToken().principal(principal))
}

请注意，作为使用opaqueToken()test 支持，你也可以模拟OpaqueTokenIntrospectorbean 本身带有一个@MockBean注解。spring-doc.cadn.net.cn