概述

Spring Security的配置机制会使用到很多对象,比如WebSecurity,ProviderManager,各个安全Filter等。这些对象的创建并不是通过bean定义的形式被容器发现和注册进入容器的。而是由Spring Security配置机制使用Java new操作符创建。但对于这些并未被容器管理的对象，Spring Security配置机制也称之为bean,并且希望它们也经历跟容器bean同样的生命周期，也能注入相应的依赖，从而进入准备好被使用的状态。为达成这个目标，Spring Security配置机制提供了一个工具类AutowireBeanFactoryObjectPostProcessor。

工具类AutowireBeanFactoryObjectPostProcessor本身会被注册成为容器的一个bean,并且它实现了Spring bean基本的DisposableBean,SmartInitializingSingleton生命周期接口，也就是说它会经历容器标准的生命周期方法调用。在此基础之上，AutowireBeanFactoryObjectPostProcessor又实现了另外一个接口ObjectPostProcessor,这是一个Spring Security自己定义的接口，用来初始化某个新建的对象，通常就是调用其可能带有的跟Aware方法,InitializingBean#afterPropertiesSet()方法同样设计目的的各个初始化方法，并保证DisposableBean#destroy()这样的方法也能被执行。

具体我们通过代码来分析。

AutowireBeanFactoryObjectPostProcessor被注册为容器bean

当使用了注解@EnableWebSecurity,或者@EnableGlobalMethodSecurity时，AutowireBeanFactoryObjectPostProcessor会被注册为一个容器bean：

// @EnableWebSecurity 注解代码片段，可以看到该注解隐含使用了@EnableGlobalMethodSecurity
@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;
}

// @EnableGlobalAuthentication 注解代码片段，可以看到它导入了类 AuthenticationConfiguration
@Import(AuthenticationConfiguration.class)
@Configuration
public @interface EnableGlobalAuthentication {
}

从上面的代码片段来看，不管使用了@EnableWebSecurity还是@EnableGlobalAuthentication,最终都会导入类AuthenticationConfiguration :

@Configuration
@Import(ObjectPostProcessorConfiguration.class) // 导入了类 ObjectPostProcessorConfiguration
public class AuthenticationConfiguration {
    // 省略无关代码实现
}

而类AuthenticationConfiguration又导入了类ObjectPostProcessorConfiguration,ObjectPostProcessorConfiguration进一步注册了bean AutowireBeanFactoryObjectPostProcessor :

@Configuration
public class ObjectPostProcessorConfiguration {

    // 这里的参数beanFactory会被自动注入成当前Spring bean容器
    @Bean
    public ObjectPostProcessor<Object> objectPostProcessor(
            AutowireCapableBeanFactory beanFactory) {
        return new AutowireBeanFactoryObjectPostProcessor(beanFactory);
    }
}

AutowireBeanFactoryObjectPostProcessor的任务

package org.springframework.security.config.annotation.configuration;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.Aware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.security.config.annotation.ObjectPostProcessor;
import org.springframework.util.Assert;

final class AutowireBeanFactoryObjectPostProcessor
        implements ObjectPostProcessor<Object>, DisposableBean, SmartInitializingSingleton {
    private final Log logger = LogFactory.getLog(getClass());
    private final AutowireCapableBeanFactory autowireBeanFactory;
    private final List<DisposableBean> disposableBeans = new ArrayList<>();
    private final List<SmartInitializingSingleton> smartSingletons = new ArrayList<>();

    // 使用指定的 autowireBeanFactory 构造对象
    // autowireBeanFactory 通常是 Spring bean 容器
    public AutowireBeanFactoryObjectPostProcessor(
            AutowireCapableBeanFactory autowireBeanFactory) {
        Assert.notNull(autowireBeanFactory, "autowireBeanFactory cannot be null");
        this.autowireBeanFactory = autowireBeanFactory;
    }

    
    // 对某个刚刚创建的对象 object 执行这里所谓的 post-process 流程 :
    // 1. 使用指定的 autowireBeanFactory 对该对象 object 执行初始化过程;
    // 2. 使用指定的 autowireBeanFactory 对该对象 object 执行依赖注入过程;
    // 3. 如果该对象 object 是一个 DisposableBean , 则将它记录下来，在当前对象的destroy()
    // 被调用时，它们的 destroy() 方法也都会被调用;
    // 4. 如果该对象 object 是一个 SmartInitializingSingleton , 则将它记录下来，
    // 在当前对象的 afterSingletonsInstantiated () 被调用时，它们的 afterSingletonsInstantiated() 
    // 方法也都会被调用;
    @SuppressWarnings("unchecked")
    public <T> T postProcess(T object) {
        if (object == null) {
            return null;
        }
        T result = null;
        try {
            // 使用容器autowireBeanFactory标准初始化方法initializeBean()初始化对象 object
            result = (T) this.autowireBeanFactory.initializeBean(object,
                    object.toString());
        }
        catch (RuntimeException e) {
            Class<?> type = object.getClass();
            throw new RuntimeException(
                    "Could not postProcess " + object + " of type " + type, e);
        }
        // 使用容器autowireBeanFactory标准依赖注入方法autowireBean()处理 object对象的依赖注入
        this.autowireBeanFactory.autowireBean(object);
        
        if (result instanceof DisposableBean) {
            // 记录一个 DisposableBean 对象
            this.disposableBeans.add((DisposableBean) result);
        }
        if (result instanceof SmartInitializingSingleton) {
            // 记录一个 SmartInitializingSingleton 对象
            this.smartSingletons.add((SmartInitializingSingleton) result);
        }
        return result;
    }
    
    // SmartInitializingSingleton 接口定义的生命周期方法，在被调用时也回调用被记录的实现了
    // SmartInitializingSingleton 接口的那些对象的方法 afterSingletonsInstantiated()
    @Override
    public void afterSingletonsInstantiated() {
        for (SmartInitializingSingleton singleton : smartSingletons) {
            singleton.afterSingletonsInstantiated();
        }
    }

    // DisposableBean 接口定义的生命周期方法，在被调用时也回调用被记录的实现了
    // DisposableBean 接口的那些对象的方法 destroy()
    public void destroy() throws Exception {
        for (DisposableBean disposable : this.disposableBeans) {
            try {
                disposable.destroy();
            }
            catch (Exception error) {
                this.logger.error(error);
            }
        }
    }

}