Java 配置 (Java Configuration) _ Spring Security6.4.0-SNAPSHOT中文文档(官方文档中文翻译)|Spring 教程 —

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

在 Spring 3.1 中，Spring Framework 中添加了对 Java 配置的一般支持。 Spring Security 3.2 引入了 Java 配置，允许用户在不使用任何 XML 的情况下配置 Spring Security。spring-doc.cn

如果您熟悉 Security Namespace Configuration，您应该会发现它与 Spring Security Java 配置之间有很多相似之处。spring-doc.cn

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

Hello Web Security Java 配置

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

要求对应用程序中的每个 URL 进行身份验证spring-doc.cn
为您生成登录表单spring-doc.cn
让 Username 为和 Password 的用户使用基于表单的身份验证进行身份验证userpasswordspring-doc.cn
允许用户注销spring-doc.cn
CSRF 攻击预防spring-doc.cn
Session Fixation 保护spring-doc.cn
安全标头集成：spring-doc.cn
- 用于安全请求的 HTTP 严格传输安全性 spring-doc.cn
- X-Content-Type-Options 集成spring-doc.cn
- 缓存控制（您可以稍后在应用程序中覆盖它以允许缓存静态资源）spring-doc.cn
- X-XSS-Protection 集成spring-doc.cn
- X-Frame-Options 集成有助于防止点击劫持 spring-doc.cn
与以下 Servlet API 方法集成：spring-doc.cn

AbstractSecurityWebApplicationInitializer

下一步是向 WAR 文件注册。您可以在 Servlet 3.0+ 环境中使用 Spring 的 WebApplicationInitializer 支持在 Java 配置中执行此操作。毫不奇怪， Spring Security 提供了一个基类（）来确保为您注册。我们使用的方式会有所不同，具体取决于我们是否已经在使用 Spring，或者 Spring Security 是否是我们应用程序中唯一的 Spring 组件。springSecurityFilterChainAbstractSecurityWebApplicationInitializerspringSecurityFilterChainAbstractSecurityWebApplicationInitializerspring-doc.cn

没有现有 Spring 的 AbstractSecurityWebApplicationInitializer - 如果您尚未使用 Spring，请使用这些说明spring-doc.cn
AbstractSecurityWebApplicationInitializer 与 Spring MVC - 如果您已经在使用 Spring，请使用这些说明spring-doc.cn

没有现有 Spring 的 AbstractSecurityWebApplicationInitializer

如果你没有使用 Spring 或 Spring MVC，你需要将传递给超类以确保配置被拾取：WebSecurityConfigspring-doc.cn

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

public class SecurityWebApplicationInitializer
	extends AbstractSecurityWebApplicationInitializer {

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

这：SecurityWebApplicationInitializerspring-doc.cn

自动为应用程序中的每个 URL 注册 Filter。springSecurityFilterChainspring-doc.cn
添加一个加载 WebSecurityConfig 的 a 。ContextLoaderListenerspring-doc.cn

使用 Spring MVC 的 AbstractSecurityWebApplicationInitializer

如果我们在应用程序的其他地方使用 Spring，我们可能已经有一个正在加载我们的 Spring Configuration。如果我们使用以前的配置，则会收到错误。相反，我们应该使用现有的 . 例如，如果我们使用 Spring MVC，我们的可能如下所示：WebApplicationInitializerApplicationContextSecurityWebApplicationInitializerspring-doc.cn

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

public class SecurityWebApplicationInitializer
	extends AbstractSecurityWebApplicationInitializer {

}

这只会在应用程序中的每个 URL 中注册。之后，我们需要确保它已加载到我们现有的 . 例如，如果我们使用 Spring MVC，它会被添加到：springSecurityFilterChainWebSecurityConfigApplicationInitializergetServletConfigClasses()spring-doc.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 放在中，将其放入可能无法找到 Spring MVC 的父应用程序上下文中。getRootConfigClassesHandlerMappingIntrospectorspring-doc.cn

配置多个 Spring MVC 调度器

如果需要，任何与 Spring MVC 无关的 Spring Security 配置都可以放置在不同的配置类中，如下所示：spring-doc.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 ...
}

如果您有多个实例，并且不想在这两个实例之间复制常规安全配置，这可能会很有帮助。AbstractAnnotationConfigDispatcherServletInitializerspring-doc.cn

HttpSecurity 安全

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

确保对我们的应用程序的任何请求都需要对用户进行身份验证spring-doc.cn
允许用户使用基于表单的登录进行身份验证spring-doc.cn
允许用户使用 HTTP 基本身份验证进行身份验证spring-doc.cn

请注意，此配置与 XML 命名空间配置类似：spring-doc.cn

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

多个 HttpSecurity 实例

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

我们可以配置多个实例，就像我们可以在 XML 中拥有多个块一样。关键是要注册多个 s。以下示例对以开头的 URL 具有不同的配置。HttpSecurity<http>SecurityFilterChain@Bean/api/spring-doc.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	照常配置 Authentication。
2	创建该 contains 的实例以指定应首先考虑哪个实例。`SecurityFilterChain@OrderSecurityFilterChain`
3	表示这仅适用于以 .`http.securityMatcher()HttpSecurity/api/`
4	创建的另一个实例。如果 URL 不以开头，则使用此配置。此配置在之后考虑，因为它在之后具有值（没有默认为 last）。`SecurityFilterChain/api/apiFilterChain@Order1@Order`

选择或`securityMatcherrequestMatchers`

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

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

要回答这个问题，了解用于构建的每个实例都包含一个以匹配传入请求。如果请求与优先级较高的 a 不匹配（例如），则可以针对优先级较低的过滤器链（例如 no ）尝试请求。HttpSecuritySecurityFilterChainRequestMatcherSecurityFilterChain@Order(1)@Orderspring-doc.cn

多个过滤器链的匹配逻辑由 FilterChainProxy 执行。spring-doc.cn

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

指定 a 将覆盖此默认值。securityMatcherspring-doc.cn

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

以下示例演示了一个筛选条件链，该链仅保护以：/secured/spring-doc.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/userROLE_USER`
3	需要权限的请求。`/secured/adminROLE_ADMIN`
4	任何其他请求（例如）只需要经过身份验证的用户。`/secured/other`

建议提供不指定 any 的 a ，以确保整个应用程序受到保护，如前面的示例所示。SecurityFilterChainsecurityMatcherspring-doc.cn

请注意，该方法仅适用于单个授权规则。此处列出的每个请求还必须与用于创建 . 在此示例中使用匹配此特定（必须以开头）中的所有其他请求。requestMatcherssecurityMatcherHttpSecuritySecurityFilterChainanyRequest()SecurityFilterChain/secured/spring-doc.cn

有关的更多信息，请参阅授权 HttpServletRequests 。requestMatchersspring-doc.cn

`SecurityFilterChain`端点

中的多个筛选条件直接提供终端节点，例如由终端节点设置并提供终端节点的筛选条件。在上面的示例中，endpoint 不匹配，因此该应用程序将没有 any 或 endpoint。此类请求将返回。这通常让用户感到惊讶。SecurityFilterChainUsernamePasswordAuthenticationFilterhttp.formLogin()POST /login/loginhttp.securityMatcher("/secured/**")GET /loginPOST /login404 Not Foundspring-doc.cn

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

以下示例演示了一个配置，该配置保护以开头并拒绝所有其他请求的请求，同时还自定义：/secured/SecurityFilterChainspring-doc.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 生成的页面。您必须为和提供自己的自定义终端节点。请注意，Spring Security 仍然为您提供 and endpoints 。GET /secured/loginGET /secured/logoutPOST /secured/loginPOST /secured/logoutspring-doc.cn

真实示例

以下示例演示了将所有这些元素放在一起的更真实的配置：spring-doc.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	使用定义实例，这意味着此过滤器链将具有最高优先级。此筛选条件链仅适用于以、或开头的请求。对此过滤器链的请求需要权限并允许 HTTP 基本身份验证。`SecurityFilterChain@Order(1)/accounts/approvals//loans/approvals//credit-cards/approvals/ROLE_ADMIN`
3	接下来，创建另一个实例，该实例将被视为第二个实例。此筛选条件链仅适用于以、、或开头的请求。请注意，由于此筛选条件链是第二个筛选条件链，因此任何包含的请求都将与前一个筛选条件链匹配，并且不会与此筛选条件链匹配。对此筛选条件链的请求需要 authority。此过滤器链未定义任何身份验证，因为下一个（默认）过滤器链包含该配置。`SecurityFilterChain@Order(2)/accounts//loans//credit-cards//balances//approvals/ROLE_USER`
4	最后，创建一个不带注释的附加实例。此配置将处理其他过滤器链未涵盖的请求，并将最后处理（没有默认值为最后）。匹配、和的请求允许无需身份验证即可访问。任何其他请求都要求用户进行身份验证才能访问其他筛选条件链未明确允许或保护的任何 URL。`SecurityFilterChain@Order@Order//user-login/user-logout/notices/contact/register`

1	照常配置 Authentication。
2	创建该 contains 的实例以指定应首先考虑哪个实例。`SecurityFilterChain@OrderSecurityFilterChain`
3	表示这仅适用于以 .`http.securityMatcher()HttpSecurity/api/`
4	创建的另一个实例。如果 URL 不以开头，则使用此配置。此配置在之后考虑，因为它在之后具有值（没有默认为 last）。`SecurityFilterChain/api/apiFilterChain@Order1@Order`

多个过滤器链的匹配逻辑由 FilterChainProxy 执行。spring-doc.cn

指定 a 将覆盖此默认值。securityMatcherspring-doc.cn

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

1	以开头的请求将受到保护，但任何其他请求都不受保护。`/secured/`
2	需要权限的请求。`/secured/userROLE_USER`
3	需要权限的请求。`/secured/adminROLE_ADMIN`
4	任何其他请求（例如）只需要经过身份验证的用户。`/secured/other`

建议提供不指定 any 的 a ，以确保整个应用程序受到保护，如前面的示例所示。SecurityFilterChainsecurityMatcherspring-doc.cn

有关的更多信息，请参阅授权 HttpServletRequests 。requestMatchersspring-doc.cn

1	以开头的请求将受此筛选条件链保护。`/secured/`
2	以开头的请求需要经过身份验证的用户。`/secured/`
3	自定义表单登录以在 URL 前面加上 .`/secured/`
4	自定义注销以在 URL 前面添加 .`/secured/`
5	所有其他请求都将被拒绝。

1	首先配置身份验证设置。
2	使用定义实例，这意味着此过滤器链将具有最高优先级。此筛选条件链仅适用于以、或开头的请求。对此过滤器链的请求需要权限并允许 HTTP 基本身份验证。`SecurityFilterChain@Order(1)/accounts/approvals//loans/approvals//credit-cards/approvals/ROLE_ADMIN`
3	接下来，创建另一个实例，该实例将被视为第二个实例。此筛选条件链仅适用于以、、或开头的请求。请注意，由于此筛选条件链是第二个筛选条件链，因此任何包含的请求都将与前一个筛选条件链匹配，并且不会与此筛选条件链匹配。对此筛选条件链的请求需要 authority。此过滤器链未定义任何身份验证，因为下一个（默认）过滤器链包含该配置。`SecurityFilterChain@Order(2)/accounts//loans//credit-cards//balances//approvals/ROLE_USER`
4	最后，创建一个不带注释的附加实例。此配置将处理其他过滤器链未涵盖的请求，并将最后处理（没有默认值为最后）。匹配、和的请求允许无需身份验证即可访问。任何其他请求都要求用户进行身份验证才能访问其他筛选条件链未明确允许或保护的任何 URL。`SecurityFilterChain@Order@Order//user-login/user-logout/notices/contact/register`

自定义 DSL

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

Javaspring-doc.cn
Kotlinspring-doc.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()
        }
    }
}

这实际上是 method like 的实现方式。HttpSecurity.authorizeHttpRequests()spring-doc.cn

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

Javaspring-doc.cn
Kotlinspring-doc.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.cn

调用方法中的代码Config.filterChainspring-doc.cn
调用方法中的代码MyCustomDsl.initspring-doc.cn
调用方法中的代码MyCustomDsl.configurespring-doc.cn

如果需要，默认情况下，您可以使用 . 例如，您可以在以以下内容命名的 Classpath 上创建一个资源：HttpSecurityMyCustomDslSpringFactoriesMETA-INF/spring.factoriesspring-doc.cn

元 INF/spring.factories

org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer = sample.MyCustomDsl

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

Javaspring-doc.cn
Kotlinspring-doc.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()
    }

}

这实际上是 method like 的实现方式。HttpSecurity.authorizeHttpRequests()spring-doc.cn

后处理已配置的对象

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

虽然有充分的理由不直接公开每个属性，但用户可能仍需要更高级的配置选项。为了解决这个问题， Spring Security 引入了 an 的概念，它可用于修改或替换 Java 配置创建的许多实例。例如，要在上配置属性，可以使用以下内容：ObjectPostProcessorObjectfilterSecurityPublishAuthorizationSuccessFilterSecurityInterceptorspring-doc.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();
}

Hello Web Security Java 配置

AbstractSecurityWebApplicationInitializer

没有现有 Spring 的 AbstractSecurityWebApplicationInitializer

使用 Spring MVC 的 AbstractSecurityWebApplicationInitializer

配置多个 Spring MVC 调度器

HttpSecurity 安全

多个 HttpSecurity 实例

选择 或securityMatcherrequestMatchers

SecurityFilterChain端点

真实示例

自定义 DSL

后处理已配置的对象

选择或`securityMatcherrequestMatchers`

`SecurityFilterChain`端点