下一步是在 war 中注册 springSecurityFilterChain。这可以在 Servlet 3.0+ 环境中用 Spring 的 WebApplicationInitializer 支持在 Java 配置中完成。不足为奇的是，Spring Security 提供了一个基类 AbstractSecurityWebApplicationInitializer，它将确保为你注册 springSecurityFilterChain。我们使用 AbstractSecurityWebApplicationInitializer 的方式根据我们是否已经在使用 Spring 或者 Spring Security 是否是我们应用程序中唯一的 Spring 组件而不同。

如果不使用 Spring 或 Spring MVC，则需要将 WebSecurityConfig 传递到超类中，以确保获得配置。你可以在下面找到一个例子：

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

public class SecurityWebApplicationInitializer
	extends AbstractSecurityWebApplicationInitializer {

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

SecurityWebApplicationInitializer 将执行以下操作：

如果我们在应用程序中的其它地方使用 Spring，那么很可能已经有一个 WebApplicationInitializer 正在加载 Spring 配置。如果我们使用以前的配置，会得到一个错误。相反，我们应该用现有的 ApplicationContext 注册 Spring Security。例如，如果我们使用 Spring MVC，我们的 SecurityWebApplicationInitializer 看起来会像下面这样：

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

public class SecurityWebApplicationInitializer
	extends AbstractSecurityWebApplicationInitializer {

}

这只会简单地为应用程序中的每个 URL 注册 springSecurityFilterChain 过滤器。之后，我们将确保 WebSecurityConfig 加载到我们现有的 ApplicationInitializer 中。例如，如果我们使用 Spring MVC，它将被添加到 getRootConfigClasses() 中。

public class MvcWebApplicationInitializer extends
		AbstractAnnotationConfigDispatcherServletInitializer {

	@Override
	protected Class<?>[] getRootConfigClasses() {
		return new Class[] { WebSecurityConfig.class };
	}

	// ... other overrides ...
}

通常，LogoutHandler 实现标识类能够参与注销处理。它们将被要求执行必要的清理工作。因此，它们不应抛出异常。提供了各种实现方式：

更多详细信息请参阅 小节 18.4, “记住我接口和实现”。

除了直接提供 LogoutHandler 实现之外，fluent API 还提供了快捷方式，这些快捷方式提供了相应的 LogoutHandler 实现。例如，deleteCookies() 允许注销成功时指定名称删除一个或多个 Cookie。与添加 CookieClearingLogoutHandler 相比，这是一个快捷方式。

LogoutSuccessHandler 在成功注销之后被 LogoutFilter 调用，以处理例如重定向或转发到适当的目的地。请注意，该接口与 LogoutHandler 几乎相同，但可能引发异常。

提供以下实现：

如上所述，你不需要直接指定 SimpleUrlLogoutSuccessHandler。相反，fluent API 通过设置 logoutSuccessUrl() 提供快捷方式。这将在封面下建立 SimpleUrlLogoutSuccessHandler。所提供的 URL 将在注销发生后被重定向到。默认是 /login?logout。

在 REST API 类型的场景中，HttpStatusReturningLogoutSuccessHandler 可能是有趣的。这个 LogoutSuccessHandler 允许你提供要返回的普通 HTTP 状态代码，而不是在成功注销时重定向到 URL。如果未配置，默认情况下将返回状态代码 200。

你可以找到如下的最小化 WebFlux Security 配置：

@EnableWebFluxSecurity
public class HelloWebfluxSecurityConfig {

	@Bean
	public MapReactiveUserDetailsService userDetailsService() {
		UserDetails user = User.withDefaultPasswordEncoder()
			.username("user")
			.password("user")
			.roles("USER")
			.build();
		return new MapReactiveUserDetailsService(user);
	}
}

此配置提供表单和 http 基本身份验证、设置授权以要求经过身份验证的用户访问任何页面、设置默认登录页面和默认注销页面、设置与安全相关的 HTTP 报头、CSRF 保护等等。

你可以找到如下的最小化 WebFlux Security 配置的明确的版本：

@EnableWebFluxSecurity
public class HelloWebfluxSecurityConfig {

	@Bean
	public MapReactiveUserDetailsService userDetailsService() {
		UserDetails user = User.withDefaultPasswordEncoder()
			.username("user")
			.password("user")
			.roles("USER")
			.build();
		return new MapReactiveUserDetailsService(user);
	}

	@Bean
	public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
		http
			.authorizeExchange()
				.anyExchange().authenticated()
				.and()
			.httpBasic().and()
			.formLogin();
		return http.build();
	}
}

这个配置明确地设置了与我们的最小配置相同的所有东西。从这里你可以轻松地对默认值进行更改。

Spring Boot 2.0 为 OAuth 2.0 登录带来了全自动配置功能。

本节展示如何使用 Google 作为身份验证提供者来配置 OAuth 2.0 登录示例，并介绍以下主题：

初始设置

要使用 Google 的 OAuth 2.0 身份验证系统进行登录，必须在 Google API 控制台中设置项目以获得 OAuth 2.0 凭证。

	Note
	用于身份验证的 Google 的 OAuth 2.0 实现符合 OpenID Connect 1.0 规范，并且是 OpenID 认证的。

遵循 OpenID 连接页面上的说明，从设置 OAuth 2.0 开始。

在完成获取 OAuth 2.0 凭证指令之后，你应该拥有一个新的 OAuth Client，该 Client 具有由 Client ID 和 Client Secret 组成的凭证。

设置重定向 URI

重定向 URI 是应用程序中的路径，最终用户的用户代理在用 Google 进行身份验证并授予访问同意页上的 OAuth 客户端（在上一步中创建）权限之后被重定向回该路径。

在设置重定向 URI 子节中，确保授权重定向 URI 字段设置为 http://localhost:8080/login/oauth2/code/google。

	Tip
	默认的重定向 URI 模版是 {baseUrl}/login/oauth2/code/{registrationId}。registrationId 是 ClientRegistration 的唯一标识。

ClientRegistration 是用 OAuth 2.0 或 OpenID 连接 1.0 提供者注册的客户端的表示。

客户端注册保存信息，例如， 客户端 id、客户端 secret、授权授予类型、重定向 URI、范围、授权 URI、令牌 URI 和其它细节。

ClientRegistration 及其属性定义如下：

public final class ClientRegistration {
	private String registrationId;	
	private String clientId;	
	private String clientSecret;	
	private ClientAuthenticationMethod clientAuthenticationMethod;	
	private AuthorizationGrantType authorizationGrantType;	
	private String redirectUriTemplate;	
	private Set<String> scopes;	
	private ProviderDetails providerDetails;
	private String clientName;	

	public class ProviderDetails {
		private String authorizationUri;	
		private String tokenUri;	
		private UserInfoEndpoint userInfoEndpoint;
		private String jwkSetUri;	

		public class UserInfoEndpoint {
			private String uri;	
			private String userNameAttributeName;	

		}
	}
}

下表概述了 Spring Boot 2.0 OAuth Client 属性到 ClientRegistration 属性的映射。

ClientRegistrationRepository 作为 OAuth 2.0 / OpenID Connect 1.0 ClientRegistration 的存储库.

	Note
	客户端注册信息最终由关联的授权服务器存储和拥有。该存储库提供检索主客户端注册信息的子集的能力，该子集存储在授权服务器中。

Spring Boot 2.0 自动配置将 spring.security.oauth2.client.registration.[registrationId] 下的每一个属性都绑定到 ClientRegistration 实例，然后在 ClientRegistrationRepository 中组成每个 ClientRegistration 实例。

	Note
	ClientRegistrationRepository 的默认实现是 InMemoryClientRegistrationRepository。

自动配置也将 ClientRegistrationRepository 注册为应用程序上下文中的一个 @Bean，因此，当应用程序需要时，它也可以用于依赖注入，

下面的列表展示了一个示例：

@Controller
public class OAuth2LoginController {

	@Autowired
	private ClientRegistrationRepository clientRegistrationRepository;

	@RequestMapping("/")
	public String index() {
		ClientRegistration googleRegistration =
			this.clientRegistrationRepository.findByRegistrationId("google");

		...

		return "index";
	}
}

CommonOAuth2Provider 预先定义了一组默认的客户端属性给许多著名的提供者：Google、GitHub、Facebook 和 Okta。

例如，authorization-uri、token-uri 和 user-info-uri 不常为提供者改变。因此，提供默认值以减少所需配置是有意义的。

如前所述，当配置 Google 客户端时，只需要 client-id 和 client-secret 属性。

下面的列表展示了一个示例：

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: google-client-id
            client-secret: google-client-secret

	Tip
	客户端属性的自动默认在这里无缝地工作，因为 registrationId (google)与 CommonOAuth2Provider 中的 GOOGLE 枚举（区分大小写）匹配。

对于可能需要指定不同的 registrationId（例如 google-login）的情况，仍然可以通过配置提供者属性来利用客户端属性的自动默认值。

下面的列表展示了一个示例：

spring:
  security:
    oauth2:
      client:
        registration:
          google-login:	
            provider: google	
            client-id: google-client-id
            client-secret: google-client-secret

有一些 OAuth 2.0 提供者支持多租户，这导致每个租户（或子域）具有不同的协议端点。

例如，OAuth 客户端使用 Okta 注册，会被分配到指定的子域，并具有不同的协议端点。

对于这些情况，Spring Boot 2.0 提供了用于配置自定义提供程序属性的下列基本属性：spring.security.oauth2.client.provider.[providerId]。

下面的列表展示了一个示例：

spring:
  security:
    oauth2:
      client:
        registration:
          okta:
            client-id: okta-client-id
            client-secret: okta-client-secret
        provider:
          okta:	
            authorization-uri: https://your-subdomain.oktapreview.com/oauth2/v1/authorize
            token-uri: https://your-subdomain.oktapreview.com/oauth2/v1/token
            user-info-uri: https://your-subdomain.oktapreview.com/oauth2/v1/userinfo
            user-name-attribute: sub
            jwk-set-uri: https://your-subdomain.oktapreview.com/oauth2/v1/keys

用于 OAuth Client 支持的 Spring Boot 2.0 自动配置类是 OAuth2ClientAutoConfiguration。

它执行以下任务：

如果你需要根据你的具体要求重写自动配置，你可以这样做：

@Configuration
public class OAuth2LoginConfig {

	@Bean
	public ClientRegistrationRepository clientRegistrationRepository() {
		return new InMemoryClientRegistrationRepository(this.googleClientRegistration());
	}

	private ClientRegistration googleClientRegistration() {
		return ClientRegistration.withRegistrationId("google")
			.clientId("google-client-id")
			.clientSecret("google-client-secret")
			.clientAuthenticationMethod(ClientAuthenticationMethod.BASIC)
			.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
			.redirectUriTemplate("{baseUrl}/login/oauth2/code/{registrationId}")
			.scope("openid", "profile", "email", "address", "phone")
			.authorizationUri("https://accounts.google.com/o/oauth2/v2/auth")
			.tokenUri("https://www.googleapis.com/oauth2/v4/token")
			.userInfoUri("https://www.googleapis.com/oauth2/v3/userinfo")
			.userNameAttributeName(IdTokenClaimNames.SUB)
			.jwkSetUri("https://www.googleapis.com/oauth2/v3/certs")
			.clientName("Google")
			.build();
	}
}

@EnableWebSecurity
public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {

	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http
			.authorizeRequests()
				.anyRequest().authenticated()
				.and()
			.oauth2Login();
	}
}

@Configuration
public class OAuth2LoginConfig {

	@EnableWebSecurity
	public static class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {

		@Override
		protected void configure(HttpSecurity http) throws Exception {
			http
				.authorizeRequests()
					.anyRequest().authenticated()
					.and()
				.oauth2Login();
		}
	}

	@Bean
	public ClientRegistrationRepository clientRegistrationRepository() {
		return new InMemoryClientRegistrationRepository(this.googleClientRegistration());
	}

	private ClientRegistration googleClientRegistration() {
		return ClientRegistration.withRegistrationId("google")
			.clientId("google-client-id")
			.clientSecret("google-client-secret")
			.clientAuthenticationMethod(ClientAuthenticationMethod.BASIC)
			.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
			.redirectUriTemplate("{baseUrl}/login/oauth2/code/{registrationId}")
			.scope("openid", "profile", "email", "address", "phone")
			.authorizationUri("https://accounts.google.com/o/oauth2/v2/auth")
			.tokenUri("https://www.googleapis.com/oauth2/v4/token")
			.userInfoUri("https://www.googleapis.com/oauth2/v3/userinfo")
			.userNameAttributeName(IdTokenClaimNames.SUB)
			.jwkSetUri("https://www.googleapis.com/oauth2/v3/certs")
			.clientName("Google")
			.build();
	}
}

如果不能使用 Spring Boot 2.0，并且希望配置 CommonOAuth2Provider（例如，Google）中的一个预定义提供者，则应用以下配置：

@Configuration
public class OAuth2LoginConfig {

	@EnableWebSecurity
	public static class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {

		@Override
		protected void configure(HttpSecurity http) throws Exception {
			http
				.authorizeRequests()
					.anyRequest().authenticated()
					.and()
				.oauth2Login();
		}
	}

	@Bean
	public ClientRegistrationRepository clientRegistrationRepository() {
		return new InMemoryClientRegistrationRepository(this.googleClientRegistration());
	}

	@Bean
	public OAuth2AuthorizedClientService authorizedClientService() {
		return new InMemoryOAuth2AuthorizedClientService(this.clientRegistrationRepository());
	}

	private ClientRegistration googleClientRegistration() {
		return CommonOAuth2Provider.GOOGLE.getBuilder("google")
			.clientId("google-client-id")
			.clientSecret("google-client-secret")
			.build();
	}
}

OAuth2AuthorizedClient 是授权客户端的表现。当最终用户（资源所有者）授权客户端访问其受保护的资源时，客户端被认为是被授权的。

OAuth2AuthorizedClient 用于将 OAuth2AccessToken 与 ClientRegistration（客户端）和资源所有者相关联，后者是授予授权的主要最终用户。

OAuth2AuthorizedClientService 的主要作用是管理 OAuth2AuthorizedClient 实例。从开发人员的角度来看，它提供了查找与客户端关联的 OAuth2AccessToken 的能力，以便可用于发起对资源服务器的请求。

	Note
	Spring Boot 2.0 自动配置在应用程序上下文中注册 OAuth2AuthorizedClientService @Bean。

开发人员还可以在应用程序上下文中注册 OAuth2AuthorizedClientService @Bean（覆盖 Spring Boot 2.0 自动配置），以便能够查找与特定 ClientRegistration（客户端）相关联的 OAuth2AccessToken。

下面的列表展示了一个示例：

@Controller
public class OAuth2LoginController {

	@Autowired
	private OAuth2AuthorizedClientService authorizedClientService;

	@RequestMapping("/userinfo")
	public String userinfo(OAuth2AuthenticationToken authentication) {
		// authentication.getAuthorizedClientRegistrationId() returns the
		// registrationId of the Client that was authorized during the Login flow
		OAuth2AuthorizedClient authorizedClient =
			this.authorizedClientService.loadAuthorizedClient(
				authentication.getAuthorizedClientRegistrationId(),
				authentication.getName());

		OAuth2AccessToken accessToken = authorizedClient.getAccessToken();

		...

		return "userinfo";
	}
}

下面的附加资源描述高级配置选项：

我们已经看到了为单个用户配置内存中的身份验证的示例。下面是配置多个用户的示例：

@Bean
public UserDetailsService userDetailsService() throws Exception {
	// ensure the passwords are encoded properly
	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;
}

你可以找到更新以支持基于 JDBC 的身份验证。下面的示例假定你已经在应用程序中定义了数据源。jdbc-javaconfig 示例提供了使用基于 JDBC 的身份验证的完整示例。

@Autowired
private DataSource dataSource;

@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
	// ensure the passwords are encoded properly
	UserBuilder users = User.withDefaultPasswordEncoder();
	auth
		.jdbcAuthentication()
			.dataSource(dataSource)
			.withDefaultSchema()
			.withUser(users.username("user").password("password").roles("USER"))
			.withUser(users.username("admin").password("password").roles("USER","ADMIN"));
}

你可以找到更新以支持基于 LDAP 的身份验证。ldap-javaconfig 示例提供了使用基于 LDAP 的身份验证的完整示例。

@Autowired
private DataSource dataSource;

@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
	auth
		.ldapAuthentication()
			.userDnPatterns("uid={0},ou=people")
			.groupSearchBase("ou=groups");
}

上面的例子使用了下面的 LDIF 和一个嵌入式 Apache DS LDAP 实例。

users.ldif. 

dn: ou=groups,dc=springframework,dc=org
objectclass: top
objectclass: organizationalUnit
ou: groups

dn: ou=people,dc=springframework,dc=org
objectclass: top
objectclass: organizationalUnit
ou: people

dn: uid=admin,ou=people,dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: Rod Johnson
sn: Johnson
uid: admin
userPassword: password

dn: uid=user,ou=people,dc=springframework,dc=org
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: Dianne Emu
sn: Emu
uid: user
userPassword: password

dn: cn=user,ou=groups,dc=springframework,dc=org
objectclass: top
objectclass: groupOfNames
cn: user
uniqueMember: uid=admin,ou=people,dc=springframework,dc=org
uniqueMember: uid=user,ou=people,dc=springframework,dc=org

dn: cn=admin,ou=groups,dc=springframework,dc=org
objectclass: top
objectclass: groupOfNames
cn: admin
uniqueMember: uid=admin,ou=people,dc=springframework,dc=org

你可以通过将自定义 AuthenticationProvider 暴露为 bean 来定义自定义身份验证。例如，假设 SpringAuthenticationProvider 实现 AuthenticationProvider，以下将自定义身份验证：

	Note
	这仅在 AuthenticationManagerBuilder 尚未被填充时使用。

@Bean
public SpringAuthenticationProvider springAuthenticationProvider() {
	return new SpringAuthenticationProvider();
}

您可以通过将自定义 UserDetailsService 暴露为 bean 来定义自定义身份验证。例如，假设 SpringDataUserDetailsService 实现 UserDetailsService，以下将自定义身份验证：

	Note
	这仅在 AuthenticationManagerBuilder 尚未被填充以及没有 AuthenticationProviderBean 被定义时使用。

@Bean
public SpringDataUserDetailsService springDataUserDetailsService() {
	return new SpringDataUserDetailsService();
}

还可以通过将 PasswordEncoder 作为 bean 来公开自定义密码是如何编码的。例如，如果使用 bcrypt，可以添加如下定义的 bean 定义：

@Bean
public BCryptPasswordEncoder passwordEncoder() {
	return new BCryptPasswordEncoder();
}

我们可以在任何 @Configuration 实例上使用 @EnableGlobalMethodSecurity 注解启用基于注解的安全性。例如，下面将启用 Spring Security 的 @Secured 注解。

@EnableGlobalMethodSecurity(securedEnabled = true)
public class MethodSecurityConfig {
// ...
}

将注解添加到方法（在类或接口上）将相应地限制对该方法的访问。Spring Security 的本机注解支持定义了该方法的一组属性。这些将传递给 AccessDecisionManager，以便它做出实际决策：

public interface BankService {

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
public Account readAccount(Long id);

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
public Account[] findAccounts();

@Secured("ROLE_TELLER")
public Account post(Account account, double amount);
}

JSR-250 注解的支持可以使用

@EnableGlobalMethodSecurity(jsr250Enabled = true)
public class MethodSecurityConfig {
// ...
}

这些是基于标准的，并且允许应用简单的基于角色的约束，但是没有强大的 Spring Security 的本地注释。若要使用基于表达式的新语法，将使用

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig {
// ...
}

和等效 Java 代码将是

public interface BankService {

@PreAuthorize("isAnonymous()")
public Account readAccount(Long id);

@PreAuthorize("isAnonymous()")
public Account[] findAccounts();

@PreAuthorize("hasAuthority('ROLE_TELLER')")
public Account post(Account account, double amount);
}

有时，你可能需要执行比使用 @EnableGlobalMethodSecurity 注解允许的更复杂的操作。对于这些实例，可以扩展 GlobalMethodSecurityConfiguration，以确保子类中存在 @EnableGlobalMethodSecurity 注解。例如，如果你想提供自定义 MethodSecurityExpressionHandler，可以使用以下配置：

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
	@Override
	protected MethodSecurityExpressionHandler createExpressionHandler() {
		// ... create and return custom MethodSecurityExpressionHandler ...
		return expressionHandler;
	}
}

有关可以重写的方法的其它信息，请参阅 GlobalMethodSecurityConfiguration Javadoc。

Spring Security 使用 Reactor 的上下文支持方法安全，它设置使用 ReactiveSecurityContextHolder。例如，这里展示了如何检索当前登录的用户的消息。

	Note
	为此，该方法的返回类型必须是 org.reactivestreams.Publisher（即 Mono/Flux）。这是必要的，以整合的 Reactor 的上下文。

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();

这一 this::findMessageByUsername 定义为：

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

下面是在应用程序中使用方法安全时的最小方法安全配置。

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

考虑下面的类：

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

结合上面的配置，@PreAuthorize("hasRole('ADMIN')") 将确保 findByMessage 仅由具有 ADMIN 角色的用户调用。重要的是要注意，在标准方法安全工作中的任何表达式都是用于 @EnableReactiveMethodSecurity的。但是，此时我们只支持表达式的 Boolean 或布尔型的返回类型。这意味着表达式不能阻止。

当与 小节 5.6, “WebFlux Security” 集成时，根据认证的用户，通过 Spring Security 自动建立 Reactor 上下文。

@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()
				.anyExchange().permitAll()
				.and()
			.httpBasic().and()
			.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);
	}
}

你可以在 hellowebflux-method 中找到一个完整的示例。