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

EnableReactiveMethodSecurity

Spring Security 通过使用 Reactor 的 Context 来支持方法安全性，该 Context 由 . 以下示例显示如何检索当前登录用户的消息：ReactiveSecurityContextHolderspring-doc.cn

要使此示例正常工作，方法的返回类型必须是 a （即 a 或 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

使用简化的 API，而不是元数据源、配置属性、决策管理器和投票者。这简化了重用和定制。AuthorizationManagerspring-doc.cn
支持反应式返回类型，包括 Kotlin 协程。spring-doc.cn
使用原生 Spring AOP 构建，去除抽象并允许您使用 Spring AOP 构建块进行自定义spring-doc.cn
检查冲突的注释以确保安全配置明确spring-doc.cn
符合 JSR-250spring-doc.cn

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

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

方法安全配置

Javaspring-doc.cn

@EnableReactiveMethodSecurity(useAuthorizationManager=true)
public class MethodSecurityConfig {
	// ...
}

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

方法安全注释用法

Javaspring-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

方法安全性反应式布尔表达式

Javaspring-doc.cn

@Bean
public Function<Account, Mono<Boolean>> func() {
    return (account) -> Mono.defer(() -> Mono.just(account.getId().equals(12)));
}

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

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

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

完整的 Pre-post 方法安全配置

Javaspring-doc.cn

@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 构建的。spring-doc.cn

自定义授权

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

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

自定义 GrantedAuthorityDefaults

Javaspring-doc.cn

@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

以编程方式授权方法

如您所见，有几种方法可以使用方法安全性 SPEL 表达式指定重要的授权规则。spring-doc.cn

有多种方法可以让你的逻辑基于 Java 而不是基于 SPEL。这为整个 Java 语言提供了 use 访问权限，以提高可测试性和流控制。spring-doc.cn

在 SPEL 中使用自定义 Bean

以编程方式授权方法的第一种方法是一个两步过程。spring-doc.cn

首先，声明一个 bean，该 bean 具有一个采用如下所示的实例的方法：MethodSecurityExpressionOperationsspring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

@Component("authz")
public class AuthorizationLogic {
    public decide(MethodSecurityExpressionOperations operations): Mono<Boolean> {
        // ... authorization logic
    }
}

@Component("authz")
open class AuthorizationLogic {
    fun decide(val operations: MethodSecurityExpressionOperations): Mono<Boolean> {
        // ... authorization logic
    }
}

然后，按以下方式在 Comments 中引用该 bean：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

@Controller
public class MyController {
    @PreAuthorize("@authz.decide(#root)")
    @GetMapping("/endpoint")
    public Mono<String> endpoint() {
        // ...
    }
}

@Controller
open class MyController {
    @PreAuthorize("@authz.decide(#root)")
    @GetMapping("/endpoint")
    fun endpoint(): Mono<String> {
        // ...
    }
}

Spring Security 将为每个方法调用在该 bean 上调用给定的方法。spring-doc.cn

这样做的好处是，您的所有授权逻辑都位于一个单独的类中，该类可以独立进行单元测试和正确性验证。它还可以访问完整的 Java 语言。spring-doc.cn

除了返回 a 之外，您还可以返回以指示代码放弃做出决策。Mono<Boolean>Mono.empty()

如果要包含有关决策性质的更多信息，可以改为返回如下所示的自定义：AuthorizationDecisionspring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

@Component("authz")
public class AuthorizationLogic {
    public Mono<AuthorizationDecision> decide(MethodSecurityExpressionOperations operations) {
        // ... authorization logic
        return Mono.just(new MyAuthorizationDecision(false, details));
    }
}

@Component("authz")
open class AuthorizationLogic {
    fun decide(val operations: MethodSecurityExpressionOperations): Mono<AuthorizationDecision> {
        // ... authorization logic
        return Mono.just(MyAuthorizationDecision(false, details))
    }
}

或者抛出一个自定义实例。但请注意，返回对象是首选，因为这不会产生生成堆栈跟踪的费用。AuthorizationDeniedExceptionspring-doc.cn

然后，您可以在自定义授权结果的处理方式时访问自定义详细信息。spring-doc.cn

使用自定义授权管理器

以编程方式授权方法的第二种方法是创建自定义 AuthorizationManager。spring-doc.cn

首先，声明一个授权 Management 器实例，可能像这样：spring-doc.cn

Javaspring-doc.cn
Kotlinspring-doc.cn

@Component
public class MyPreAuthorizeAuthorizationManager implements ReactiveAuthorizationManager<MethodInvocation> {
    @Override
    public Mono<AuthorizationDecision> check(Supplier<Authentication> authentication, MethodInvocation invocation) {
        // ... authorization logic
    }

}

@Component
class MyPreAuthorizeAuthorizationManager : ReactiveAuthorizationManager<MethodInvocation> {
    override fun check(authentication: Supplier<Authentication>, invocation: MethodInvocation): Mono<AuthorizationDecision> {
        // ... authorization logic
    }

}

然后，使用与您希望它运行的时间相对应的切入点发布方法 interceptor。例如，你可以将 how 和 work 替换为：ReactiveAuthorizationManager@PreAuthorize@PostAuthorizespring-doc.cn

仅 @PreAuthorize 和 @PostAuthorize 配置

Javaspring-doc.cn
Kotlinspring-doc.cn

@Configuration
@EnableMethodSecurity(prePostEnabled = false)
class MethodSecurityConfig {
    @Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	Advisor preAuthorize(MyPreAuthorizeAuthorizationManager manager) {
		return AuthorizationManagerBeforeReactiveMethodInterceptor.preAuthorize(manager);
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	Advisor postAuthorize(MyPostAuthorizeAuthorizationManager manager) {
		return AuthorizationManagerAfterReactiveMethodInterceptor.postAuthorize(manager);
	}
}

@Configuration
@EnableMethodSecurity(prePostEnabled = false)
class MethodSecurityConfig {
   	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	fun preAuthorize(val manager: MyPreAuthorizeAuthorizationManager) : Advisor {
		return AuthorizationManagerBeforeReactiveMethodInterceptor.preAuthorize(manager)
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	fun postAuthorize(val manager: MyPostAuthorizeAuthorizationManager) : Advisor {
		return AuthorizationManagerAfterReactiveMethodInterceptor.postAuthorize(manager)
	}
}

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

自定义表达式处理

或者，第三种，您可以自定义每个 SPEL 表达式的处理方式。为此，您可以公开一个 custom ，如下所示：MethodSecurityExpressionHandlerspring-doc.cn

自定义 MethodSecurityExpressionHandler

Javaspring-doc.cn
Kotlinspring-doc.cn

@Bean
static MethodSecurityExpressionHandler methodSecurityExpressionHandler(RoleHierarchy roleHierarchy) {
	DefaultMethodSecurityExpressionHandler handler = new DefaultMethodSecurityExpressionHandler();
	handler.setRoleHierarchy(roleHierarchy);
	return handler;
}

companion object {
	@Bean
	fun methodSecurityExpressionHandler(val roleHierarchy: RoleHierarchy) : MethodSecurityExpressionHandler {
		val handler = DefaultMethodSecurityExpressionHandler()
		handler.setRoleHierarchy(roleHierarchy)
		return handler
	}
}

我们使用方法公开，以确保 Spring 在初始化 Spring Security 的方法安全类之前发布它MethodSecurityExpressionHandlerstatic@Configurationspring-doc.cn

你还可以子类DefaultMessageSecurityExpressionHandler，以添加超出默认值的自定义授权表达式。spring-doc.cn

EnableReactiveMethodSecurity

Javaspring-doc.cn
Kotlinspring-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`
	.contextWrite(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`
	.contextWrite(ReactiveSecurityContextHolder.withAuthentication(authentication))

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

其中定义为：this::findMessageByUsernamespring-doc.cn

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

Javaspring-doc.cn
Kotlinspring-doc.cn

@Configuration
@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);
	}
}

@Configuration
@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

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

Kotlinspring-doc.cn

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

结合我们上面的配置，确保 that 仅由具有该角色的用户调用。请注意，标准方法安全性中的任何表达式都适用于 . 但是，目前，我们仅支持表达式的 or 的返回类型。这意味着表达式不能阻塞。@PreAuthorize("hasRole('ADMIN')")findByMessageADMIN@EnableReactiveMethodSecurityBooleanbooleanspring-doc.cn

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

Javaspring-doc.cn
Kotlinspring-doc.cn

@Configuration
@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);
	}
}

@Configuration
@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