授权 HttpServletRequests
Spring Security 允许你在请求级别建模你的授权。例如,使用 Spring Security,你可以指定 /admin
下的所有页面需要一个权限,而所有其他页面仅需要认证。
默认情况下,Spring Security 要求每个请求都经过认证。也就是说,任何时候你使用一个 HttpSecurity
实例,都必须声明你的授权规则。
无论何时你有 HttpSecurity
实例,至少应该这样做
-
Java
-
Kotlin
-
Xml
http
.authorizeHttpRequests((authorize) -> authorize
.anyRequest().authenticated()
)
http {
authorizeHttpRequests {
authorize(anyRequest, authenticated)
}
}
<http>
<intercept-url pattern="/**" access="authenticated"/>
</http>
这告诉 Spring Security,你应用程序中的任何端点至少需要安全上下文经过认证才能允许访问。
在许多情况下,你的授权规则会比这更复杂,因此请考虑以下用例
-
我有一个使用
authorizeRequests
的应用,想迁移到authorizeHttpRequests
-
我想匹配请求,并且我将 Spring MVC 映射到了非默认 servlet
-
我想授权请求
-
我想将请求授权委托给策略代理
理解请求授权组件如何工作
本节基于Servlet 架构和实现,深入探讨 Servlet 应用程序中请求级别的授权工作方式。 |

-
首先,
AuthorizationFilter
构建一个Supplier
,该Supplier
从SecurityContextHolder检索Authentication。 -
其次,它将
Supplier<Authentication>
和HttpServletRequest
传递给AuthorizationManager
。AuthorizationManager
将请求与authorizeHttpRequests
中的模式匹配,并运行相应的规则。-
如果授权被拒绝,则会发布
AuthorizationDeniedEvent
并抛出AccessDeniedException
。在这种情况下,ExceptionTranslationFilter
处理AccessDeniedException
。 -
如果访问被允许,则会发布
AuthorizationGrantedEvent
,并且AuthorizationFilter
继续处理FilterChain,这允许应用程序正常处理。
-
默认情况下 AuthorizationFilter
位于最后
默认情况下,AuthorizationFilter
位于Spring Security 过滤器链的最后。这意味着 Spring Security 的认证过滤器、攻击防护和其他过滤器集成不需要授权。如果你在 AuthorizationFilter
之前添加自己的过滤器,它们也不需要授权;否则,它们将需要授权。
通常,在你添加Spring MVC端点时,这一点变得很重要。因为它们由DispatcherServlet
执行,而 DispatcherServlet
在 AuthorizationFilter
之后运行,所以你的端点需要包含在 authorizeHttpRequests
中才能被允许访问。
所有转发都经过授权
AuthorizationFilter
不仅在每个请求上运行,而且在每个转发 (dispatch) 上运行。这意味着 REQUEST
转发需要授权,`FORWARD`、`ERROR` 和 `INCLUDE` 也需要。
例如,Spring MVC 可以将请求 FORWARD
到一个视图解析器,该解析器渲染 Thymeleaf 模板,如下所示
-
Java
-
Kotlin
@Controller
public class MyController {
@GetMapping("/endpoint")
public String endpoint() {
return "endpoint";
}
}
@Controller
class MyController {
@GetMapping("/endpoint")
fun endpoint(): String {
return "endpoint"
}
}
在这种情况下,授权会发生两次;一次是授权 /endpoint
,另一次是转发到 Thymeleaf 渲染 "endpoint" 模板。
因此,你可能想允许所有 FORWARD
转发。
这一原则的另一个例子是Spring Boot 如何处理错误。如果容器捕获到一个异常,例如如下所示
-
Java
-
Kotlin
@Controller
public class MyController {
@GetMapping("/endpoint")
public String endpoint() {
throw new UnsupportedOperationException("unsupported");
}
}
@Controller
class MyController {
@GetMapping("/endpoint")
fun endpoint(): String {
throw UnsupportedOperationException("unsupported")
}
}
那么 Boot 会将其转发到 ERROR
转发。
在那种情况下,授权也会发生两次;一次是授权 /endpoint
,另一次是转发错误。
因此,你可能想允许所有 ERROR
转发。
Authentication
查找延迟
这在使用 authorizeHttpRequests
并且请求总是允许或总是拒绝时很重要。在这些情况下,Authentication 不会被查询,从而使请求更快。
授权端点
你可以通过添加更多规则并按优先级顺序排列来配置 Spring Security 具有不同的规则。
如果你想要求 /endpoint
只能由具有 USER
权限的终端用户访问,那么你可以这样做
-
Java
-
Kotlin
-
Xml
@Bean
public SecurityFilterChain web(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests((authorize) -> authorize
.requestMatchers("/endpoint").hasAuthority("USER")
.anyRequest().authenticated()
)
// ...
return http.build();
}
@Bean
fun web(http: HttpSecurity): SecurityFilterChain {
http {
authorizeHttpRequests {
authorize("/endpoint", hasAuthority("USER"))
authorize(anyRequest, authenticated)
}
}
return http.build()
}
<http>
<intercept-url pattern="/endpoint" access="hasAuthority('USER')"/>
<intercept-url pattern="/**" access="authenticated"/>
</http>
如你所见,声明可以分解为模式/规则对。
AuthorizationFilter
按列出的顺序处理这些对,仅将第一个匹配项应用于请求。这意味着即使 /**
也匹配 /endpoint
,上述规则也不会有问题。上述规则的解读方式是:“如果请求是 /endpoint
,则需要 USER
权限;否则,仅需要认证”。
Spring Security 支持多种模式和多种规则;你也可以以编程方式创建自己的模式和规则。
一旦授权,你可以使用Spring Security 的测试支持以下列方式进行测试
-
Java
@WithMockUser(authorities="USER")
@Test
void endpointWhenUserAuthorityThenAuthorized() {
this.mvc.perform(get("/endpoint"))
.andExpect(status().isOk());
}
@WithMockUser
@Test
void endpointWhenNotUserAuthorityThenForbidden() {
this.mvc.perform(get("/endpoint"))
.andExpect(status().isForbidden());
}
@Test
void anyWhenUnauthenticatedThenUnauthorized() {
this.mvc.perform(get("/any"))
.andExpect(status().isUnauthorized());
}
匹配请求
上面你已经看到了两种匹配请求的方式。
你看到的第一个是最简单的,即匹配任何请求。
使用 Ant 进行匹配
Ant 是 Spring Security 用于匹配请求的默认语言。
你可以使用它来匹配单个端点或目录,甚至可以捕获占位符以供后续使用。你也可以将其细化以匹配特定的 HTTP 方法集合。
假设你不想匹配 /endpoint
端点,而是想匹配 /resource
目录下的所有端点。在这种情况下,你可以执行以下操作
-
Java
-
Kotlin
-
Xml
http
.authorizeHttpRequests((authorize) -> authorize
.requestMatchers("/resource/**").hasAuthority("USER")
.anyRequest().authenticated()
)
http {
authorizeHttpRequests {
authorize("/resource/**", hasAuthority("USER"))
authorize(anyRequest, authenticated)
}
}
<http>
<intercept-url pattern="/resource/**" access="hasAuthority('USER')"/>
<intercept-url pattern="/**" access="authenticated"/>
</http>
这段代码的解读方式是:“如果请求是 /resource
或其某个子目录,则需要 USER
权限;否则,仅需要认证”
你也可以从请求中提取路径值,如下所示
-
Java
-
Kotlin
-
Xml
http
.authorizeHttpRequests((authorize) -> authorize
.requestMatchers("/resource/{name}").access(new WebExpressionAuthorizationManager("#name == authentication.name"))
.anyRequest().authenticated()
)
http {
authorizeHttpRequests {
authorize("/resource/{name}", WebExpressionAuthorizationManager("#name == authentication.name"))
authorize(anyRequest, authenticated)
}
}
<http>
<intercept-url pattern="/resource/{name}" access="#name == authentication.name"/>
<intercept-url pattern="/**" access="authenticated"/>
</http>
一旦授权,你可以使用Spring Security 的测试支持以下列方式进行测试
-
Java
@WithMockUser(authorities="USER")
@Test
void endpointWhenUserAuthorityThenAuthorized() {
this.mvc.perform(get("/endpoint/jon"))
.andExpect(status().isOk());
}
@WithMockUser
@Test
void endpointWhenNotUserAuthorityThenForbidden() {
this.mvc.perform(get("/endpoint/jon"))
.andExpect(status().isForbidden());
}
@Test
void anyWhenUnauthenticatedThenUnauthorized() {
this.mvc.perform(get("/any"))
.andExpect(status().isUnauthorized());
}
Spring Security 只匹配路径。如果你想匹配查询参数,则需要一个自定义请求匹配器。 |
使用正则表达式进行匹配
Spring Security 支持根据正则表达式匹配请求。如果你想对子目录应用比 **
更严格的匹配条件,这将非常有用。
例如,考虑一个包含用户名的路径,并且规则是所有用户名必须是字母数字。你可以使用RegexRequestMatcher
来遵循此规则,如下所示
-
Java
-
Kotlin
-
Xml
http
.authorizeHttpRequests((authorize) -> authorize
.requestMatchers(RegexRequestMatcher.regexMatcher("/resource/[A-Za-z0-9]+")).hasAuthority("USER")
.anyRequest().denyAll()
)
http {
authorizeHttpRequests {
authorize(RegexRequestMatcher.regexMatcher("/resource/[A-Za-z0-9]+"), hasAuthority("USER"))
authorize(anyRequest, denyAll)
}
}
<http>
<intercept-url request-matcher="regex" pattern="/resource/[A-Za-z0-9]+" access="hasAuthority('USER')"/>
<intercept-url pattern="/**" access="denyAll"/>
</http>
按 Http 方法匹配
你也可以按 HTTP 方法匹配规则。这在一个地方很方便,那就是根据授予的权限进行授权,例如授予 read
或 write
特权。
要要求所有 GET
请求具有 read
权限,所有 POST
请求具有 write
权限,你可以这样做
-
Java
-
Kotlin
-
Xml
http
.authorizeHttpRequests((authorize) -> authorize
.requestMatchers(HttpMethod.GET).hasAuthority("read")
.requestMatchers(HttpMethod.POST).hasAuthority("write")
.anyRequest().denyAll()
)
http {
authorizeHttpRequests {
authorize(HttpMethod.GET, hasAuthority("read"))
authorize(HttpMethod.POST, hasAuthority("write"))
authorize(anyRequest, denyAll)
}
}
<http>
<intercept-url http-method="GET" pattern="/**" access="hasAuthority('read')"/>
<intercept-url http-method="POST" pattern="/**" access="hasAuthority('write')"/>
<intercept-url pattern="/**" access="denyAll"/>
</http>
这些授权规则应解读为:“如果请求是 GET,则需要 read
权限;否则,如果请求是 POST,则需要 write
权限;否则,拒绝请求”
默认拒绝请求是一种健康的安全性实践,因为它将规则集变成了允许列表。 |
一旦授权,你可以使用Spring Security 的测试支持以下列方式进行测试
-
Java
@WithMockUser(authorities="read")
@Test
void getWhenReadAuthorityThenAuthorized() {
this.mvc.perform(get("/any"))
.andExpect(status().isOk());
}
@WithMockUser
@Test
void getWhenNoReadAuthorityThenForbidden() {
this.mvc.perform(get("/any"))
.andExpect(status().isForbidden());
}
@WithMockUser(authorities="write")
@Test
void postWhenWriteAuthorityThenAuthorized() {
this.mvc.perform(post("/any").with(csrf()))
.andExpect(status().isOk());
}
@WithMockUser(authorities="read")
@Test
void postWhenNoWriteAuthorityThenForbidden() {
this.mvc.perform(get("/any").with(csrf()))
.andExpect(status().isForbidden());
}
按转发类型匹配
此功能目前在 XML 中不受支持 |
如前所述,Spring Security默认授权所有转发类型。即使在 REQUEST
转发上建立的安全上下文会延续到后续转发,细微的不匹配有时也可能导致意外的 AccessDeniedException
。
为了解决这个问题,你可以配置 Spring Security Java 配置以允许 FORWARD
和 ERROR
等转发类型,如下所示
-
Java
-
Kotlin
http
.authorizeHttpRequests((authorize) -> authorize
.dispatcherTypeMatchers(DispatcherType.FORWARD, DispatcherType.ERROR).permitAll()
.requestMatchers("/endpoint").permitAll()
.anyRequest().denyAll()
)
http {
authorizeHttpRequests {
authorize(DispatcherTypeRequestMatcher(DispatcherType.FORWARD), permitAll)
authorize(DispatcherTypeRequestMatcher(DispatcherType.ERROR), permitAll)
authorize("/endpoint", permitAll)
authorize(anyRequest, denyAll)
}
}
使用 MvcRequestMatcher
通常来说,你可以像上面演示的那样使用 requestMatchers(String)
。
但是,如果你将 Spring MVC 映射到不同的 servlet 路径,那么你需要在安全配置中考虑到这一点。
例如,如果 Spring MVC 映射到 /spring-mvc
而不是 /
(默认值),那么你可能有一个像 /spring-mvc/my/controller
这样的端点,你想对其进行授权。
你需要使用 MvcRequestMatcher
在配置中分离 servlet 路径和 controller 路径,如下所示
-
Java
-
Kotlin
-
Xml
@Bean
MvcRequestMatcher.Builder mvc(HandlerMappingIntrospector introspector) {
return new MvcRequestMatcher.Builder(introspector).servletPath("/spring-mvc");
}
@Bean
SecurityFilterChain appEndpoints(HttpSecurity http, MvcRequestMatcher.Builder mvc) {
http
.authorizeHttpRequests((authorize) -> authorize
.requestMatchers(mvc.pattern("/my/controller/**")).hasAuthority("controller")
.anyRequest().authenticated()
);
return http.build();
}
@Bean
fun mvc(introspector: HandlerMappingIntrospector): MvcRequestMatcher.Builder =
MvcRequestMatcher.Builder(introspector).servletPath("/spring-mvc");
@Bean
fun appEndpoints(http: HttpSecurity, mvc: MvcRequestMatcher.Builder): SecurityFilterChain =
http {
authorizeHttpRequests {
authorize(mvc.pattern("/my/controller/**"), hasAuthority("controller"))
authorize(anyRequest, authenticated)
}
}
<http>
<intercept-url servlet-path="/spring-mvc" pattern="/my/controller/**" access="hasAuthority('controller')"/>
<intercept-url pattern="/**" access="authenticated"/>
</http>
这种需求可能至少以两种不同的方式出现
-
如果你使用
spring.mvc.servlet.path
Boot 属性将默认路径 (/
) 更改为其他路径 -
如果你注册了多个 Spring MVC
DispatcherServlet
(因此要求其中一个不是默认路径)
使用自定义匹配器
此功能目前在 XML 中不受支持 |
在 Java 配置中,你可以创建自己的RequestMatcher
并将其提供给 DSL,如下所示
-
Java
-
Kotlin
RequestMatcher printview = (request) -> request.getParameter("print") != null;
http
.authorizeHttpRequests((authorize) -> authorize
.requestMatchers(printview).hasAuthority("print")
.anyRequest().authenticated()
)
val printview: RequestMatcher = { (request) -> request.getParameter("print") != null }
http {
authorizeHttpRequests {
authorize(printview, hasAuthority("print"))
authorize(anyRequest, authenticated)
}
}
因为RequestMatcher 是一个函数式接口,你可以在 DSL 中将其作为 lambda 提供。但是,如果你想从请求中提取值,则需要一个具体类,因为这需要覆盖 default 方法。 |
一旦授权,你可以使用Spring Security 的测试支持以下列方式进行测试
-
Java
@WithMockUser(authorities="print")
@Test
void printWhenPrintAuthorityThenAuthorized() {
this.mvc.perform(get("/any?print"))
.andExpect(status().isOk());
}
@WithMockUser
@Test
void printWhenNoPrintAuthorityThenForbidden() {
this.mvc.perform(get("/any?print"))
.andExpect(status().isForbidden());
}
授权请求
请求匹配后,你可以通过已见的几种方式授权它,例如 permitAll
、denyAll
和 hasAuthority
。
简单总结一下,以下是内置于 DSL 中的授权规则
-
permitAll
- 请求不需要授权,是公共端点;注意,在这种情况下,Authentication 不会从会话中检索 -
denyAll
- 在任何情况下都不允许该请求;注意,在这种情况下,Authentication 不会从会话中检索 -
hasAuthority
- 请求要求Authentication
具有与给定值匹配的GrantedAuthority
-
hasRole
-hasAuthority
的快捷方式,它会添加ROLE_
前缀或配置为默认前缀的任何内容 -
hasAnyAuthority
- 请求要求Authentication
具有与给定值中的任何一个匹配的GrantedAuthority
-
hasAnyRole
-hasAnyAuthority
的快捷方式,它会添加ROLE_
前缀或配置为默认前缀的任何内容 -
access
- 请求使用此自定义AuthorizationManager
来确定访问权限
了解了模式、规则以及它们如何配对后,你应该能够理解这个更复杂示例中发生的事情
-
Java
import static jakarta.servlet.DispatcherType.*;
import static org.springframework.security.authorization.AuthorizationManagers.allOf;
import static org.springframework.security.authorization.AuthorityAuthorizationManager.hasAuthority;
import static org.springframework.security.authorization.AuthorityAuthorizationManager.hasRole;
@Bean
SecurityFilterChain web(HttpSecurity http) throws Exception {
http
// ...
.authorizeHttpRequests(authorize -> authorize (1)
.dispatcherTypeMatchers(FORWARD, ERROR).permitAll() (2)
.requestMatchers("/static/**", "/signup", "/about").permitAll() (3)
.requestMatchers("/admin/**").hasRole("ADMIN") (4)
.requestMatchers("/db/**").access(allOf(hasAuthority("db"), hasRole("ADMIN"))) (5)
.anyRequest().denyAll() (6)
);
return http.build();
}
1 | 指定了多个授权规则。每个规则按声明顺序进行考虑。 |
2 | 允许 FORWARD 和 ERROR 转发,以允许Spring MVC渲染视图以及 Spring Boot 渲染错误 |
3 | 我们指定了任何用户都可以访问的多个 URL 模式。具体来说,如果 URL 以 "/static/" 开头、等于 "/signup" 或等于 "/about",则任何用户都可以访问请求。 |
4 | 任何以 "/admin/" 开头的 URL 将限制给具有 "ROLE_ADMIN" 角色的用户。你会注意到,由于我们调用的是 hasRole 方法,因此无需指定 "ROLE_" 前缀。 |
5 | 任何以 "/db/" 开头的 URL 都要求用户同时被授予 "db" 权限并具有 "ROLE_ADMIN" 角色。你会注意到,由于我们使用的是 hasRole 表达式,因此无需指定 "ROLE_" 前缀。 |
6 | 任何尚未匹配到的 URL 都将被拒绝访问。如果你不想意外地忘记更新授权规则,这是一个不错的策略。 |
使用 SpEL 表达授权
虽然推荐使用具体的 AuthorizationManager
,但在某些情况下,表达式是必需的,例如 <intercept-url>
或 JSP Taglibs。因此,本节将重点介绍这些领域的示例。
鉴于此,让我们更深入地了解 Spring Security 的 Web Security Authorization SpEL API。
Spring Security 将其所有授权字段和方法封装在一组根对象中。最通用的根对象称为 SecurityExpressionRoot
,它是 WebSecurityExpressionRoot
的基础。Spring Security 在准备评估授权表达式时,将此根对象提供给 StandardEvaluationContext
。
使用授权表达式字段和方法
这提供的第一件事是为你的 SpEL 表达式提供了一组增强的授权字段和方法。以下是常用方法的快速概览
-
permitAll
- 调用该请求不需要授权;注意,在这种情况下,Authentication 不会从会话中检索 -
denyAll
- 在任何情况下都不允许该请求;注意,在这种情况下,Authentication 不会从会话中检索 -
hasAuthority
- 请求要求Authentication
具有与给定值匹配的GrantedAuthority
-
hasRole
-hasAuthority
的快捷方式,它会添加ROLE_
前缀或配置为默认前缀的任何内容 -
hasAnyAuthority
- 请求要求Authentication
具有与给定值中的任何一个匹配的GrantedAuthority
-
hasAnyRole
-hasAnyAuthority
的快捷方式,它会添加ROLE_
前缀或配置为默认前缀的任何内容 -
hasPermission
- 用于执行对象级别授权的PermissionEvaluator
实例的钩子
以下是常用字段的简要介绍
-
authentication
- 与此方法调用关联的Authentication
实例 -
principal
- 与此方法调用关联的Authentication#getPrincipal
了解了模式、规则以及它们如何配对后,你应该能够理解这个更复杂示例中发生的事情
-
Xml
<http>
<intercept-url pattern="/static/**" access="permitAll"/> (1)
<intercept-url pattern="/admin/**" access="hasRole('ADMIN')"/> (2)
<intercept-url pattern="/db/**" access="hasAuthority('db') and hasRole('ADMIN')"/> (3)
<intercept-url pattern="/**" access="denyAll"/> (4)
</http>
1 | 我们指定了一个任何用户都可以访问的 URL 模式。具体来说,如果 URL 以 "/static/" 开头,则任何用户都可以访问请求。 |
2 | 任何以 "/admin/" 开头的 URL 将限制给具有 "ROLE_ADMIN" 角色的用户。你会注意到,由于我们调用的是 hasRole 方法,因此无需指定 "ROLE_" 前缀。 |
3 | 任何以 "/db/" 开头的 URL 都要求用户同时被授予 "db" 权限并具有 "ROLE_ADMIN" 角色。你会注意到,由于我们使用的是 hasRole 表达式,因此无需指定 "ROLE_" 前缀。 |
4 | 任何尚未匹配到的 URL 都将被拒绝访问。如果你不想意外地忘记更新授权规则,这是一个不错的策略。 |
使用路径参数
此外,Spring Security 提供了一种发现路径参数的机制,以便它们也可以在 SpEL 表达式中访问。
例如,你可以通过以下方式在 SpEL 表达式中访问路径参数
-
Xml
<http>
<intercept-url pattern="/resource/{name}" access="#name == authentication.name"/>
<intercept-url pattern="/**" access="authenticated"/>
</http>
该表达式引用了 /resource/
后面的路径变量,并要求它等于 Authentication#getName
。
使用授权数据库、策略代理或其他服务
如果你想配置 Spring Security 使用单独的服务进行授权,你可以创建自己的 AuthorizationManager
并将其匹配到 anyRequest
。
首先,你的 AuthorizationManager
可能看起来像这样
-
Java
@Component
public final class OpenPolicyAgentAuthorizationManager implements AuthorizationManager<RequestAuthorizationContext> {
@Override
public AuthorizationDecision check(Supplier<Authentication> authentication, RequestAuthorizationContext context) {
// make request to Open Policy Agent
}
}
然后,你可以通过以下方式将其配置到 Spring Security 中
-
Java
@Bean
SecurityFilterChain web(HttpSecurity http, AuthorizationManager<RequestAuthorizationContext> authz) throws Exception {
http
// ...
.authorizeHttpRequests((authorize) -> authorize
.anyRequest().access(authz)
);
return http.build();
}
优先使用 permitAll
而非 ignoring
当你拥有静态资源时,配置过滤器链来忽略这些值可能很诱人。更安全的方法是使用 permitAll
允许它们,如下所示
-
Java
-
Kotlin
http
.authorizeHttpRequests((authorize) -> authorize
.requestMatchers("/css/**").permitAll()
.anyRequest().authenticated()
)
http {
authorizeHttpRequests {
authorize("/css/**", permitAll)
authorize(anyRequest, authenticated)
}
}
这更安全,因为即使对于静态资源,编写安全头也很重要,如果请求被忽略,Spring Security 将无法做到这一点。
过去,这会带来性能折衷,因为 Spring Security 在每个请求上都会查询会话。然而,自 Spring Security 6 起,除非授权规则要求,否则不再查询会话。由于性能影响现已解决,Spring Security 建议对所有请求至少使用 permitAll
。
从 authorizeRequests
迁移
AuthorizationFilter 取代了FilterSecurityInterceptor 。为了保持向后兼容,FilterSecurityInterceptor 仍然是默认值。本节讨论 AuthorizationFilter 的工作原理以及如何覆盖默认配置。 |
AuthorizationFilter
为 HttpServletRequest
提供授权。它被插入到FilterChainProxy中,作为安全过滤器之一。
声明 SecurityFilterChain
时,你可以覆盖默认值。不要使用authorizeRequests,而是使用 authorizeHttpRequests
,如下所示
-
Java
@Bean
SecurityFilterChain web(HttpSecurity http) throws AuthenticationException {
http
.authorizeHttpRequests((authorize) -> authorize
.anyRequest().authenticated();
)
// ...
return http.build();
}
这在许多方面改进了 authorizeRequests
-
使用简化的
AuthorizationManager
API,而不是元数据源、配置属性、决策管理器和投票器。这简化了重用和自定义。 -
延迟
Authentication
查找。不再需要在每个请求中查找认证,而只在授权决策需要认证的请求中查找。 -
基于 Bean 的配置支持。
当使用 authorizeHttpRequests
而不是 authorizeRequests
时,使用AuthorizationFilter
而不是FilterSecurityInterceptor
。
迁移表达式
在可能的情况下,建议使用类型安全的授权管理器而不是 SpEL。对于 Java 配置,可以使用WebExpressionAuthorizationManager
来帮助迁移遗留的 SpEL。
要使用 WebExpressionAuthorizationManager
,你可以使用你想要迁移的表达式构造一个,如下所示
-
Java
-
Kotlin
.requestMatchers("/test/**").access(new WebExpressionAuthorizationManager("hasRole('ADMIN') && hasRole('USER')"))
.requestMatchers("/test/**").access(WebExpressionAuthorizationManager("hasRole('ADMIN') && hasRole('USER')"))
如果你在表达式中引用一个 bean,例如:@webSecurity.check(authentication, request)
,建议你直接调用该 bean,如下所示
-
Java
-
Kotlin
.requestMatchers("/test/**").access((authentication, context) ->
new AuthorizationDecision(webSecurity.check(authentication.get(), context.getRequest())))
.requestMatchers("/test/**").access((authentication, context): AuthorizationManager<RequestAuthorizationContext> ->
AuthorizationDecision(webSecurity.check(authentication.get(), context.getRequest())))
对于包含 bean 引用以及其他表达式的复杂指令,建议你将其更改为实现 AuthorizationManager
并通过调用 .access(AuthorizationManager)
来引用它们。
如果无法做到这一点,你可以配置一个带有 bean 解析器的DefaultHttpSecurityExpressionHandler
,并将其提供给 WebExpressionAuthorizationManager#setExpressionhandler
。
安全匹配器
RequestMatcher
接口用于确定请求是否匹配给定的规则。我们使用 securityMatchers
来确定给定的HttpSecurity
是否应应用于给定的请求。同样地,我们可以使用 requestMatchers
来确定应应用于给定请求的授权规则。看以下示例
-
Java
-
Kotlin
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
.securityMatcher("/api/**") (1)
.authorizeHttpRequests(authorize -> authorize
.requestMatchers("/api/user/**").hasRole("USER") (2)
.requestMatchers("/api/admin/**").hasRole("ADMIN") (3)
.anyRequest().authenticated() (4)
)
.formLogin(withDefaults());
return http.build();
}
}
@Configuration
@EnableWebSecurity
open class SecurityConfig {
@Bean
open fun web(http: HttpSecurity): SecurityFilterChain {
http {
securityMatcher("/api/**") (1)
authorizeHttpRequests {
authorize("/api/user/**", hasRole("USER")) (2)
authorize("/api/admin/**", hasRole("ADMIN")) (3)
authorize(anyRequest, authenticated) (4)
}
}
return http.build()
}
}
1 | 配置 HttpSecurity 仅应用于以 /api/ 开头的 URL |
2 | 允许具有 USER 角色的用户访问以 /api/user/ 开头的 URL |
3 | 允许具有 ADMIN 角色的用户访问以 /api/admin/ 开头的 URL |
4 | 任何不匹配上述规则的其他请求都将需要认证 |
securityMatcher(s)
和 requestMatcher(s)
方法将决定哪种 RequestMatcher
实现最适合您的应用:如果在类路径中有 Spring MVC,则将使用 MvcRequestMatcher
,否则将使用 AntPathRequestMatcher
。您可以在此处阅读更多关于 Spring MVC 集成的信息。
如果您想使用特定的 RequestMatcher
,只需将实现传递给 securityMatcher
和/或 requestMatcher
方法即可
-
Java
-
Kotlin
import static org.springframework.security.web.util.matcher.AntPathRequestMatcher.antMatcher; (1)
import static org.springframework.security.web.util.matcher.RegexRequestMatcher.regexMatcher;
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
.securityMatcher(antMatcher("/api/**")) (2)
.authorizeHttpRequests(authorize -> authorize
.requestMatchers(antMatcher("/api/user/**")).hasRole("USER") (3)
.requestMatchers(regexMatcher("/api/admin/.*")).hasRole("ADMIN") (4)
.requestMatchers(new MyCustomRequestMatcher()).hasRole("SUPERVISOR") (5)
.anyRequest().authenticated()
)
.formLogin(withDefaults());
return http.build();
}
}
public class MyCustomRequestMatcher implements RequestMatcher {
@Override
public boolean matches(HttpServletRequest request) {
// ...
}
}
import org.springframework.security.web.util.matcher.AntPathRequestMatcher.antMatcher (1)
import org.springframework.security.web.util.matcher.RegexRequestMatcher.regexMatcher
@Configuration
@EnableWebSecurity
open class SecurityConfig {
@Bean
open fun web(http: HttpSecurity): SecurityFilterChain {
http {
securityMatcher(antMatcher("/api/**")) (2)
authorizeHttpRequests {
authorize(antMatcher("/api/user/**"), hasRole("USER")) (3)
authorize(regexMatcher("/api/admin/**"), hasRole("ADMIN")) (4)
authorize(MyCustomRequestMatcher(), hasRole("SUPERVISOR")) (5)
authorize(anyRequest, authenticated)
}
}
return http.build()
}
}
1 | 导入 AntPathRequestMatcher 和 RegexRequestMatcher 中的静态工厂方法来创建 RequestMatcher 实例。 |
2 | 配置 HttpSecurity 以仅应用于以 /api/ 开头的 URL,使用 AntPathRequestMatcher |
3 | 允许具有 USER 角色的用户访问以 /api/user/ 开头的 URL,使用 AntPathRequestMatcher |
4 | 允许具有 ADMIN 角色的用户访问以 /api/admin/ 开头的 URL,使用 RegexRequestMatcher |
5 | 允许具有 SUPERVISOR 角色的用户访问与 MyCustomRequestMatcher 匹配的 URL,使用自定义的 RequestMatcher |