对于最新的稳定版本,请使用 Spring Security 6.4.1spring-doc.cn

EnableReactiveMethodSecurity

Spring Security 使用 Reactor 的 Context 支持方法安全性,该上下文是使用 . 例如,这演示了如何检索当前登录用户的消息。ReactiveSecurityContextHolderspring-doc.cn

为此,方法的返回类型必须是 a (例如 /)。 这是与 Reactor 的 .org.reactivestreams.PublisherMonoFluxContextspring-doc.cn

EnableReactiveMethodSecurity 与 AuthorizationManager

在 Spring Security 5.8 中,我们可以在任何实例上使用 Comments 来启用基于 Comments 的安全性。@EnableReactiveMethodSecurity(useAuthorizationManager=true)@Configurationspring-doc.cn

这在许多方面都有所改进。:@EnableReactiveMethodSecurity@EnableReactiveMethodSecurity(useAuthorizationManager=true)spring-doc.cn

  1. 使用简化的 API,而不是元数据源、配置属性、决策管理器和投票者。 这简化了重用和定制。AuthorizationManagerspring-doc.cn

  2. 支持响应式返回类型。请注意,在添加协程支持之前,我们正在等待 Spring Framework 的其他协程支持spring-doc.cn

  3. 使用原生 Spring AOP 构建,去除抽象并允许您使用 Spring AOP 构建块进行自定义spring-doc.cn

  4. 检查冲突的注释以确保安全配置明确spring-doc.cn

  5. 符合 JSR-250spring-doc.cn

对于早期版本,请阅读 @EnableReactiveMethodSecurity 的类似支持。spring-doc.cn

例如,以下内容将启用 Spring Security 的 Comments:@PreAuthorizespring-doc.cn

方法安全配置
@EnableReactiveMethodSecurity(useAuthorizationManager=true)
public class MethodSecurityConfig {
	// ...
}

然后,向方法添加注释(在类或接口上)将相应地限制对该方法的访问。 Spring Security 的本机 Comments 支持为该方法定义了一组属性。 这些将被传递给各种方法拦截器,例如 ,以便它做出实际的决定:AuthorizationManagerBeforeReactiveMethodInterceptorspring-doc.cn

方法安全注释用法
public interface BankService {
	@PreAuthorize("hasRole('USER')")
	Mono<Account> readAccount(Long id);

	@PreAuthorize("hasRole('USER')")
	Flux<Account> findAccounts();

	@PreAuthorize("@func.apply(#account)")
	Mono<Account> post(Account account, Double amount);
}

在这种情况下,指的是 SPEL 评估引擎调用的方法。hasRoleSecurityExpressionRootspring-doc.cn

@bean引用您定义的自定义组件,其中 can return 或 to 指示授权决策。 像这样的 bean 可能看起来像这样:applyBooleanMono<Boolean>spring-doc.cn

方法 安全性 反应式布尔表达式
@Bean
public Function<Account, Mono<Boolean>> func() {
    return (account) -> Mono.defer(() -> Mono.just(account.getId().equals(12)));
}

自定义授权

Spring Security 的 、 、 和 附带 具有丰富的基于表达式的支持。@PreAuthorize@PostAuthorize@PreFilter@PostFilterspring-doc.cn

此外,对于基于角色的授权,Spring Security 会添加一个默认前缀,该前缀在计算 . 您可以通过公开 bean 来配置授权规则以使用不同的前缀,如下所示:ROLE_hasRoleGrantedAuthorityDefaultsspring-doc.cn

自定义 MethodSecurityExpressionHandler
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
static GrantedAuthorityDefaults grantedAuthorityDefaults() {
	return new GrantedAuthorityDefaults("MYPREFIX_");
}

我们使用方法公开,以确保 Spring 在初始化 Spring Security 的方法安全类之前发布它。 由于 bean 是 Spring Security 内部工作的一部分,我们还应该将其公开为基础设施 bean,从而有效地避免一些与 bean 后处理相关的警告(参见 gh-14751)。GrantedAuthorityDefaultsstatic@ConfigurationGrantedAuthorityDefaultsspring-doc.cn

自定义授权管理器

方法授权是方法授权之前和方法之后授权的组合。spring-doc.cn

Before-method 授权在调用方法之前执行。 如果该授权拒绝访问,则不会调用该方法,并会引发 an。 方法后授权在调用方法之后,但在方法返回给调用方之前执行。 如果该授权拒绝访问,则不会返回该值,并会引发AccessDeniedExceptionAccessDeniedExceptionspring-doc.cn

要重新创建默认情况下添加的功能,您需要发布以下配置:@EnableReactiveMethodSecurity(useAuthorizationManager=true)spring-doc.cn

完整的 Pre-post 方法安全配置
@Configuration
class MethodSecurityConfig {
	@Bean
	BeanDefinitionRegistryPostProcessor aopConfig() {
		return AopConfigUtils::registerAutoProxyCreatorIfNecessary;
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	PreFilterAuthorizationReactiveMethodInterceptor preFilterInterceptor() {
		return new PreFilterAuthorizationReactiveMethodInterceptor();
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	AuthorizationManagerBeforeReactiveMethodInterceptor preAuthorizeInterceptor() {
		return AuthorizationManagerBeforeReactiveMethodInterceptor.preAuthorize();
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	AuthorizationManagerAfterReactiveMethodInterceptor postAuthorizeInterceptor() {
		return AuthorizationManagerAfterReactiveMethodInterceptor.postAuthorize();
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	PostFilterAuthorizationReactiveMethodInterceptor postFilterInterceptor() {
		return new PostFilterAuthorizationReactiveMethodInterceptor();
	}
}

请注意,Spring Security 的方法安全性是使用 Spring AOP 构建的。 因此,根据指定的顺序调用拦截器。 这可以通过调用拦截器实例来自定义,如下所示:setOrderspring-doc.cn

发布自定义顾问
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
Advisor postFilterAuthorizationMethodInterceptor() {
	PostFilterAuthorizationMethodInterceptor interceptor = new PostFilterAuthorizationReactiveMethodInterceptor();
	interceptor.setOrder(AuthorizationInterceptorOrders.POST_AUTHORIZE.getOrder() - 1);
	return interceptor;
}

您可能希望仅在应用程序中提供支持,在这种情况下,您可以执行以下操作:@PreAuthorizespring-doc.cn

仅 @PreAuthorize 配置
@Configuration
class MethodSecurityConfig {
	@Bean
	BeanDefinitionRegistryPostProcessor aopConfig() {
		return AopConfigUtils::registerAutoProxyCreatorIfNecessary;
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	Advisor preAuthorize() {
		return AuthorizationManagerBeforeMethodInterceptor.preAuthorize();
	}
}

或者,您可能有一个要添加到列表中的自定义 before-method。ReactiveAuthorizationManagerspring-doc.cn

在这种情况下,您需要告诉 Spring Security 授权管理器应用了哪些方法和类。ReactiveAuthorizationManagerspring-doc.cn

因此,你可以将 Spring Security 配置为在两者之间调用你的,如下所示:ReactiveAuthorizationManager@PreAuthorize@PostAuthorizespring-doc.cn

自定义 Before Advisor
@EnableReactiveMethodSecurity(useAuthorizationManager=true)
class MethodSecurityConfig {
	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public Advisor customAuthorize() {
		JdkRegexpMethodPointcut pattern = new JdkRegexpMethodPointcut();
		pattern.setPattern("org.mycompany.myapp.service.*");
		ReactiveAuthorizationManager<MethodInvocation> rule = AuthorityAuthorizationManager.isAuthenticated();
		AuthorizationManagerBeforeReactiveMethodInterceptor interceptor = new AuthorizationManagerBeforeReactiveMethodInterceptor(pattern, rule);
		interceptor.setOrder(AuthorizationInterceptorsOrder.PRE_AUTHORIZE_ADVISOR_ORDER.getOrder() + 1);
		return interceptor;
    }
}

您可以使用中指定的 order 常量将拦截器放置在 Spring Security 方法拦截器之间。AuthorizationInterceptorsOrderspring-doc.cn

对于方法后授权,也可以执行相同的操作。 方法后授权通常涉及分析返回值以验证访问。spring-doc.cn

例如,您可能有一个方法来确认请求的帐户确实属于已登录用户,如下所示:spring-doc.cn

@PostAuthorize示例
public interface BankService {

	@PreAuthorize("hasRole('USER')")
	@PostAuthorize("returnObject.owner == authentication.name")
	Mono<Account> readAccount(Long id);
}

您可以提供自己的 API 来自定义如何评估对返回值的访问权限。AuthorizationMethodInterceptorspring-doc.cn

例如,如果您有自己的自定义注释,则可以按如下方式对其进行配置:spring-doc.cn

自定义 After Advisor
@EnableReactiveMethodSecurity(useAuthorizationManager=true)
class MethodSecurityConfig {
	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public Advisor customAuthorize(ReactiveAuthorizationManager<MethodInvocationResult> rules) {
		AnnotationMethodMatcher pattern = new AnnotationMethodMatcher(MySecurityAnnotation.class);
		AuthorizationManagerAfterReactiveMethodInterceptor interceptor = new AuthorizationManagerAfterReactiveMethodInterceptor(pattern, rules);
		interceptor.setOrder(AuthorizationInterceptorsOrder.POST_AUTHORIZE_ADVISOR_ORDER.getOrder() + 1);
		return interceptor;
	}
}

它将在拦截器之后调用。@PostAuthorizespring-doc.cn

EnableReactiveMethodSecurity

@EnableReactiveMethodSecurity还支持 Kotlin 协程,但程度有限。 拦截协程时,只有第一个拦截器参与。 如果存在任何其他拦截器,并且位于 Spring Security 的方法安全拦截器之后,则将被跳过它们spring-doc.cn

Authentication authentication = new TestingAuthenticationToken("user", "password", "ROLE_USER");

Mono<String> messageByUsername = ReactiveSecurityContextHolder.getContext()
	.map(SecurityContext::getAuthentication)
	.map(Authentication::getName)
	.flatMap(this::findMessageByUsername)
	// In a WebFlux application the `subscriberContext` is automatically setup using `ReactorContextWebFilter`
	.subscriberContext(ReactiveSecurityContextHolder.withAuthentication(authentication));

StepVerifier.create(messageByUsername)
	.expectNext("Hi user")
	.verifyComplete();
val authentication: Authentication = TestingAuthenticationToken("user", "password", "ROLE_USER")

val messageByUsername: Mono<String> = ReactiveSecurityContextHolder.getContext()
	.map(SecurityContext::getAuthentication)
	.map(Authentication::getName)
	.flatMap(this::findMessageByUsername) // In a WebFlux application the `subscriberContext` is automatically setup using `ReactorContextWebFilter`
	.subscriberContext(ReactiveSecurityContextHolder.withAuthentication(authentication))

StepVerifier.create(messageByUsername)
	.expectNext("Hi user")
	.verifyComplete()

定义为:this::findMessageByUsernamespring-doc.cn

Mono<String> findMessageByUsername(String username) {
	return Mono.just("Hi " + username);
}
fun findMessageByUsername(username: String): Mono<String> {
	return Mono.just("Hi $username")
}

以下是在响应式应用程序中使用方法安全时的最小方法安全配置。spring-doc.cn

@EnableReactiveMethodSecurity
public class SecurityConfig {
	@Bean
	public MapReactiveUserDetailsService userDetailsService() {
		User.UserBuilder userBuilder = User.withDefaultPasswordEncoder();
		UserDetails rob = userBuilder.username("rob")
			.password("rob")
			.roles("USER")
			.build();
		UserDetails admin = userBuilder.username("admin")
			.password("admin")
			.roles("USER","ADMIN")
			.build();
		return new MapReactiveUserDetailsService(rob, admin);
	}
}
@EnableReactiveMethodSecurity
class SecurityConfig {
	@Bean
	fun userDetailsService(): MapReactiveUserDetailsService {
		val userBuilder: User.UserBuilder = User.withDefaultPasswordEncoder()
		val rob = userBuilder.username("rob")
			.password("rob")
			.roles("USER")
			.build()
		val admin = userBuilder.username("admin")
			.password("admin")
			.roles("USER", "ADMIN")
			.build()
		return MapReactiveUserDetailsService(rob, admin)
	}
}

请考虑以下类:spring-doc.cn

@Component
public class HelloWorldMessageService {
	@PreAuthorize("hasRole('ADMIN')")
	public Mono<String> findMessage() {
		return Mono.just("Hello World!");
	}
}
@Component
class HelloWorldMessageService {
	@PreAuthorize("hasRole('ADMIN')")
	fun findMessage(): Mono<String> {
		return Mono.just("Hello World!")
	}
}

或者,以下使用 Kotlin 协程的类:spring-doc.cn

@Component
class HelloWorldMessageService {
    @PreAuthorize("hasRole('ADMIN')")
    suspend fun findMessage(): String {
        delay(10)
        return "Hello World!"
    }
}

结合我们上面的配置,将确保 that 仅由具有 . 请务必注意,标准方法安全性中的任何表达式都适用于 。 但是,目前我们只支持表达式的 return type of or。 这意味着表达式不能阻塞。@PreAuthorize("hasRole('ADMIN')")findByMessageADMIN@EnableReactiveMethodSecurityBooleanbooleanspring-doc.cn

WebFlux Security 集成时,Spring Security 会根据经过身份验证的用户自动建立 Reactor 上下文。spring-doc.cn

@EnableWebFluxSecurity
@EnableReactiveMethodSecurity
public class SecurityConfig {

	@Bean
	SecurityWebFilterChain springWebFilterChain(ServerHttpSecurity http) throws Exception {
		return http
			// Demonstrate that method security works
			// Best practice to use both for defense in depth
			.authorizeExchange(exchanges -> exchanges
				.anyExchange().permitAll()
			)
			.httpBasic(withDefaults())
			.build();
	}

	@Bean
	MapReactiveUserDetailsService userDetailsService() {
		User.UserBuilder userBuilder = User.withDefaultPasswordEncoder();
		UserDetails rob = userBuilder.username("rob")
			.password("rob")
			.roles("USER")
			.build();
		UserDetails admin = userBuilder.username("admin")
			.password("admin")
			.roles("USER","ADMIN")
			.build();
		return new MapReactiveUserDetailsService(rob, admin);
	}
}
@EnableWebFluxSecurity
@EnableReactiveMethodSecurity
class SecurityConfig {
	@Bean
	open fun springWebFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
		return http {
			authorizeExchange {
				authorize(anyExchange, permitAll)
			}
			httpBasic { }
		}
	}

	@Bean
	fun userDetailsService(): MapReactiveUserDetailsService {
		val userBuilder: User.UserBuilder = User.withDefaultPasswordEncoder()
		val rob = userBuilder.username("rob")
			.password("rob")
			.roles("USER")
			.build()
		val admin = userBuilder.username("admin")
			.password("admin")
			.roles("USER", "ADMIN")
			.build()
		return MapReactiveUserDetailsService(rob, admin)
	}
}

您可以在 hellowebflux-method 中找到完整的示例spring-doc.cn