Spring IOC容器启动源码分析

1. 引言

---

我们可以通过ApplicationContext创建IOC容器，它有很多个子类，下面通过它的子类AnnotationConfigApplicationContext的创建来分析下IOC容器是如何创建并进行初始化的。

ApplicationContext applicationContext = 
new AnnotationConfigApplicationContext(AopConfig.class);

AnnotationConfigApplicationContext创建的源码如下：

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
    this();
    register(annotatedClasses);
    refresh();
}

这里refresh()方法是重点，它的源码是：

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();
        // Tell the subclass to refresh the internal bean factory.
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);
        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);
            // Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);
            // Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);
            // Initialize message source for this context.
            initMessageSource();
            // Initialize event multicaster for this context.
            initApplicationEventMulticaster();
            // Initialize other special beans in specific context subclasses.
            onRefresh();
            // Check for listener beans and register them.
            registerListeners();
            // Instantiate all remaining (non-lazy-init) singletons.
            finishBeanFactoryInitialization(beanFactory);
            // Last step: publish corresponding event.
            finishRefresh();
        } catch (BeansException ex) {
            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();
            // Reset 'active' flag.
            cancelRefresh(ex);
            // Propagate exception to caller.
            throw ex;
        } finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

refresh()方法中每一行都很重要，我们依次来进行分析。

2. prepareRefresh()

---

该方法主要是为IOC容器启动做一些准备工作，设置容器的启动时间，closed和active标识。

  protected void prepareRefresh() {
    // Switch to active.
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);
    

    // 空方法，留给子类扩展，初始化 placeholder property
    initPropertySources();

    // 验证一些必须的属性
    getEnvironment().validateRequiredProperties();

    // Store pre-refresh ApplicationListeners...
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    } else {
        // Reset local application listeners to pre-refresh state.
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

这里有个可以扩展的点，我们可以通过重写ApplicationContext来对自定义环境变量验证，要求必须存在某个环境变量时才能启动IOC容器。具体细节可以参考：https://blog.csdn.net/boling_cavalry/article/details/81474340

3. obtainFreshBeanFactory

---

obtainFreshBeanFactory()主要是获取BeanFactory，在获取BeanFactory之前会先创建BeanFactory。

先来看看BeanFactory是在什么地方创建的，我们回到AnnotationConfigApplicationContext创建的地方。

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
    this(); // 调用无参的构造
    register(annotatedClasses);
    refresh();
}

无参构造器默认会隐式地调用父类的无参构造器方法，AnnotationConfigApplicationContext的父类是GenericApplicationContext，而BeanFactory就是在GenericApplicationContext的构造方法中创建出来的。

public GenericApplicationContext() {
    this.beanFactory = new DefaultListableBeanFactory();
}

再回到obtainFreshBeanFactory()方法，它主要做了3件事情：

1. 设置refreshed属性，通过AtomicBoolean的cas操作控制refresh()方法只会被调用一次；
2. 给beanFactory设置serializationId；
3. 返回beanFactory对象，实际类型为DefaultListableBeanFactory。

4.prepareBeanFactory

---

prepareBeanFactory(beanFactory)主要功能是给上一步获取到的beanFactory进行一些属性的设置。主要设置了以下属性：

• BeanFactory的类加载器、支持表达式解析器；
• 添加了两个BeanPostProcessor： ApplicationContextAwareProcessor、ApplicationListenerDetector；
• 设置忽略的自动装配接口：EnvironmentAware，EmbeddedValueResolverAware，ResourceLoaderAware，ApplicationEventPublisherAware，MessageSourceAware，ApplicationContextAware， 在依赖注入的时候忽略这些接口，也就是这些指定的接口不会被注入进去。
• 注册可以解析的自动装配：BeanFactory,ResourceLoader,ApplicationEventPublisher,ApplicationContext，这些类可以在任何地方直接注入；
• 添加类加载期织入(LoadTimeWeaver)的AspectJ；
• 注册一些组件：environment、systemProperties、systemEnvironment。

在Java 语言中，从织入切面的方式上来看，存在三种织入方式：编译期织入、类加载期织入和运行期织入。编译期织入是指在Java编译期，采用特殊的编译器，将切面织入到Java类中；而类加载期织入则指通过特殊的类加载器，在类字节码加载到JVM时，织入切面；运行期织入则是采用CGLib工具或JDK动态代理进行切面的织入。

AspectJ提供了两种切面织入方式，第一种通过特殊编译器，在编译期，将AspectJ语言编写的切面类织入到Java类中，可以通过一个Ant或Maven任务来完成这个操作；第二种方式是类加载期织入，也简称为LTW（Load Time Weaving）。

5. postProcessBeanFactory

---

postProcessBeanFactory(beanFactory)是个空方法。子类可以通过重写这个方法，在BeanFactory创建并预准备完成之后做些扩展工作。该方法在spring-web下有对其进行重写。

6. invokeBeanFactoryPostProcessors

---

invokeBeanFactoryPostProcessors(beanFactory)主要用来执行BeanFactoryPostProcessors，它会将bean的信息转化成BeanDefinition。

BeanFactoryPostProcessors是BeanFacotry的后置处理器，在BeanFactory标准初始化之后执行，它是Spring提供的众多扩展点之一。BeanFacotry后置处理器有两个接口：BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor。

invokeBeanFactoryPostProcessors方法整体流程如下：

先执行`BeanDefinitionRegistryPostProcessor`接口：
1. 获取所有的`BeanDefinitionRegistryPostProcessor`；
2. 看先执行实现了`PriorityOrdered`优先级接口的`BeanDefinitionRegistryPostProcessor`、         `postProcessor.postProcessBeanDefinitionRegistry(registry)`
3. 在执行实现了`Ordered`顺序接口的`BeanDefinitionRegistryPostProcessor`；
`postProcessor.postProcessBeanDefinitionRegistry(registry)`
4. 最后执行没有实现任何优先级或者是顺序接口的`BeanDefinitionRegistryPostProcessors`；
`postProcessor.postProcessBeanDefinitionRegistry(registry)`
            
再执行`BeanFactoryPostProcessor`的方法
1. 获取所有的`BeanFactoryPostProcessor`
2. 看先执行实现了`PriorityOrdered`优先级接口的`BeanFactoryPostProcessor`、
`postProcessor.postProcessBeanFactory()`
3. 在执行实现了`Ordered`顺序接口的`BeanFactoryPostProcessor`；
`postProcessor.postProcessBeanFactory()`
4. 最后执行没有实现任何优先级或者是顺序接口的`BeanFactoryPostProcessor`；
`postProcessor.postProcessBeanFactory()`

7. registerBeanPostProcessors

---

registerBeanPostProcessors(beanFactory)方法用来向beanFactory注册BeanPostProcessor(bean的后置处理器)，这又是Spring容器提供的众多扩展点之一。Bean的后置处理器共有5个接口：

1. BeanPostProcessor
2. DestructionAwareBeanPostProcessor
3. InstantiationAwareBeanPostProcessor
4. SmartInstantiationAwareBeanPostProcessor
5. MergedBeanDefinitionPostProcessor

这5个接口中的方法会在IOC容器启动过程中不同的时机被回调。

和BeanFacotryPostProcessor类似，BeanPostProcessor也能够通过实现PriorityOrdered、Ordered接口进行排序。

registerBeanPostProcessors(beanFactory)方法中将BeanFacotryPostProcessor分成priorityOrderedPostProcessors、internalPostProcessors、orderedPostProcessorNames、nonOrderedPostProcessorNames 4 类，分好类之后再依次添加BeanFactory中。

priorityOrderedPostProcessor： 实现了`PriorityOrdered`接口的BeanPostProcessor；
orderedPostProcessorNames： 实现了`Ordered`接口的BeanPostProcessor；
nonOrderedPostProcessorNames： 没有实现排序的BeanPostProcessor
internalPostProcessors： MergedBeanDefinitionPostProcessor接口

通过请求beanFactory.addBeanPostProcessor(postProcessor);方法，向容器中添加bean的后置处理器。

8. initMessageSource

---

initMessageSource()方法是向容器中注册一个MessageSource组件。MessageSource主要作用是支持国际化。

initMessageSource()方法的主要逻辑是：
先看容器中是否有name为messageSource的MessageSource的组件,

if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // Only set parent context as parent essageSource if no parent MessageSource
                // registered already.
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
}

如果容器中没有MessageSource组件，则创建出来并注册到beanFactory中。

DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

9. initApplicationEventMulticaster

---

initApplicationEventMulticaster()主要对事件派发器（ApplicationEventMulticaster）进行初始化，即向beanFactory注册一个事件派发器。它的逻辑很很简单，就是先判断容器中是否有name=applicationEventMulticaster的bean，没有的话就创建一个再向容器中注册。

10. onRefresh

---

这个方法默认实现什么都没有做，主要留给子类进行拓展。

11. registerListeners

---

registerListeners() 将所有的ApplicationListener进行注册，并进行事件派发。它的主要逻辑：

1. 获取所有的ApplicationListener；
2. 将每个监听器添加到事件派发器中；
3. 如果存在早期应用事件，则将其发布出去。

12. finishBeanFactoryInitialization

---

finishBeanFactoryInitialization(beanFactory)是个重点方法，它会将所有非懒加载的单例对象进行实例化。

在AbstractApplicationContext#finishBeanFactoryInitialization方法中，它最终会调用DefaultListableBeanFactory#preInstantiateSingletons方法对剩下的单实例bean进行初始化，我们重点看看此方法。先贴一下源码：

public void preInstantiateSingletons() throws BeansException {
    // beanDefinitionNames在refresh()之前创建ApplicationContext的this()方法中进行设值
    List beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 遍历触发所有非懒加载的单例bean进行初始化
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        //单例、非抽象、非懒加载
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // bean是否为工厂bean，工厂bean需要加
            if (isFactoryBean(beanName)) {
                // 通过 &+beanName来获取工厂bean本身，而beanName获取的是FactoryBean创建的对象
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean factory = (FactoryBean) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                                        ((SmartFactoryBean) factory)::isEagerInit,
                                getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        // 获取FactoryBean创建的bean对象
                        getBean(beanName);
                    }
                }
            }
            else {
                // 普通的单例bean获取对象，实际会进行初始化
                getBean(beanName);
            }
        }
    }

    // 触发实现了SmartInitializingSingleton接口的afterSingletonsInstantiated方法
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction