今天試著來和大家捋一遍 Spring Security 的初始化流程。

在 Spring Boot 中，Spring Security 的初始化，我們就從自動化配置開始分析吧！

1.SecurityAutoConfiguration

Spring Security 的自動化配置類是 SecurityAutoConfiguration，我們就從這個配置類開始分析。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(DefaultAuthenticationEventPublisher.class)
@EnableConfigurationProperties(SecurityProperties.class)
@Import({ SpringBootWebSecurityConfiguration.class, WebSecurityEnablerConfiguration.class,
  SecurityDataConfiguration.class })
public class SecurityAutoConfiguration {

 @Bean
 @ConditionalOnMissingBean(AuthenticationEventPublisher.class)
 public DefaultAuthenticationEventPublisher authenticationEventPublisher(ApplicationEventPublisher publisher) {
  return new DefaultAuthenticationEventPublisher(publisher);
 }

}

這個 Bean 中，定義了一個事件發布器。另外導入了三個配置：

1. SpringBootWebSecurityConfiguration：這個配置的作用是在如果開發者沒有自定義 WebSecurityConfigurerAdapter 的話，這里提供一個默認的實現。
2. WebSecurityEnablerConfiguration：這個配置是 Spring Security 的核心配置，也將是我們分析的重點。
3. SecurityDataConfiguration：提供了 Spring Security 整合 Spring Data 的支持，由于國內使用 MyBatis 較多，所以這個配置發光發熱的場景有限。

2.WebSecurityEnablerConfiguration

接著來看上面出現的 WebSecurityEnablerConfiguration：

@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(WebSecurityConfigurerAdapter.class)
@ConditionalOnMissingBean(name = BeanIds.SPRING_SECURITY_FILTER_CHAIN)
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
@EnableWebSecurity
public class WebSecurityEnablerConfiguration {

}

這個配置倒沒啥可說的，給了一堆生效條件，最終給出了一個 @EnableWebSecurity 注解，看來初始化重任落在 @EnableWebSecurity 注解身上了。

3.@EnableWebSecurity

@Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
@Target(value = { java.lang.annotation.ElementType.TYPE })
@Documented
@Import({ WebSecurityConfiguration.class,
  SpringWebMvcImportSelector.class,
  OAuth3ImportSelector.class })
@EnableGlobalAuthentication
@Configuration
public @interface EnableWebSecurity {

 /**
  * Controls debugging support for Spring Security. Default is false.
  * @return if true, enables debug support with Spring Security
  */
 boolean debug() default false;
}

@EnableWebSecurity 所做的事情，有兩件比較重要：

1. 導入 WebSecurityConfiguration 配置。
2. 通過 @EnableGlobalAuthentication 注解引入全局配置。

3.1 WebSecurityConfiguration

WebSecurityConfiguration 類實現了兩個接口，我們來分別看下：

public class WebSecurityConfiguration implements ImportAware, BeanClassLoaderAware {
}

ImportAware 接口和 @Import 注解一起使用的。實現了 ImportAware 接口的配置類可以方便的通過 setImportMetadata 方法獲取到導入類中的數據配置。

可能有點繞，我再梳理下，就是 WebSecurityConfiguration 實現了 ImportAware 接口，使用 @Import 注解在 @EnableWebSecurity 上導入 WebSecurityConfiguration 之后，在 WebSecurityConfiguration 的 setImportMetadata 方法中可以方便的獲取到 @EnableWebSecurity 中的屬性值，這里主要是 debug 屬性。

我們來看下 WebSecurityConfiguration#setImportMetadata 方法：

public void setImportMetadata(AnnotationMetadata importMetadata) {
 Map<String, Object> enableWebSecurityAttrMap = importMetadata
   .getAnnotationAttributes(EnableWebSecurity.class.getName());
 AnnotationAttributes enableWebSecurityAttrs = AnnotationAttributes
   .fromMap(enableWebSecurityAttrMap);
 debugEnabled = enableWebSecurityAttrs.getBoolean("debug");
 if (webSecurity != null) {
  webSecurity.debug(debugEnabled);
 }
}

獲取到 debug 屬性賦值給 WebSecurity。

實現 BeanClassLoaderAware 接口則是為了方便的獲取 ClassLoader。

這是 WebSecurityConfiguration 實現的兩個接口。

在 WebSecurityConfiguration 內部定義的 Bean 中，最為重要的是兩個方法：

1. springSecurityFilterChain 該方法目的是為了獲取過濾器鏈。
2. setFilterChainProxySecurityConfigurer 這個方法是為了收集配置類并創建 WebSecurity。

這兩個方法是核心，我們來逐一分析，先來看 setFilterChainProxySecurityConfigurer：

@Autowired(required = false)
public void setFilterChainProxySecurityConfigurer(
  ObjectPostProcessor<Object> objectPostProcessor,
  @Value("#{@autowiredWebSecurityConfigurersIgnoreParents.getWebSecurityConfigurers()}") List<SecurityConfigurer<Filter, WebSecurity>> webSecurityConfigurers)
  throws Exception {
 webSecurity = objectPostProcessor
   .postProcess(new WebSecurity(objectPostProcessor));
 if (debugEnabled != null) {
  webSecurity.debug(debugEnabled);
 }
 webSecurityConfigurers.sort(AnnotationAwareOrderComparator.INSTANCE);
 Integer previousOrder = null;
 Object previousConfig = null;
 for (SecurityConfigurer<Filter, WebSecurity> config : webSecurityConfigurers) {
  Integer order = AnnotationAwareOrderComparator.lookupOrder(config);
  if (previousOrder != null && previousOrder.equals(order)) {
   throw new IllegalStateException(
     "@Order on WebSecurityConfigurers must be unique. Order of "
       + order + " was already used on " + previousConfig + ", so it cannot be used on "
       + config + " too.");
  }
  previousOrder = order;
  previousConfig = config;
 }
 for (SecurityConfigurer<Filter, WebSecurity> webSecurityConfigurer : webSecurityConfigurers) {
  webSecurity.apply(webSecurityConfigurer);
 }
 this.webSecurityConfigurers = webSecurityConfigurers;
}

首先這個方法有兩個參數，兩個參數都會自動進行注入，第一個參數 ObjectPostProcessor 是一個后置處理器，默認的實現是 AutowireBeanFactoryObjectPostProcessor，主要是為了將 new 出來的對象注入到 Spring 容器中（參見深入理解 SecurityConfigurer 【源碼篇】）。

第二個參數 webSecurityConfigurers 是一個集合，這個集合里存放的都是 SecurityConfigurer，我們前面分析的過濾器鏈中過濾器的配置器，包括 WebSecurityConfigurerAdapter 的子類，都是 SecurityConfigurer 的實現類。根據 @Value 注解中的描述，我們可以知道，這個集合中的數據來自 autowiredWebSecurityConfigurersIgnoreParents.getWebSecurityConfigurers() 方法。

在 WebSecurityConfiguration 中定義了該實例：

@Bean
public static AutowiredWebSecurityConfigurersIgnoreParents autowiredWebSecurityConfigurersIgnoreParents(
  ConfigurableListableBeanFactory beanFactory) {
 return new AutowiredWebSecurityConfigurersIgnoreParents(beanFactory);
}

它的 getWebSecurityConfigurers 方法我們來看下：

public List<SecurityConfigurer<Filter, WebSecurity>> getWebSecurityConfigurers() {
 List<SecurityConfigurer<Filter, WebSecurity>> webSecurityConfigurers = new ArrayList<>();
 Map<String, WebSecurityConfigurer> beansOfType = beanFactory
   .getBeansOfType(WebSecurityConfigurer.class);
 for (Entry<String, WebSecurityConfigurer> entry : beansOfType.entrySet()) {
  webSecurityConfigurers.add(entry.getValue());
 }
 return webSecurityConfigurers;
}

可以看到，其實就是從 beanFactory 工廠中查詢到 WebSecurityConfigurer 的實例返回。

WebSecurityConfigurer 的實例其實就是 WebSecurityConfigurerAdapter，如果我們沒有自定義 WebSecurityConfigurerAdapter，那么默認使用的是 SpringBootWebSecurityConfiguration 中自定義的 WebSecurityConfigurerAdapter。

當然我們也可能自定義了 WebSecurityConfigurerAdapter，而且如果我們配置了多個過濾器鏈（多個 HttpSecurity 配置），那么 WebSecurityConfigurerAdapter 的實例也將有多個。所以這里返回的是 List 集合。

至此，我們搞明白了了 setFilterChainProxySecurityConfigurer 方法的兩個參數。回到該方法我們繼續分析。

接下來創建了 webSecurity 對象，并且放到 ObjectPostProcessor 中處理了一下，也就是把 new 出來的對象存入 Spring 容器中。

調用 webSecurityConfigurers.sort 方法對 WebSecurityConfigurerAdapter 進行排序，如果我們配置了多個 WebSecurityConfigurerAdapter 實例（多個過濾器鏈，參見：Spring Security 竟然可以同時存在多個過濾器鏈？），那么我們肯定要通過 @Order 注解對其進行排序，以便分出一個優先級出來，而且這個優先級還不能相同。

所以接下來的 for 循環中就是判斷這個優先級是否有相同的，要是有，直接拋出異常。

最后，遍歷 webSecurityConfigurers，并將其數據挨個配置到 webSecurity 中。webSecurity.apply 方法會將這些配置存入 AbstractConfiguredSecurityBuilder.configurers 屬性中（參見：深入理解 HttpSecurity【源碼篇】）。

這就是 setFilterChainProxySecurityConfigurer 方法的工作邏輯，大家看到，它主要是在構造 WebSecurity 對象。

WebSecurityConfiguration 中第二個比較關鍵的方法是 springSecurityFilterChain，該方法是在上個方法執行之后執行，方法的目的是構建過濾器鏈，我們來看下：

@Bean(name = AbstractSecurityWebApplicationInitializer.DEFAULT_FILTER_NAME)
public Filter springSecurityFilterChain() throws Exception {
 boolean hasConfigurers = webSecurityConfigurers != null
   && !webSecurityConfigurers.isEmpty();
 if (!hasConfigurers) {
  WebSecurityConfigurerAdapter adapter = objectObjectPostProcessor
    .postProcess(new WebSecurityConfigurerAdapter() {
    });
  webSecurity.apply(adapter);
 }
 return webSecurity.build();
}

這里首先會判斷有沒有 webSecurityConfigurers 存在，一般來說都是有的，即使你沒有配置，還有一個默認的。當然，如果不存在的話，這里會現場 new 一個出來，然后調用 apply 方法。

最最關鍵的就是最后的 webSecurity.build() 方法了，這個方法的調用就是去構建過濾器鏈了。

根據 深入理解 HttpSecurity【源碼篇】 一文的介紹，這個 build 方法最終是在 AbstractConfiguredSecurityBuilder#doBuild 方法中執行的：

@Override
protected final O doBuild() throws Exception {
 synchronized (configurers) {
  buildState = BuildState.INITIALIZING;
  beforeInit();
  init();
  buildState = BuildState.CONFIGURING;
  beforeConfigure();
  configure();
  buildState = BuildState.BUILDING;
  O result = performBuild();
  buildState = BuildState.BUILT;
  return result;
 }
}

這里會記錄下來整個項目的構建狀態。三個比較關鍵的方法，一個是 init、一個 configure 還有一個 performBuild。

init 方法會遍歷所有的 WebSecurityConfigurerAdapter ，并執行其 init 方法。WebSecurityConfigurerAdapter#init 方法主要是做 HttpSecurity 的初始化工作，具體參考：深入理解 WebSecurityConfigurerAdapter【源碼篇】。init 方法在執行時，會涉及到 HttpSecurity 的初始化，而 HttpSecurity 的初始化，需要配置 AuthenticationManager，所以這里最終還會涉及到一些全局的 AuthenticationManagerBuilder 及相關屬性的初始化，具體參見：深入理解 AuthenticationManagerBuilder 【源碼篇】，需要注意的是，AuthenticationManager 在初始化的過程中，也會來到這個 doBuild 方法中，具體參考松哥前面文章，這里就不再贅述。

configure 方法會遍歷所有的 WebSecurityConfigurerAdapter ，并執行其 configure 方法。WebSecurityConfigurerAdapter#configure 方法默認是一個空方法，開發者可以自己重寫該方法去定義自己的 WebSecurity，具體參考：深入理解 WebSecurityConfigurerAdapter【源碼篇】。

最后調用 performBuild 方法進行構建，這個最終執行的是 WebSecurity#performBuild 方法，該方法執行流程，參考松哥前面文章深入理解 WebSecurityConfigurerAdapter【源碼篇】。

performBuild 方法執行的過程，也是過濾器鏈構建的過程。里邊會調用到過濾器鏈的構建方法，也就是默認的十多個過濾器會挨個構建，這個構建過程也會調用到這個 doBuild 方法。

performBuild 方法中將成功構建 FilterChainProxy，最終形成我們需要的過濾器鏈。

3.2 @EnableGlobalAuthentication

@EnableWebSecurity 注解除了過濾器鏈的構建，還有一個注解就是 @EnableGlobalAuthentication。我們也順便來看下：

@Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
@Target(value = { java.lang.annotation.ElementType.TYPE })
@Documented
@Import(AuthenticationConfiguration.class)
@Configuration
public @interface EnableGlobalAuthentication {
}

可以看到，該注解的作用主要是導入 AuthenticationConfiguration 配置。

這便是 Spring Security 的一個大致的初始化流程。大部分的源碼在前面的文章中都講過了，本文主要是是一個梳理，如果小伙伴們還沒看前面的文章，建議看過了再來學習本文哦。