此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.3.1！Spring中文文档

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.3.1！Spring中文文档

如果 Spring Security 位于类路径上，则默认情况下 Web 应用程序是安全的。 Spring Boot 依靠 Spring Security 的内容协商策略来确定是否使用 或 . 若要向 Web 应用程序添加方法级安全性，还可以使用所需的设置进行添加。 其他信息可以在 Spring Security 参考指南中找到。httpBasicformLogin@EnableGlobalMethodSecuritySpring中文文档

默认值只有一个用户。 用户名是 ，密码是随机的，在应用程序启动时以 WARN 级别打印，如以下示例所示：UserDetailsServiceuserSpring中文文档

Using generated security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35

This generated password is for development use only. Your security configuration must be updated before running your application in production.
如果微调日志记录配置，请确保将类别设置为日志级消息。 否则，不会打印默认密码。org.springframework.boot.autoconfigure.securityWARN

您可以通过提供 和 来更改用户名和密码。spring.security.user.namespring.security.user.passwordSpring中文文档

默认情况下，在 Web 应用程序中获得的基本功能包括：Spring中文文档

  • 具有内存中存储的 Bean （或者在 WebFlux 应用程序的情况下） bean 和具有生成密码的单个用户（有关用户的属性，请参阅 SecurityProperties.User）。UserDetailsServiceReactiveUserDetailsServiceSpring中文文档

  • 整个应用程序（包括执行器端点，如果执行器位于类路径上），基于表单的登录或 HTTP 基本安全性（取决于请求中的标头）。AcceptSpring中文文档

  • A 用于发布身份验证事件。DefaultAuthenticationEventPublisherSpring中文文档

您可以通过为其添加 Bean 来提供不同的 bean。AuthenticationEventPublisherSpring中文文档

如果微调日志记录配置，请确保将类别设置为日志级消息。 否则，不会打印默认密码。org.springframework.boot.autoconfigure.securityWARN

MVC 安全性

默认安全配置在 和 中实现。 导入 Web 安全性并配置身份验证，这在非 Web 应用程序中也相关。SecurityAutoConfigurationUserDetailsServiceAutoConfigurationSecurityAutoConfigurationSpringBootWebSecurityConfigurationUserDetailsServiceAutoConfigurationSpring中文文档

要完全关闭默认的 Web 应用程序安全配置或组合多个 Spring Security 组件（如 OAuth2 客户端和资源服务器），请添加 bean 类型（这样做不会禁用配置或执行器的安全性）。 要同时关闭配置，您可以添加类型为 、 或 的 Bean。SecurityFilterChainUserDetailsServiceUserDetailsServiceUserDetailsServiceAuthenticationProviderAuthenticationManagerSpring中文文档

自动配置的 a 也会回退以下任何 Spring Security 模块在类路径上：UserDetailsServiceSpring中文文档

要除了这些依赖项中的一个或多个之外使用，请定义您自己的 Bean。UserDetailsServiceInMemoryUserDetailsManagerSpring中文文档

可以通过添加自定义 Bean 来覆盖访问规则。 Spring Boot 提供了可用于覆盖执行器端点和静态资源的访问规则的便捷方法。 可用于创建基于该属性的 A。 可用于在常用位置创建 for 资源。SecurityFilterChainEndpointRequestRequestMatchermanagement.endpoints.web.base-pathPathRequestRequestMatcherSpring中文文档

WebFlux 安全

与 Spring MVC 应用程序类似，您可以通过添加依赖项来保护 WebFlux 应用程序。 默认安全配置在 和 中实现。 导入 Web 安全性并配置身份验证，这在非 Web 应用程序中也相关。spring-boot-starter-securityReactiveSecurityAutoConfigurationUserDetailsServiceAutoConfigurationReactiveSecurityAutoConfigurationWebFluxSecurityConfigurationUserDetailsServiceAutoConfigurationSpring中文文档

要完全关闭默认的 Web 应用程序安全性配置，您可以添加 Bean 类型（这样做不会禁用配置或执行器的安全性）。 要同时关闭配置，您可以添加 type 或 的 bean。WebFilterChainProxyUserDetailsServiceUserDetailsServiceReactiveUserDetailsServiceReactiveAuthenticationManagerSpring中文文档

当以下任何Spring Security模块位于类路径上时，自动配置也将回退：Spring中文文档

要除了这些依赖项中的一个或多个之外使用，请定义您自己的 Bean。ReactiveUserDetailsServiceMapReactiveUserDetailsServiceSpring中文文档

可以通过添加自定义 Bean 来配置访问规则和多个 Spring Security 组件（如 OAuth 2 客户端和资源服务器）的使用。 Spring Boot 提供了可用于覆盖执行器端点和静态资源的访问规则的便捷方法。 可用于创建基于该属性的 A。SecurityWebFilterChainEndpointRequestServerWebExchangeMatchermanagement.endpoints.web.base-pathSpring中文文档

PathRequest可用于在常用位置创建 for 资源。ServerWebExchangeMatcherSpring中文文档

例如，您可以通过添加如下内容来自定义安全配置：Spring中文文档

import org.springframework.boot.autoconfigure.security.reactive.PathRequest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.web.server.ServerHttpSecurity;
import org.springframework.security.web.server.SecurityWebFilterChain;

import static org.springframework.security.config.Customizer.withDefaults;

@Configuration(proxyBeanMethods = false)
public class MyWebFluxSecurityConfiguration {

	@Bean
	public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
		http.authorizeExchange((exchange) -> {
			exchange.matchers(PathRequest.toStaticResources().atCommonLocations()).permitAll();
			exchange.pathMatchers("/foo", "/bar").authenticated();
		});
		http.formLogin(withDefaults());
		return http.build();
	}

}
import org.springframework.boot.autoconfigure.security.reactive.PathRequest
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.security.config.Customizer.withDefaults
import org.springframework.security.config.web.server.ServerHttpSecurity
import org.springframework.security.web.server.SecurityWebFilterChain

@Configuration(proxyBeanMethods = false)
class MyWebFluxSecurityConfiguration {

	@Bean
	fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
		http.authorizeExchange { spec ->
			spec.matchers(PathRequest.toStaticResources().atCommonLocations()).permitAll()
			spec.pathMatchers("/foo", "/bar").authenticated()
		}
		http.formLogin(withDefaults())
		return http.build()
	}

}

OAuth2

OAuth2 是一个广泛使用的授权框架，由 Spring 支持。Spring中文文档

客户

如果您的类路径上有，则可以利用一些自动配置来设置 OAuth2/Open ID Connect 客户端。 此配置利用 下的属性。 相同的属性适用于 servlet 和反应式应用程序。spring-security-oauth2-clientOAuth2ClientPropertiesSpring中文文档

您可以在前缀下注册多个 OAuth2 客户端和提供程序，如以下示例所示：spring.security.oauth2.clientSpring中文文档

spring.security.oauth2.client.registration.my-login-client.client-id=abcd
spring.security.oauth2.client.registration.my-login-client.client-secret=password
spring.security.oauth2.client.registration.my-login-client.client-name=Client for OpenID Connect
spring.security.oauth2.client.registration.my-login-client.provider=my-oauth-provider
spring.security.oauth2.client.registration.my-login-client.scope=openid,profile,email,phone,address
spring.security.oauth2.client.registration.my-login-client.redirect-uri={baseUrl}/login/oauth2/code/{registrationId}
spring.security.oauth2.client.registration.my-login-client.client-authentication-method=client_secret_basic
spring.security.oauth2.client.registration.my-login-client.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.my-client-1.client-id=abcd
spring.security.oauth2.client.registration.my-client-1.client-secret=password
spring.security.oauth2.client.registration.my-client-1.client-name=Client for user scope
spring.security.oauth2.client.registration.my-client-1.provider=my-oauth-provider
spring.security.oauth2.client.registration.my-client-1.scope=user
spring.security.oauth2.client.registration.my-client-1.redirect-uri={baseUrl}/authorized/user
spring.security.oauth2.client.registration.my-client-1.client-authentication-method=client_secret_basic
spring.security.oauth2.client.registration.my-client-1.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.my-client-2.client-id=abcd
spring.security.oauth2.client.registration.my-client-2.client-secret=password
spring.security.oauth2.client.registration.my-client-2.client-name=Client for email scope
spring.security.oauth2.client.registration.my-client-2.provider=my-oauth-provider
spring.security.oauth2.client.registration.my-client-2.scope=email
spring.security.oauth2.client.registration.my-client-2.redirect-uri={baseUrl}/authorized/email
spring.security.oauth2.client.registration.my-client-2.client-authentication-method=client_secret_basic
spring.security.oauth2.client.registration.my-client-2.authorization-grant-type=authorization_code
spring.security.oauth2.client.provider.my-oauth-provider.authorization-uri=https://my-auth-server.com/oauth2/authorize
spring.security.oauth2.client.provider.my-oauth-provider.token-uri=https://my-auth-server.com/oauth2/token
spring.security.oauth2.client.provider.my-oauth-provider.user-info-uri=https://my-auth-server.com/userinfo
spring.security.oauth2.client.provider.my-oauth-provider.user-info-authentication-method=header
spring.security.oauth2.client.provider.my-oauth-provider.jwk-set-uri=https://my-auth-server.com/oauth2/jwks
spring.security.oauth2.client.provider.my-oauth-provider.user-name-attribute=name
spring:
  security:
    oauth2:
      client:
        registration:
          my-login-client:
            client-id: "abcd"
            client-secret: "password"
            client-name: "Client for OpenID Connect"
            provider: "my-oauth-provider"
            scope: "openid,profile,email,phone,address"
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
            client-authentication-method: "client_secret_basic"
            authorization-grant-type: "authorization_code"

          my-client-1:
            client-id: "abcd"
            client-secret: "password"
            client-name: "Client for user scope"
            provider: "my-oauth-provider"
            scope: "user"
            redirect-uri: "{baseUrl}/authorized/user"
            client-authentication-method: "client_secret_basic"
            authorization-grant-type: "authorization_code"

          my-client-2:
            client-id: "abcd"
            client-secret: "password"
            client-name: "Client for email scope"
            provider: "my-oauth-provider"
            scope: "email"
            redirect-uri: "{baseUrl}/authorized/email"
            client-authentication-method: "client_secret_basic"
            authorization-grant-type: "authorization_code"

        provider:
          my-oauth-provider:
            authorization-uri: "https://my-auth-server.com/oauth2/authorize"
            token-uri: "https://my-auth-server.com/oauth2/token"
            user-info-uri: "https://my-auth-server.com/userinfo"
            user-info-authentication-method: "header"
            jwk-set-uri: "https://my-auth-server.com/oauth2/jwks"
            user-name-attribute: "name"

对于支持 OpenID Connect 发现的 OpenID Connect 提供程序，可以进一步简化配置。 提供程序需要配置一个 URI，它断言为颁发者标识符。 例如，如果提供的是“https://example.com”，则将向“https://example.com/.well-known/openid-configuration”发出“OpenID 提供程序配置请求”。 结果应为“OpenID 提供程序配置响应”。 以下示例演示如何使用 OpenID Connect Provider 配置：issuer-uriissuer-uriissuer-uriSpring中文文档

spring.security.oauth2.client.provider.oidc-provider.issuer-uri=https://dev-123456.oktapreview.com/oauth2/default/
spring:
  security:
    oauth2:
      client:
        provider:
          oidc-provider:
            issuer-uri: "https://dev-123456.oktapreview.com/oauth2/default/"

默认情况下，Spring Security 只处理匹配的 URL。 如果要自定义以使用不同的模式，则需要提供处理该自定义模式的配置。 例如，对于 servlet 应用程序，您可以添加类似于以下内容的自己的应用程序：OAuth2LoginAuthenticationFilter/login/oauth2/code/*redirect-uriSecurityFilterChainSpring中文文档

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.web.SecurityFilterChain;

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
public class MyOAuthClientConfiguration {

	@Bean
	public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
		http
			.authorizeHttpRequests((requests) -> requests
				.anyRequest().authenticated()
			)
			.oauth2Login((login) -> login
				.redirectionEndpoint((endpoint) -> endpoint
					.baseUri("/login/oauth2/callback/*")
				)
			);
		return http.build();
	}

}
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.invoke
import org.springframework.security.web.SecurityFilterChain

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
open class MyOAuthClientConfiguration {

	@Bean
	open fun securityFilterChain(http: HttpSecurity): SecurityFilterChain {
		http {
			authorizeHttpRequests {
				authorize(anyRequest, authenticated)
			}
			oauth2Login {
				redirectionEndpoint {
					baseUri = "/login/oauth2/callback/*"
				}
			}
		}
		return http.build()
	}

}
Spring Boot 自动配置 Spring Security 用于管理客户端注册的 Only。 它的功能有限，我们建议仅将其用于开发环境。 对于生产环境，请考虑使用或创建自己的 实现。InMemoryOAuth2AuthorizedClientServiceInMemoryOAuth2AuthorizedClientServiceJdbcOAuth2AuthorizedClientServiceOAuth2AuthorizedClientService

通用提供程序的 OAuth2 客户端注册

对于常见的 OAuth2 和 OpenID 提供商，包括 Google、Github、Facebook 和 Okta，我们提供了一组默认提供商（分别为 、 、 和 ）。googlegithubfacebookoktaSpring中文文档

如果不需要自定义这些提供程序，则可以将属性设置为需要推断其默认值的属性。 此外，如果客户端注册的密钥与默认支持的提供程序匹配，则 Spring Boot 也会推断出这一点。providerSpring中文文档

换句话说，以下示例中的两个配置使用 Google 提供程序：Spring中文文档

spring.security.oauth2.client.registration.my-client.client-id=abcd
spring.security.oauth2.client.registration.my-client.client-secret=password
spring.security.oauth2.client.registration.my-client.provider=google
spring.security.oauth2.client.registration.google.client-id=abcd
spring.security.oauth2.client.registration.google.client-secret=password
spring:
  security:
    oauth2:
      client:
        registration:
          my-client:
            client-id: "abcd"
            client-secret: "password"
            provider: "google"
          google:
            client-id: "abcd"
            client-secret: "password"

资源服务器

如果你的类路径上有，Spring Boot 可以设置 OAuth2 资源服务器。 对于 JWT 配置，需要指定 JWK Set URI 或 OIDC Issuer URI，如以下示例所示：spring-security-oauth2-resource-serverSpring中文文档

spring.security.oauth2.resourceserver.jwt.jwk-set-uri=https://example.com/oauth2/default/v1/keys
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          jwk-set-uri: "https://example.com/oauth2/default/v1/keys"
spring.security.oauth2.resourceserver.jwt.issuer-uri=https://dev-123456.oktapreview.com/oauth2/default/
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: "https://dev-123456.oktapreview.com/oauth2/default/"
如果授权服务器不支持 JWK 集 URI，则可以使用用于验证 JWT 签名的公钥配置资源服务器。 这可以使用属性来完成，其中值需要指向包含 PEM 编码的 x509 格式的公钥的文件。spring.security.oauth2.resourceserver.jwt.public-key-location

该属性可用于指定 JWT 中 aud 声明的预期值。 例如，要求 JWT 包含值为 ：spring.security.oauth2.resourceserver.jwt.audiencesmy-audienceSpring中文文档

spring.security.oauth2.resourceserver.jwt.audiences[0]=my-audience
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          audiences:
            - "my-audience"

相同的属性适用于 servlet 和反应式应用程序。 或者，您可以为 servlet 应用程序定义自己的 bean，或者为反应式应用程序定义自己的 bean。JwtDecoderReactiveJwtDecoderSpring中文文档

如果使用不透明令牌而不是 JWT，则可以配置以下属性以通过自检来验证令牌：Spring中文文档

spring.security.oauth2.resourceserver.opaquetoken.introspection-uri=https://example.com/check-token
spring.security.oauth2.resourceserver.opaquetoken.client-id=my-client-id
spring.security.oauth2.resourceserver.opaquetoken.client-secret=my-client-secret
spring:
  security:
    oauth2:
      resourceserver:
        opaquetoken:
          introspection-uri: "https://example.com/check-token"
          client-id: "my-client-id"
          client-secret: "my-client-secret"

同样，相同的属性也适用于 servlet 和反应式应用程序。 或者，您可以为 servlet 应用程序定义自己的 bean，或者为反应式应用程序定义自己的 bean。OpaqueTokenIntrospectorReactiveOpaqueTokenIntrospectorSpring中文文档

授权服务器

如果您的类路径上有，则可以利用一些自动配置来设置基于 Servlet 的 OAuth2 授权服务器。spring-security-oauth2-authorization-serverSpring中文文档

您可以在前缀下注册多个 OAuth2 客户端，如以下示例所示：spring.security.oauth2.authorizationserver.clientSpring中文文档

spring.security.oauth2.authorizationserver.client.my-client-1.registration.client-id=abcd
spring.security.oauth2.authorizationserver.client.my-client-1.registration.client-secret={noop}secret1
spring.security.oauth2.authorizationserver.client.my-client-1.registration.client-authentication-methods[0]=client_secret_basic
spring.security.oauth2.authorizationserver.client.my-client-1.registration.authorization-grant-types[0]=authorization_code
spring.security.oauth2.authorizationserver.client.my-client-1.registration.authorization-grant-types[1]=refresh_token
spring.security.oauth2.authorizationserver.client.my-client-1.registration.redirect-uris[0]=https://my-client-1.com/login/oauth2/code/abcd
spring.security.oauth2.authorizationserver.client.my-client-1.registration.redirect-uris[1]=https://my-client-1.com/authorized
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[0]=openid
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[1]=profile
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[2]=email
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[3]=phone
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[4]=address
spring.security.oauth2.authorizationserver.client.my-client-1.require-authorization-consent=true
spring.security.oauth2.authorizationserver.client.my-client-2.registration.client-id=efgh
spring.security.oauth2.authorizationserver.client.my-client-2.registration.client-secret={noop}secret2
spring.security.oauth2.authorizationserver.client.my-client-2.registration.client-authentication-methods[0]=client_secret_jwt
spring.security.oauth2.authorizationserver.client.my-client-2.registration.authorization-grant-types[0]=client_credentials
spring.security.oauth2.authorizationserver.client.my-client-2.registration.scopes[0]=user.read
spring.security.oauth2.authorizationserver.client.my-client-2.registration.scopes[1]=user.write
spring.security.oauth2.authorizationserver.client.my-client-2.jwk-set-uri=https://my-client-2.com/jwks
spring.security.oauth2.authorizationserver.client.my-client-2.token-endpoint-authentication-signing-algorithm=RS256
spring:
  security:
    oauth2:
      authorizationserver:
        client:
          my-client-1:
            registration:
              client-id: "abcd"
              client-secret: "{noop}secret1"
              client-authentication-methods:
                - "client_secret_basic"
              authorization-grant-types:
                - "authorization_code"
                - "refresh_token"
              redirect-uris:
                - "https://my-client-1.com/login/oauth2/code/abcd"
                - "https://my-client-1.com/authorized"
              scopes:
                - "openid"
                - "profile"
                - "email"
                - "phone"
                - "address"
            require-authorization-consent: true
          my-client-2:
            registration:
              client-id: "efgh"
              client-secret: "{noop}secret2"
              client-authentication-methods:
                - "client_secret_jwt"
              authorization-grant-types:
                - "client_credentials"
              scopes:
                - "user.read"
                - "user.write"
            jwk-set-uri: "https://my-client-2.com/jwks"
            token-endpoint-authentication-signing-algorithm: "RS256"
该属性的格式必须与配置的 . 的默认实例是通过 创建的。client-secretPasswordEncoderPasswordEncoderPasswordEncoderFactories.createDelegatingPasswordEncoder()

Spring Boot 为 Spring Authorization Server 提供的自动配置旨在快速入门。 大多数应用程序都需要定制，并且需要定义多个 Bean 来覆盖自动配置。Spring中文文档

可以将以下组件定义为 bean，以覆盖特定于 Spring Authorization Server 的自动配置：Spring中文文档

Spring Boot 自动配置 Spring Authorization Server 用于管理已注册客户端的 Authorization Server。 它的功能有限，我们建议仅将其用于开发环境。 对于生产环境，请考虑使用或创建自己的 实现。InMemoryRegisteredClientRepositoryInMemoryRegisteredClientRepositoryJdbcRegisteredClientRepositoryRegisteredClientRepository

其他信息可以在 Spring Authorization Server 参考指南的“入门”一章中找到。Spring中文文档

Spring Boot 自动配置 Spring Security 用于管理客户端注册的 Only。 它的功能有限，我们建议仅将其用于开发环境。 对于生产环境，请考虑使用或创建自己的 实现。InMemoryOAuth2AuthorizedClientServiceInMemoryOAuth2AuthorizedClientServiceJdbcOAuth2AuthorizedClientServiceOAuth2AuthorizedClientService
如果授权服务器不支持 JWK 集 URI，则可以使用用于验证 JWT 签名的公钥配置资源服务器。 这可以使用属性来完成，其中值需要指向包含 PEM 编码的 x509 格式的公钥的文件。spring.security.oauth2.resourceserver.jwt.public-key-location
该属性的格式必须与配置的 . 的默认实例是通过 创建的。client-secretPasswordEncoderPasswordEncoderPasswordEncoderFactories.createDelegatingPasswordEncoder()
Spring Boot 自动配置 Spring Authorization Server 用于管理已注册客户端的 Authorization Server。 它的功能有限，我们建议仅将其用于开发环境。 对于生产环境，请考虑使用或创建自己的 实现。InMemoryRegisteredClientRepositoryInMemoryRegisteredClientRepositoryJdbcRegisteredClientRepositoryRegisteredClientRepository

SAML 2.0

信赖方

如果您的类路径上有，则可以利用一些自动配置来设置 SAML 2.0 信赖方。 此配置利用 下的属性。spring-security-saml2-service-providerSaml2RelyingPartyPropertiesSpring中文文档

信赖方注册表示身份提供程序 IDP 和服务提供商 SP 之间的配对配置。 可以在前缀下注册多个信赖方，如以下示例所示：spring.security.saml2.relyingpartySpring中文文档

spring.security.saml2.relyingparty.registration.my-relying-party1.signing.credentials[0].private-key-location=path-to-private-key
spring.security.saml2.relyingparty.registration.my-relying-party1.signing.credentials[0].certificate-location=path-to-certificate
spring.security.saml2.relyingparty.registration.my-relying-party1.decryption.credentials[0].private-key-location=path-to-private-key
spring.security.saml2.relyingparty.registration.my-relying-party1.decryption.credentials[0].certificate-location=path-to-certificate
spring.security.saml2.relyingparty.registration.my-relying-party1.singlelogout.url=https://myapp/logout/saml2/slo
spring.security.saml2.relyingparty.registration.my-relying-party1.singlelogout.response-url=https://remoteidp2.slo.url
spring.security.saml2.relyingparty.registration.my-relying-party1.singlelogout.binding=POST
spring.security.saml2.relyingparty.registration.my-relying-party1.assertingparty.verification.credentials[0].certificate-location=path-to-verification-cert
spring.security.saml2.relyingparty.registration.my-relying-party1.assertingparty.entity-id=remote-idp-entity-id1
spring.security.saml2.relyingparty.registration.my-relying-party1.assertingparty.sso-url=https://remoteidp1.sso.url
spring.security.saml2.relyingparty.registration.my-relying-party2.signing.credentials[0].private-key-location=path-to-private-key
spring.security.saml2.relyingparty.registration.my-relying-party2.signing.credentials[0].certificate-location=path-to-certificate
spring.security.saml2.relyingparty.registration.my-relying-party2.decryption.credentials[0].private-key-location=path-to-private-key
spring.security.saml2.relyingparty.registration.my-relying-party2.decryption.credentials[0].certificate-location=path-to-certificate
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.verification.credentials[0].certificate-location=path-to-other-verification-cert
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.entity-id=remote-idp-entity-id2
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.sso-url=https://remoteidp2.sso.url
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.singlelogout.url=https://remoteidp2.slo.url
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.singlelogout.response-url=https://myapp/logout/saml2/slo
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.singlelogout.binding=POST
spring:
  security:
    saml2:
      relyingparty:
        registration:
          my-relying-party1:
            signing:
              credentials:
              - private-key-location: "path-to-private-key"
                certificate-location: "path-to-certificate"
            decryption:
              credentials:
              - private-key-location: "path-to-private-key"
                certificate-location: "path-to-certificate"
            singlelogout:
               url: "https://myapp/logout/saml2/slo"
               response-url: "https://remoteidp2.slo.url"
               binding: "POST"
            assertingparty:
              verification:
                credentials:
                - certificate-location: "path-to-verification-cert"
              entity-id: "remote-idp-entity-id1"
              sso-url: "https://remoteidp1.sso.url"

          my-relying-party2:
            signing:
              credentials:
              - private-key-location: "path-to-private-key"
                certificate-location: "path-to-certificate"
            decryption:
              credentials:
              - private-key-location: "path-to-private-key"
                certificate-location: "path-to-certificate"
            assertingparty:
              verification:
                credentials:
                - certificate-location: "path-to-other-verification-cert"
              entity-id: "remote-idp-entity-id2"
              sso-url: "https://remoteidp2.sso.url"
              singlelogout:
                url: "https://remoteidp2.slo.url"
                response-url: "https://myapp/logout/saml2/slo"
                binding: "POST"

对于 SAML2 注销，默认情况下，Spring Security 的且仅进程 URL 匹配 。 如果要自定义 AP 发起的注销请求发送到的对象或 AP 向其发送注销响应的对象，要使用不同的模式，则需要提供处理该自定义模式的配置。 例如，对于 servlet 应用程序，您可以添加类似于以下内容的自己的应用程序：Saml2LogoutRequestFilterSaml2LogoutResponseFilter/logout/saml2/slourlresponse-urlSecurityFilterChainSpring中文文档

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.web.SecurityFilterChain;

import static org.springframework.security.config.Customizer.withDefaults;

@Configuration(proxyBeanMethods = false)
public class MySamlRelyingPartyConfiguration {

	@Bean
	public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
		http.authorizeHttpRequests((requests) -> requests.anyRequest().authenticated());
		http.saml2Login(withDefaults());
		http.saml2Logout((saml2) -> saml2.logoutRequest((request) -> request.logoutUrl("/SLOService.saml2"))
			.logoutResponse((response) -> response.logoutUrl("/SLOService.saml2")));
		return http.build();
	}

}