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

Java 配置

在 Spring 3.1 中，Spring Framework 添加了对 Java 配置的一般支持。Spring Security 3.2 引入了 Java 配置，让用户无需使用任何 XML 即可配置 Spring Security。spring-doc.cadn.net.cn

如果您熟悉安全命名空间配置，您应该会发现它与 Spring Security Java 配置之间有很多相似之处。spring-doc.cadn.net.cn

Spring Security 提供了许多示例应用程序来演示 Spring Security Java 配置的使用。spring-doc.cadn.net.cn

Hello Web Security Java 配置

第一步是创建我们的 Spring Security Java 配置。该配置创建了一个称为springSecurityFilterChain，它负责应用程序中的所有安全性（保护应用程序URL，验证提交的用户名和密码，重定向到登录表单等）。以下示例显示了Spring Security Java配置的最基本示例：spring-doc.cadn.net.cn

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.*;
import org.springframework.security.config.annotation.authentication.builders.*;
import org.springframework.security.config.annotation.web.configuration.*;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig {

	@Bean
	public UserDetailsService userDetailsService() {
		InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
		manager.createUser(User.withDefaultPasswordEncoder().username("user").password("password").roles("USER").build());
		return manager;
	}
}

这种配置并不复杂或广泛，但它做了很多：spring-doc.cadn.net.cn

抽象SecurityWebApplication初始化器

下一步是注册springSecurityFilterChain替换为 WAR 文件。 您可以在 Java 配置中使用Spring的WebApplicationInitializer支持在 Servlet 3.0+ 环境中。 毫不奇怪，Spring Security 提供了一个基类（AbstractSecurityWebApplicationInitializer） 以确保springSecurityFilterChain为您注册。 我们使用AbstractSecurityWebApplicationInitializer取决于我们是否已经在使用 Spring，或者 Spring Security 是否是我们应用程序中唯一的 Spring 组件。spring-doc.cadn.net.cn

AbstractSecurityWebApplicationInitializer 没有现有 Spring

如果您没有使用 Spring 或 Spring MVC，则需要将WebSecurityConfig到超类以确保选择配置：spring-doc.cadn.net.cn

import org.springframework.security.web.context.*;

public class SecurityWebApplicationInitializer
	extends AbstractSecurityWebApplicationInitializer {

	public SecurityWebApplicationInitializer() {
		super(WebSecurityConfig.class);
	}
}

这SecurityWebApplicationInitializer:spring-doc.cadn.net.cn

AbstractSecurityWebApplicationInitializer 与 Spring MVC

如果我们在应用程序的其他地方使用 Spring，我们可能已经有一个WebApplicationInitializer那就是加载我们的 Spring 配置。 如果我们使用前面的配置，我们会得到一个错误。 相反，我们应该使用现有的ApplicationContext. 例如，如果我们使用 Spring MVC，则我们的SecurityWebApplicationInitializer可能如下所示：spring-doc.cadn.net.cn

import org.springframework.security.web.context.*;

public class SecurityWebApplicationInitializer
	extends AbstractSecurityWebApplicationInitializer {

}

这仅注册springSecurityFilterChain应用程序中的每个 URL。 之后，我们需要确保WebSecurityConfig加载在我们现有的ApplicationInitializer. 例如，如果我们使用 Spring MVC，它会添加到getServletConfigClasses():spring-doc.cadn.net.cn

public class MvcWebApplicationInitializer extends
		AbstractAnnotationConfigDispatcherServletInitializer {

	@Override
	protected Class<?>[] getServletConfigClasses() {
		return new Class[] { WebSecurityConfig.class, WebMvcConfig.class };
	}

	// ... other overrides ...
}

这样做的原因是 Spring Security 需要能够检查一些 Spring MVC 配置，以便适当地配置底层请求匹配器，因此它们需要位于相同的应用程序上下文中。 将 Spring Security 置于getRootConfigClasses将其放入可能无法找到 Spring MVC 的PathPatternParser.spring-doc.cadn.net.cn

为多个 Spring MVC 调度程序配置

如果需要，可以将任何与 Spring MVC 无关的 Spring Security 配置放置在不同的配置类中，如下所示：spring-doc.cadn.net.cn

public class MvcWebApplicationInitializer extends
		AbstractAnnotationConfigDispatcherServletInitializer {

	@Override
    protected Class<?>[] getRootConfigClasses() {
		return new Class[] { NonWebSecurityConfig.class };
    }

	@Override
	protected Class<?>[] getServletConfigClasses() {
		return new Class[] { WebSecurityConfig.class, WebMvcConfig.class };
	}

	// ... other overrides ...
}

如果您有多个AbstractAnnotationConfigDispatcherServletInitializer并且不想在它们之间重复常规安全配置。spring-doc.cadn.net.cn

Http安全

到目前为止，我们的WebSecurityConfig仅包含有关如何对用户进行身份验证的信息。 Spring Security 如何知道我们要要求所有用户都经过身份验证？ Spring Security 如何知道我们想要支持基于表单的身份验证？ 实际上，有一个配置类（称为SecurityFilterChain）在幕后被调用。 它配置了以下默认实现：spring-doc.cadn.net.cn

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
	http
		.authorizeHttpRequests((authorize) -> authorize
			.anyRequest().authenticated()
		)
		.formLogin(Customizer.withDefaults())
		.httpBasic(Customizer.withDefaults());
	return http.build();
}

默认配置（如前面的示例所示）：spring-doc.cadn.net.cn

请注意，此配置与 XML 命名空间配置平行：spring-doc.cadn.net.cn

<http>
	<intercept-url pattern="/**" access="authenticated"/>
	<form-login />
	<http-basic />
</http>

多个 HttpSecurity 实例

为了在某些区域需要不同保护的应用程序中有效管理安全性，我们可以在securityMatcherDSL 方法。 这种方法使我们能够定义针对应用程序特定部分量身定制的不同安全配置，从而增强整体应用程序的安全性和控制力。spring-doc.cadn.net.cn

我们可以配置多个HttpSecurity实例，就像我们可以有多个<http>块。 关键是要注册多个SecurityFilterChain @Beans. 以下示例对以/api/:spring-doc.cadn.net.cn

@Configuration
@EnableWebSecurity
public class MultiHttpSecurityConfig {
	@Bean                                                             (1)
	public UserDetailsService userDetailsService() throws Exception {
		UserBuilder users = User.withDefaultPasswordEncoder();
		InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
		manager.createUser(users.username("user").password("password").roles("USER").build());
		manager.createUser(users.username("admin").password("password").roles("USER","ADMIN").build());
		return manager;
	}

	@Bean
	@Order(1)                                                        (2)
	public SecurityFilterChain apiFilterChain(HttpSecurity http) throws Exception {
		http
			.securityMatcher("/api/**")                              (3)
			.authorizeHttpRequests((authorize) -> authorize
				.anyRequest().hasRole("ADMIN")
			)
			.httpBasic(Customizer.withDefaults());
		return http.build();
	}

	@Bean                                                            (4)
	public SecurityFilterChain formLoginFilterChain(HttpSecurity http) throws Exception {
		http
			.authorizeHttpRequests((authorize) -> authorize
				.anyRequest().authenticated()
			)
			.formLogin(Customizer.withDefaults());
		return http.build();
	}
}
1 像往常一样配置身份验证。
2 创建SecurityFilterChain包含@Order指定哪个SecurityFilterChain应该首先考虑。
3 这http.securityMatcher()声明该HttpSecurity仅适用于以/api/.
4 创建另一个SecurityFilterChain. 如果 URL 不是以/api/，则使用此配置。 此配置在apiFilterChain，因为它有一个@Order值1（否@Order默认为 last）。

选择securityMatcher或requestMatchers

一个常见的问题是：spring-doc.cadn.net.cn

有什么区别http.securityMatcher()method 和requestMatchers()用于请求授权（即在http.authorizeHttpRequests())?spring-doc.cadn.net.cn

要回答这个问题，了解每个HttpSecurity实例用于构建SecurityFilterChain包含一个RequestMatcher以匹配传入的请求。 如果请求与SecurityFilterChain具有更高优先级（例如@Order(1)），可以针对优先级较低的过滤器链（例如 no@Order).spring-doc.cadn.net.cn

多个过滤器链的匹配逻辑由FilterChainProxy.spring-doc.cadn.net.cn

默认值RequestMatcher匹配任何请求，以确保 Spring Security 默认保护所有请求。spring-doc.cadn.net.cn

指定securityMatcher覆盖此默认值。spring-doc.cadn.net.cn

如果没有过滤器链与特定请求匹配，则该请求不受 Spring Security 保护。spring-doc.cadn.net.cn

以下示例演示了一个仅保护以/secured/:spring-doc.cadn.net.cn

@Configuration
@EnableWebSecurity
public class PartialSecurityConfig {

	@Bean
	public UserDetailsService userDetailsService() throws Exception {
		// ...
	}

	@Bean
	public SecurityFilterChain securedFilterChain(HttpSecurity http) throws Exception {
		http
			.securityMatcher("/secured/**")                            (1)
			.authorizeHttpRequests((authorize) -> authorize
				.requestMatchers("/secured/user").hasRole("USER")      (2)
				.requestMatchers("/secured/admin").hasRole("ADMIN")    (3)
				.anyRequest().authenticated()                          (4)
			)
			.httpBasic(Customizer.withDefaults())
			.formLogin(Customizer.withDefaults());
		return http.build();
	}
}
1 以/secured/将受到保护，但任何其他请求都不受保护。
2 请求/secured/user需要ROLE_USER柄。
3 请求/secured/admin需要ROLE_ADMIN柄。
4 任何其他请求（例如/secured/other） 只需要经过身份验证的用户。

建议提供SecurityFilterChain没有指定任何securityMatcher以确保整个应用程序受到保护，如前面的示例所示。spring-doc.cadn.net.cn

请注意，requestMatchers方法仅适用于单个授权规则。 其中列出的每个请求也必须与总体请求匹配securityMatcher对于这个特定的HttpSecurity实例，用于创建SecurityFilterChain. 用anyRequest()在此示例中，匹配此特定请求中的所有其他请求SecurityFilterChain（必须以/secured/).spring-doc.cadn.net.cn

有关更多信息，请参阅授权 HttpServletRequestsrequestMatchers.spring-doc.cadn.net.cn

SecurityFilterChain端点

中的多个过滤器SecurityFilterChain直接提供端点，例如UsernamePasswordAuthenticationFilter由http.formLogin()并提供POST /login端点。 在上面的示例中，/loginendpoint 不匹配http.securityMatcher("/secured/**")因此，该应用程序不会有任何GET /login或POST /login端点。 此类请求将返回404 Not Found. 这常常让用户感到惊讶。spring-doc.cadn.net.cn

指定http.securityMatcher()影响与该请求匹配的请求SecurityFilterChain. 但是，它不会自动影响过滤器链提供的端点。 在这种情况下，您可能需要自定义希望筛选器链提供的任何终结点的 URL。spring-doc.cadn.net.cn

以下示例演示了一种配置，用于保护以/secured/并拒绝所有其他请求，同时还自定义SecurityFilterChain:spring-doc.cadn.net.cn

@Configuration
@EnableWebSecurity
public class SecuredSecurityConfig {

	@Bean
	public UserDetailsService userDetailsService() throws Exception {
		// ...
	}

	@Bean
	@Order(1)
	public SecurityFilterChain securedFilterChain(HttpSecurity http) throws Exception {
		http
			.securityMatcher("/secured/**")                            (1)
			.authorizeHttpRequests((authorize) -> authorize
				.anyRequest().authenticated()                          (2)
			)
			.formLogin((formLogin) -> formLogin                          (3)
				.loginPage("/secured/login")
				.loginProcessingUrl("/secured/login")
				.permitAll()
			)
			.logout((logout) -> logout                                   (4)
				.logoutUrl("/secured/logout")
				.logoutSuccessUrl("/secured/login?logout")
				.permitAll()
			)
			.formLogin(Customizer.withDefaults());
		return http.build();
	}

	@Bean
	public SecurityFilterChain defaultFilterChain(HttpSecurity http) throws Exception {
		http
			.authorizeHttpRequests((authorize) -> authorize
				.anyRequest().denyAll()                                (5)
			);
		return http.build();
	}
}
1 以/secured/将受到此过滤链的保护。
2 以/secured/需要经过身份验证的用户。
3 自定义表单登录以在 URL 前加上/secured/.
4 自定义注销以在 URL 前加上/secured/.
5 所有其他请求都将被拒绝。

此示例自定义登录和注销页面，这禁用了 Spring Security 生成的页面。 必须为GET /secured/login和GET /secured/logout. 请注意，Spring Security 仍然提供POST /secured/login和POST /secured/logout端点。spring-doc.cadn.net.cn

真实世界示例

以下示例演示了将所有这些元素放在一起的更真实的配置：spring-doc.cadn.net.cn

@Configuration
@EnableWebSecurity
public class BankingSecurityConfig {

    @Bean                                                              (1)
    public UserDetailsService userDetailsService() {
		UserBuilder users = User.withDefaultPasswordEncoder();
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(users.username("user1").password("password").roles("USER", "VIEW_BALANCE").build());
        manager.createUser(users.username("user2").password("password").roles("USER").build());
        manager.createUser(users.username("admin").password("password").roles("ADMIN").build());
        return manager;
    }

    @Bean
    @Order(1)                                                          (2)
    public SecurityFilterChain approvalsSecurityFilterChain(HttpSecurity http) throws Exception {
        String[] approvalsPaths = { "/accounts/approvals/**", "/loans/approvals/**", "/credit-cards/approvals/**" };
        http
            .securityMatcher(approvalsPaths)
            .authorizeHttpRequests((authorize) -> authorize
				.anyRequest().hasRole("ADMIN")
            )
            .httpBasic(Customizer.withDefaults());
        return http.build();
    }

    @Bean
    @Order(2)                                                          (3)
    public SecurityFilterChain bankingSecurityFilterChain(HttpSecurity http) throws Exception {
        String[] bankingPaths = { "/accounts/**", "/loans/**", "/credit-cards/**", "/balances/**" };
		String[] viewBalancePaths = { "/balances/**" };
        http
			.securityMatcher(bankingPaths)
			.authorizeHttpRequests((authorize) -> authorize
				.requestMatchers(viewBalancePaths).hasRole("VIEW_BALANCE")
				.anyRequest().hasRole("USER")
            );
        return http.build();
    }

    @Bean                                                              (4)
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
		String[] allowedPaths = { "/", "/user-login", "/user-logout", "/notices", "/contact", "/register" };
        http
            .authorizeHttpRequests((authorize) -> authorize
				.requestMatchers(allowedPaths).permitAll()
				.anyRequest().authenticated()
            )
			.formLogin((formLogin) -> formLogin
				.loginPage("/user-login")
				.loginProcessingUrl("/user-login")
			)
			.logout((logout) -> logout
				.logoutUrl("/user-logout")
				.logoutSuccessUrl("/?logout")
			);
        return http.build();
    }
}
1 首先配置身份验证设置。
2 定义一个SecurityFilterChain实例与@Order(1)，这意味着此过滤器链将具有最高优先级。 此筛选器链仅适用于以/accounts/approvals/,/loans/approvals/或/credit-cards/approvals/. 对此过滤器链的请求需要ROLE_ADMIN权限并允许 HTTP 基本身份验证。
3 接下来，创建另一个SecurityFilterChain实例与@Order(2)这将被视为第二位。 此筛选器链仅适用于以/accounts/,/loans/,/credit-cards/或/balances/. 请注意，由于此筛选器链是第二个，因此包含/approvals/将匹配上一个过滤器链，并且不会被此过滤器链匹配。 对此过滤器链的请求需要ROLE_USER柄。 此筛选器链不定义任何身份验证，因为下一个（默认）筛选器链包含该配置。
4 最后，创建一个额外的SecurityFilterChain实例，而不使用@Order注解。 此配置将处理其他过滤器链未涵盖的请求，并将最后处理（no@Order默认为 last）。 匹配的请求 ，//user-login,/user-logout,/notices,/contact和/register允许无需身份验证即可访问。 任何其他请求都需要对用户进行身份验证才能访问其他过滤器链未显式允许或保护的任何 URL。

自定义 DSL

您可以在 Spring Security 中提供自己的自定义 DSL：spring-doc.cadn.net.cn

public class MyCustomDsl extends AbstractHttpConfigurer<MyCustomDsl, HttpSecurity> {
	private boolean flag;

	@Override
	public void init(HttpSecurity http) throws Exception {
		// any method that adds another configurer
		// must be done in the init method
		http.csrf().disable();
	}

	@Override
	public void configure(HttpSecurity http) throws Exception {
		ApplicationContext context = http.getSharedObject(ApplicationContext.class);

		// here we lookup from the ApplicationContext. You can also just create a new instance.
		MyFilter myFilter = context.getBean(MyFilter.class);
		myFilter.setFlag(flag);
		http.addFilterBefore(myFilter, UsernamePasswordAuthenticationFilter.class);
	}

	public MyCustomDsl flag(boolean value) {
		this.flag = value;
		return this;
	}

	public static MyCustomDsl customDsl() {
		return new MyCustomDsl();
	}
}
class MyCustomDsl : AbstractHttpConfigurer<MyCustomDsl, HttpSecurity>() {
    var flag: Boolean = false

    override fun init(http: HttpSecurity) {
        // any method that adds another configurer
        // must be done in the init method
        http.csrf().disable()
    }

    override fun configure(http: HttpSecurity) {
        val context: ApplicationContext = http.getSharedObject(ApplicationContext::class.java)

        // here we lookup from the ApplicationContext. You can also just create a new instance.
        val myFilter: MyFilter = context.getBean(MyFilter::class.java)
        myFilter.setFlag(flag)
        http.addFilterBefore(myFilter, UsernamePasswordAuthenticationFilter::class.java)
    }

    companion object {
        @JvmStatic
        fun customDsl(): MyCustomDsl {
            return MyCustomDsl()
        }
    }
}

这实际上就是像HttpSecurity.authorizeHttpRequests()被实施。spring-doc.cadn.net.cn

然后，您可以使用自定义 DSL：spring-doc.cadn.net.cn

@Configuration
@EnableWebSecurity
public class Config {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.with(MyCustomDsl.customDsl(), (dsl) -> dsl
				.flag(true)
			)
			// ...
		return http.build();
	}
}
@Configuration
@EnableWebSecurity
class Config {

    @Bean
    fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http
            .with(MyCustomDsl.customDsl()) {
                flag = true
            }
            // ...

        return http.build()
    }
}

按以下顺序调用代码：spring-doc.cadn.net.cn

如果你愿意，你可以有HttpSecurity加MyCustomDsl默认情况下，使用SpringFactories. 例如，您可以在名为META-INF/spring.factories包含以下内容：spring-doc.cadn.net.cn

元-INF/spring.factories
org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer = sample.MyCustomDsl

您还可以显式禁用默认值：spring-doc.cadn.net.cn

@Configuration
@EnableWebSecurity
public class Config {
	@Bean
	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
		http
			.with(MyCustomDsl.customDsl(), (dsl) -> dsl
				.disable()
			)
			...;
		return http.build();
	}
}
@Configuration
@EnableWebSecurity
class Config {

    @Bean
    fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http
            .with(MyCustomDsl.customDsl()) {
                disable()
            }
            // ...
        return http.build()
    }

}

模块化 HttpSecurity 配置

许多用户更喜欢他们的 Spring Security 配置位于集中位置，并会选择在单个SecurityFilterChain实例。 但是，有时用户可能希望模块化配置。这可以使用以下方法完成：spring-doc.cadn.net.cn

如果您使用的是 Spring Security 的 Kotlin 配置，那么您还可以将*Dsl → Unit模块化 HttpSecurityDsl 配置中概述的 Bean。

Customizer<HttpSecurity> Bean

如果您想模块化安全配置，可以将逻辑放在Customizer<HttpSecurity>豆。 例如，以下配置将确保所有HttpSecurity实例配置为：spring-doc.cadn.net.cn

@Bean
ThrowingCustomizer<HttpSecurity> httpSecurityCustomizer() {
	return (http) -> http
		.headers((headers) -> headers
			.contentSecurityPolicy((csp) -> csp
				(1)
				.policyDirectives("object-src 'none'")
			)
		)
		(2)
		.redirectToHttps(Customizer.withDefaults());
}
@Bean
fun httpSecurityCustomizer(): ThrowingCustomizer<HttpSecurity> {
    return ThrowingCustomizer { http -> http
        .headers { headers -> headers
            .contentSecurityPolicy { csp -> csp
                (1)
                .policyDirectives("object-src 'none'")
            }
        }
        (2)
        .redirectToHttps(Customizer.withDefaults())
    }
}
1 将内容安全策略设置为object-src 'none'
2 将任何请求重定向到 https

顶级 HttpSecurity 定制器 Bean

如果您希望进一步模块化安全配置，Spring Security 将自动应用任何顶级HttpSecurity Customizer豆。spring-doc.cadn.net.cn

顶级HttpSecurity Customizer类型可以概括为Customizer<T>匹配public HttpSecurity.*(Customizer<T>). 这转化为任何Customizer<T>这是公共方法的单个参数HttpSecurity.spring-doc.cadn.net.cn

几个例子可以帮助澄清。 如果Customizer<ContentTypeOptionsConfig>作为 Bean 发布，它不会自动应用，因为它是HeadersConfigurer.contentTypeOptions(Customizer)这不是在HttpSecurity. 但是，如果Customizer<HeadersConfigurer<HttpSecurity>>作为 Bean 发布，它将自动应用，因为它是HttpSecurity.headers(Customizer).spring-doc.cadn.net.cn

例如，以下配置将确保将内容安全策略设置为object-src 'none':spring-doc.cadn.net.cn

@Bean
Customizer<HeadersConfigurer<HttpSecurity>> headersSecurity() {
	return (headers) -> headers
		.contentSecurityPolicy((csp) -> csp
			(1)
			.policyDirectives("object-src 'none'")
		);
}
@Bean
fun headersSecurity(): Customizer<HeadersConfigurer<HttpSecurity>> {
    return Customizer { headers -> headers
        .contentSecurityPolicy { csp -> csp
            (1)
            .policyDirectives("object-src 'none'")
        }
    }
}

定制器豆子订购

首先，每个 Customizer<HttpSecurity> Bean 都使用 ObjectProvider#orderedStream（） 应用。这意味着如果有多个Customizer<HttpSecurity>Bean，可以将@Order注释添加到 Bean 定义中以控制排序。spring-doc.cadn.net.cn

接下来，查找每个顶级 HttpSecurity Customizer Bean 类型，并使用ObjectProvider#orderedStream(). 如果有两个Customizer<HeadersConfigurer<HttpSecurity>>豆子和两个Customizer<HttpsRedirectConfigurer<HttpSecurity>>实例，每个Customizer类型被调用的顺序是未定义的。但是，每个实例的顺序Customizer<HttpsRedirectConfigurer<HttpSecurity>>由ObjectProvider#orderedStream()并且可以使用@Order在 Bean 上定义。spring-doc.cadn.net.cn

最后，HttpSecurityBean 作为 Bean 注入。 都Customizer实例在HttpSecurityBean 创建。这允许覆盖由Customizer豆。spring-doc.cadn.net.cn

您可以在下面找到一个示例来说明排序：spring-doc.cadn.net.cn

@Bean (4)
SecurityFilterChain springSecurity(HttpSecurity http) throws Exception {
	http
		.authorizeHttpRequests((requests) -> requests
			.anyRequest().authenticated()
		);
	return http.build();
}

@Bean
@Order(Ordered.LOWEST_PRECEDENCE) (2)
ThrowingCustomizer<HttpSecurity> userAuthorization() {
	return (http) -> http
		.authorizeHttpRequests((requests) -> requests
			.requestMatchers("/users/**").hasRole("USER")
		);
}

@Bean
@Order(Ordered.HIGHEST_PRECEDENCE) (1)
ThrowingCustomizer<HttpSecurity> adminAuthorization() {
	return (http) -> http
		.authorizeHttpRequests((requests) -> requests
			.requestMatchers("/admins/**").hasRole("ADMIN")
		);
}

(3)

@Bean
Customizer<HeadersConfigurer<HttpSecurity>> contentSecurityPolicy() {
	return (headers) -> headers
		.contentSecurityPolicy((csp) -> csp
			.policyDirectives("object-src 'none'")
		);
}

@Bean
Customizer<HeadersConfigurer<HttpSecurity>> contentTypeOptions() {
	return (headers) -> headers
		.contentTypeOptions(Customizer.withDefaults());
}

@Bean
Customizer<HttpsRedirectConfigurer<HttpSecurity>> httpsRedirect() {
	return Customizer.withDefaults();
}
@Bean (4)
fun springSecurity(http: HttpSecurity): SecurityFilterChain {
    http
        .authorizeHttpRequests({ requests -> requests
            .anyRequest().authenticated()
        })
    return http.build()
}

@Bean
@Order(Ordered.LOWEST_PRECEDENCE)  (2)
fun userAuthorization(): ThrowingCustomizer<HttpSecurity> {
    return ThrowingCustomizer { http -> http
        .authorizeHttpRequests { requests -> requests
            .requestMatchers("/users/**").hasRole("USER")
        }
    }
}

@Bean
@Order(Ordered.HIGHEST_PRECEDENCE) (1)
fun adminAuthorization(): ThrowingCustomizer<HttpSecurity> {
    return ThrowingCustomizer { http -> http
        .authorizeHttpRequests { requests -> requests
            .requestMatchers("/admins/**").hasRole("ADMIN")
        }
    }
}

(3)

@Bean
fun contentSecurityPolicy(): Customizer<HeadersConfigurer<HttpSecurity>> {
    return Customizer { headers -> headers
        .contentSecurityPolicy { csp -> csp
            .policyDirectives("object-src 'none'")
        }
    }
}

@Bean
fun contentTypeOptions(): Customizer<HeadersConfigurer<HttpSecurity>> {
    return Customizer { headers -> headers
        .contentTypeOptions(Customizer.withDefaults())
    }
}

@Bean
fun httpsRedirect(): Customizer<HttpsRedirectConfigurer<HttpSecurity>> {
    return Customizer.withDefaults<HttpsRedirectConfigurer<HttpSecurity>>()
}
1 首先Customizer<HttpSecurity>实例。 这adminAuthorization豆子的@Order所以首先应用它。如果没有@Order注释Customizer<HttpSecurity>Beans 或@Order注释具有相同的值，则Customizer<HttpSecurity>实例被应用为未定义。
2 这userAuthorization由于是Customizer<HttpSecurity>
3 命令Customizer类型未定义。 在此示例中，的顺序contentSecurityPolicy,contentTypeOptions和httpsRedirect是未定义的。 如果@Order(Ordered.HIGHEST_PRECEDENCE)被添加到contentTypeOptions，那么我们就会知道contentTypeOptions在contentSecurityPolicy（它们是同一类型），但我们不知道是否httpsRedirect在Customizer<HeadersConfigurer<HttpSecurity>>豆。
4 毕竟Customizer应用 bean，则HttpSecurity作为 Bean 传入。

后处理已配置对象

Spring Security 的 Java 配置不会公开它配置的每个对象的每个属性。 这简化了大多数用户的配置。 毕竟，如果每个属性都公开，用户可以使用标准 bean 配置。spring-doc.cadn.net.cn

虽然有充分的理由不直接公开每个属性，但用户可能仍需要更高级的配置选项。 为了解决这个问题，Spring Security 引入了ObjectPostProcessor，可用于修改或替换许多Object由 Java 配置创建的实例。 例如，要配置filterSecurityPublishAuthorizationSuccess属性FilterSecurityInterceptor，您可以使用以下内容：spring-doc.cadn.net.cn

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
	http
		.authorizeHttpRequests((authorize) -> authorize
			.anyRequest().authenticated()
			.withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
				public <O extends FilterSecurityInterceptor> O postProcess(
						O fsi) {
					fsi.setPublishAuthorizationSuccess(true);
					return fsi;
				}
			})
		);
	return http.build();
}