Java 配置

Spring Framework 在 Spring 3.1 中增加了对 Java 配置的通用支持。Spring Security 3.2 引入了 Java 配置，允许用户无需使用任何 XML 即可配置 Spring Security。

如果您熟悉 安全命名空间配置，您会发现它与 Spring Security Java 配置之间有许多相似之处。

Spring Security 提供了大量示例应用程序来演示 Spring Security Java 配置的使用。

Hello Web Security Java 配置

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

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;
	}
}

此配置不复杂也不广泛，但它做了很多工作

AbstractSecurityWebApplicationInitializer

下一步是将 springSecurityFilterChain 注册到 WAR 文件中。您可以在 Servlet 3.0+ 环境中通过 Spring 的 WebApplicationInitializer 支持在 Java 配置中完成此操作。不出所料，Spring Security 提供了一个基类 (AbstractSecurityWebApplicationInitializer) 来确保 springSecurityFilterChain 为您注册。我们使用 AbstractSecurityWebApplicationInitializer 的方式取决于我们是否已经在使用 Spring，或者 Spring Security 是否是我们应用程序中唯一的 Spring 组件。

没有现有 Spring 的 AbstractSecurityWebApplicationInitializer

如果您没有使用 Spring 或 Spring MVC，您需要将 WebSecurityConfig 传递给超类以确保配置被拾取

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

public class SecurityWebApplicationInitializer
	extends AbstractSecurityWebApplicationInitializer {

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

SecurityWebApplicationInitializer

  • 自动为应用程序中的每个 URL 注册 springSecurityFilterChain 过滤器。

  • 添加一个加载 WebSecurityConfig 的 ContextLoaderListener。

带有 Spring MVC 的 AbstractSecurityWebApplicationInitializer

如果我们在应用程序的其他地方使用 Spring，我们可能已经有一个正在加载我们的 Spring 配置的 WebApplicationInitializer。如果我们使用前面的配置，我们将得到一个错误。相反，我们应该将 Spring Security 注册到现有的 ApplicationContext 中。例如，如果我们使用 Spring MVC，我们的 SecurityWebApplicationInitializer 可能如下所示

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

public class SecurityWebApplicationInitializer
	extends AbstractSecurityWebApplicationInitializer {

}

这只为应用程序中的每个 URL 注册 springSecurityFilterChain。之后，我们需要确保在现有的 ApplicationInitializer 中加载了 WebSecurityConfig。例如，如果使用 Spring MVC，它会被添加到 getServletConfigClasses() 中。

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 MVC Dispatcher 配置

如果需要，任何与 Spring MVC 无关的 Spring Security 配置都可以放在不同的配置类中，如下所示

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 实例，并且不想在它们之间重复通用的安全配置，这会很有帮助。

HttpSecurity

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

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

默认配置（如前例所示）

  • 确保对应用程序的任何请求都需要用户经过身份验证

  • 允许用户使用基于表单的登录进行身份验证

  • 允许用户使用 HTTP 基本身份验证进行身份验证

请注意，此配置与 XML 命名空间配置并行

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

多个 HttpSecurity 实例

为了有效地管理应用程序中的安全性，其中某些区域需要不同的保护，我们可以结合 securityMatcher DSL 方法使用多个过滤器链。这种方法允许我们定义针对应用程序特定部分量身定制的不同安全配置，从而增强整体应用程序安全性和控制。

我们可以像在 XML 中有多个 <http> 块一样配置多个 HttpSecurity 实例。关键是注册多个 SecurityFilterChain @Bean。以下示例为以 /api/ 开头的 URL 提供了不同的配置

@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 创建一个包含 @Order 的 SecurityFilterChain 实例，以指定应首先考虑哪个 SecurityFilterChain。
3 http.securityMatcher() 表示此 HttpSecurity 仅适用于以 /api/ 开头的 URL。
4 创建另一个 SecurityFilterChain 实例。如果 URL 不以 /api/ 开头，则使用此配置。此配置在 apiFilterChain 之后考虑，因为它具有 1 之后的 @Order 值（没有 @Order 默认为最后）。

选择 securityMatcher 或 requestMatchers

一个常见问题是

http.securityMatcher() 方法与用于请求授权的 requestMatchers()（即在 http.authorizeHttpRequests() 内部）有什么区别？

为了回答这个问题，了解每个用于构建 SecurityFilterChain 的 HttpSecurity 实例都包含一个 RequestMatcher 来匹配传入请求会很有帮助。如果请求不匹配具有更高优先级（例如 @Order(1)）的 SecurityFilterChain，则可以针对具有较低优先级（例如没有 @Order）的过滤器链尝试该请求。

多个过滤器链的匹配逻辑由 FilterChainProxy 执行。

默认的 RequestMatcher 匹配 任何请求，以确保 Spring Security 默认保护所有请求。

指定 securityMatcher 会覆盖此默认值。

如果没有过滤器链匹配特定请求，则该请求 不受 Spring Security 的保护。

以下示例演示了一个仅保护以 /secured/ 开头的请求的单个过滤器链

@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）只需经过身份验证的用户。

建议提供一个不指定任何 securityMatcher 的 SecurityFilterChain，以确保整个应用程序受到保护，如 前面的示例所示。

请注意，requestMatchers 方法仅适用于单个授权规则。此处列出的每个请求也必须与用于创建 SecurityFilterChain 的此特定 HttpSecurity 实例的整体 securityMatcher 匹配。此示例中使用 anyRequest() 匹配此特定 SecurityFilterChain 内的所有其他请求（该请求必须以 /secured/ 开头）。

有关 requestMatchers 的更多信息，请参阅 授权 HttpServletRequest。

SecurityFilterChain 端点

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

指定 http.securityMatcher() 会影响该 SecurityFilterChain 匹配哪些请求。但是，它不会自动影响过滤器链提供的端点。在这种情况下，您可能需要自定义过滤器链要提供的任何端点的 URL。

以下示例演示了一个配置，该配置保护以 /secured/ 开头的请求并拒绝所有其他请求，同时还自定义了 SecurityFilterChain 提供的端点

@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()
			);
		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 自定义表单登录以 /secured/ 作为 URL 前缀。
4 自定义注销以 /secured/ 作为 URL 前缀。
5 所有其他请求将被拒绝。

此示例自定义了登录和注销页面，这会禁用 Spring Security 生成的页面。您必须为 GET /secured/login 和 GET /secured/logout 提供您自己的自定义端点。请注意，Spring Security 仍会为您提供 POST /secured/login 和 POST /secured/logout 端点。

实际示例

以下示例演示了一个稍微更真实的配置，将所有这些元素组合在一起

@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 定义一个带有 @Order(1) 的 SecurityFilterChain 实例，这意味着此过滤器链将具有最高优先级。此过滤器链仅适用于以 /accounts/approvals/、/loans/approvals/ 或 /credit-cards/approvals/ 开头的请求。对此过滤器链的请求需要 ROLE_ADMIN 权限并允许 HTTP 基本身份验证。
3 接下来，创建另一个带有 @Order(2) 的 SecurityFilterChain 实例，该实例将排在第二位。此过滤器链仅适用于以 /accounts/、/loans/、/credit-cards/ 或 /balances/ 开头的请求。请注意，由于此过滤器链是第二个，任何包含 /approvals/ 的请求都将匹配前一个过滤器链，并且 不会 被此过滤器链匹配。对此过滤器链的请求需要 ROLE_USER 权限。此过滤器链未定义任何身份验证，因为下一个（默认）过滤器链包含该配置。
4 最后，创建另一个没有 @Order 注解的 SecurityFilterChain 实例。此配置将处理未被其他过滤器链覆盖的请求，并将最后处理（没有 @Order 默认为最后）。匹配 /、/user-login、/user-logout、/notices、/contact 和 /register 的请求允许未经身份验证的访问。任何其他请求都需要用户进行身份验证才能访问任何未明确允许或受其他过滤器链保护的 URL。

自定义 DSL

您可以在 Spring Security 中提供自己的自定义 DSL

  • Java

  • Kotlin

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() 等方法实现的方式。

然后您可以使用自定义 DSL

  • Java

  • Kotlin

@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()
    }
}

代码按以下顺序调用

  • 调用 Config.filterChain 方法中的代码

  • 调用 MyCustomDsl.init 方法中的代码

  • 调用 MyCustomDsl.configure 方法中的代码

如果您愿意，可以使用 SpringFactories 让 HttpSecurity 默认添加 MyCustomDsl。例如，您可以在类路径上创建一个名为 META-INF/spring.factories 的资源，其内容如下

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

您也可以显式禁用默认值

  • Java

  • Kotlin

@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 Security 的 Kotlin 配置，那么您还可以像 模块化 HttpSecurityDsl 配置中概述的那样公开 *Dsl → Unit Bean。

Customizer<HttpSecurity> Bean

如果您想模块化您的安全配置，可以将逻辑放入 Customizer<HttpSecurity> Bean 中。例如，以下配置将确保所有 HttpSecurity 实例都配置为

  • Java

  • Kotlin

@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 Customizer Bean

如果您希望进一步模块化您的安全配置，Spring Security 将自动应用任何顶级 HttpSecurity Customizer Bean。

顶级 HttpSecurity Customizer 类型可以概括为任何与 public HttpSecurity.*(Customizer<T>) 匹配的 Customizer<T>。这意味着任何作为 HttpSecurity 公共方法的单个参数的 Customizer<T>。

几个例子可以帮助澄清。如果 Customizer<ContentTypeOptionsConfig> 作为 Bean 发布，它将不会自动应用，因为它是一个参数 HeadersConfigurer.contentTypeOptions(Customizer)，而这不是 HttpSecurity 上定义的方法。但是，如果 Customizer<HeadersConfigurer<HttpSecurity>> 作为 Bean 发布，它将自动应用，因为它是一个参数 HttpSecurity.headers(Customizer)。

例如，以下配置将确保 内容安全策略 设置为 object-src 'none'

  • Java

  • Kotlin

@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 Bean 排序

首先，使用 ObjectProvider#orderedStream() 应用每个 Customizer<HttpSecurity> Bean。这意味着如果存在多个 Customizer<HttpSecurity> Bean，则可以将 @Order 注解添加到 Bean 定义以控制排序。

接下来，查找每个 顶级 HttpSecurity Customizer Bean 类型，并使用 ObjectProvider#orderedStream() 应用每个类型。如果存在两个 Customizer<HeadersConfigurer<HttpSecurity>> Bean 和两个 Customizer<HttpsRedirectConfigurer<HttpSecurity>> 实例，则调用每个 Customizer 类型的顺序是未定义的。但是，每个 Customizer<HttpsRedirectConfigurer<HttpSecurity>> 实例的顺序由 ObjectProvider#orderedStream() 定义，并且可以使用 Bean 定义上的 @Order 进行控制。

最后，HttpSecurity Bean 作为 Bean 注入。所有 Customizer 实例在 HttpSecurity Bean 创建之前应用。这允许覆盖由 Customizer Bean 提供的自定义。

您可以在下面找到一个说明排序的示例

  • Java

  • Kotlin

@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 Bean 具有最高的 @Order，因此它最先应用。如果在 Customizer<HttpSecurity> Bean 上没有 @Order 注解，或者 @Order 注解具有相同的值，则 Customizer<HttpSecurity> 实例的应用顺序是未定义的。
2 由于 userAuthorization 是 Customizer<HttpSecurity> 的实例，因此接下来应用它。
3 Customizer 类型的顺序是未定义的。在此示例中，contentSecurityPolicy、contentTypeOptions 和 httpsRedirect 的顺序是未定义的。如果将 @Order(Ordered.HIGHEST_PRECEDENCE) 添加到 contentTypeOptions，那么我们就会知道 contentTypeOptions 在 contentSecurityPolicy 之前（它们是相同类型），但我们不知道 httpsRedirect 在 Customizer<HeadersConfigurer<HttpSecurity>> Bean 之前还是之后。
4 在所有 Customizer Bean 应用之后，HttpSecurity 作为 Bean 传入。

后处理配置对象

Spring Security 的 Java 配置不公开它配置的每个对象的每个属性。这简化了大多数用户的配置。毕竟，如果每个属性都暴露，用户可以使用标准的 bean 配置。

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

@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();
}
© . This site is unofficial and not affiliated with VMware.