对于最新的稳定版本，请使用 Spring Security 6.3.3！spring-doc.cn

对于最新的稳定版本，请使用 Spring Security 6.3.3！spring-doc.cn
FilterSecurityInterceptor正在被 AuthorizationFilter 替换。 考虑改用它。

本节以 Servlet 体系结构和实现为基础，深入探讨了授权在基于 Servlet 的应用程序中的工作原理。spring-doc.cn

FilterSecurityInterceptor为 s 提供授权。 它作为 Security Filters 之一插入到 FilterChainProxy 中。HttpServletRequestspring-doc.cn

filtersecurityinterceptor
图 1.授权 HttpServletRequest

  • 数字 1首先，从 SecurityContextHolder 获取 Authentication。FilterSecurityInterceptorspring-doc.cn

  • 编号 2其次，从 、 和 创建一个 FilterInvocation，并将其传递到 .FilterSecurityInterceptorHttpServletRequestHttpServletResponseFilterChainFilterSecurityInterceptorspring-doc.cn

  • 编号 3接下来，它传递 to 以获取 s。FilterInvocationSecurityMetadataSourceConfigAttributespring-doc.cn

  • 编号 4最后，它将 、 和 s 传递给 xref：servlet/authorization.adoc#authz-access-decision-manager'AccessDecisionManager'。AuthenticationFilterInvocationConfigAttributespring-doc.cn

默认情况下，Spring Security 的授权将要求对所有请求进行身份验证。 显式配置如下所示：spring-doc.cn

每个请求都必须进行身份验证
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
	http
		// ...
		.authorizeRequests(authorize -> authorize
			.anyRequest().authenticated()
		);
	return http.build();
}
<http>
	<!-- ... -->
	<intercept-url pattern="/**" access="authenticated"/>
</http>
@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
    http {
        // ...
        authorizeRequests {
            authorize(anyRequest, authenticated)
        }
    }
    return http.build()
}

我们可以通过按优先顺序添加更多规则来将 Spring Security 配置为具有不同的规则。spring-doc.cn

授权请求
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
	http
		// ...
		.authorizeRequests(authorize -> authorize                                  (1)
			.mvcMatchers("/resources/**", "/signup", "/about").permitAll()         (2)
			.mvcMatchers("/admin/**").hasRole("ADMIN")                             (3)
			.mvcMatchers("/db/**").access("hasRole('ADMIN') and hasRole('DBA')")   (4)
			.anyRequest().denyAll()                                                (5)
		);
	return http.build();
}
<http> (1)
	<!-- ... -->
	(2)
	<intercept-url pattern="/resources/**" access="permitAll"/>
	<intercept-url pattern="/signup" access="permitAll"/>
	<intercept-url pattern="/about" access="permitAll"/>

	<intercept-url pattern="/admin/**" access="hasRole('ADMIN')"/> (3)
	<intercept-url pattern="/db/**" access="hasRole('ADMIN') and hasRole('DBA')"/> (4)
	<intercept-url pattern="/**" access="denyAll"/> (5)
</http>
@Bean
open fun filterChain(http: HttpSecurity): SecurityFilterChain {
   http {
        authorizeRequests { (1)
            authorize("/resources/**", permitAll) (2)
            authorize("/signup", permitAll)
            authorize("/about", permitAll)

            authorize("/admin/**", hasRole("ADMIN")) (3)
            authorize("/db/**", "hasRole('ADMIN') and hasRole('DBA')") (4)
            authorize(anyRequest, denyAll) (5)
        }
    }
    return http.build()
}
1 指定了多个授权规则。 每个规则都按照其声明的顺序进行考虑。
2 我们指定了任何用户都可以访问的多个 URL 模式。 具体而言，如果 URL 以“/resources/”开头、等于“/signup”或等于“/about”，则任何用户都可以访问请求。
3 任何以 “/admin/” 开头的 URL 都将被限制为具有 “ROLE_ADMIN” 角色的用户。 您会注意到，由于我们正在调用该方法，因此不需要指定 “ROLE_” 前缀。hasRole
4 任何以 “/db/” 开头的 URL 都要求用户同时具有 “ROLE_ADMIN” 和 “ROLE_DBA”。 您会注意到，由于我们使用的是表达式，因此不需要指定 “ROLE_” 前缀。hasRole
5 任何尚未匹配的 URL 都将被拒绝访问。 如果您不想意外忘记更新授权规则，这是一个很好的策略。
FilterSecurityInterceptor正在被 AuthorizationFilter 替换。 考虑改用它。
1 指定了多个授权规则。 每个规则都按照其声明的顺序进行考虑。
2 我们指定了任何用户都可以访问的多个 URL 模式。 具体而言，如果 URL 以“/resources/”开头、等于“/signup”或等于“/about”，则任何用户都可以访问请求。
3 任何以 “/admin/” 开头的 URL 都将被限制为具有 “ROLE_ADMIN” 角色的用户。 您会注意到，由于我们正在调用该方法，因此不需要指定 “ROLE_” 前缀。hasRole
4 任何以 “/db/” 开头的 URL 都要求用户同时具有 “ROLE_ADMIN” 和 “ROLE_DBA”。 您会注意到，由于我们使用的是表达式，因此不需要指定 “ROLE_” 前缀。hasRole
5 任何尚未匹配的 URL 都将被拒绝访问。 如果您不想意外忘记更新授权规则，这是一个很好的策略。

将 FilterSecurityInterceptor 应用于每个请求

默认情况下，仅对请求应用一次。 这意味着，如果请求是从已过滤的请求中分派的，则 将退避并且不执行任何授权检查。 在某些情况下，您可能希望将筛选器应用于每个请求。 您可以使用以下方法将 Spring Security 配置为将授权规则应用于每个请求：FilterSecurityInterceptorFilterSecurityInterceptorfilterSecurityInterceptorOncePerRequestspring-doc.cn

将 filterSecurityInterceptorOncePerRequest 设置为 false
@Bean
SecurityFilterChain web(HttpSecurity http) throws Exception {
    http
        .authorizeRequests((authorize) -> authorize
            .filterSecurityInterceptorOncePerRequest(false)
            .anyRequest.authenticated()
        )
        // ...

    return http.build();
}
<http once-per-request="false">
    <intercept-url pattern="/**" access="authenticated"/>
</http>

您还可以根据请求分派器类型配置授权：spring-doc.cn

允许 ASYNC 调度程序类型
@Bean
SecurityFilterChain web(HttpSecurity http) throws Exception {
    http
        .authorizeRequests((authorize) -> authorize
            .filterSecurityInterceptorOncePerRequest(false)
            .dispatcherTypeMatchers(DispatcherType.ASYNC).permitAll()
            .anyRequest.authenticated()
        )
        // ...

    return http.build();
}
<http auto-config="true" once-per-request="false">
    <intercept-url request-matcher-ref="dispatcherTypeMatcher" access="permitAll" />
    <intercept-url pattern="/**" access="authenticated"/>
</http>

<b:bean id="dispatcherTypeMatcher" class="org.springframework.security.web.util.matcher.DispatcherTypeRequestMatcher">
    <b:constructor-arg value="ASYNC"/>
</b:bean>