学习spring流程，脉络梳理-含源码及注释

PostProcessor？

PostProcessor (增强器 后置处理器) ，BeanFactoryPostProcessor 完成对 Beanfactory 相关信息的修改或者扩展，BeanPostProcessor 完成对 bean 的修改或者扩展。

 

Bean的生命周期

取自BeanFactory接口代码注释

* <p>Bean factory implementations should support the standard bean lifecycle interfaces
* as far as possible. The full set of initialization methods and their standard order is:
* Bean工厂实现应该尽可能地支持标准bean lifecycle接口，所有实例方法和他们的标准排序如下
* <ol>
* <li>BeanNameAware's {@code setBeanName}
* <li>BeanClassLoaderAware's {@code setBeanClassLoader}
* <li>BeanFactoryAware's {@code setBeanFactory}
* <li>EnvironmentAware's {@code setEnvironment}
* <li>EmbeddedValueResolverAware's {@code setEmbeddedValueResolver}
* <li>ResourceLoaderAware's {@code setResourceLoader}
* (only applicable when running in an application context)
* <li>ApplicationEventPublisherAware's {@code setApplicationEventPublisher}
* (only applicable when running in an application context)
* <li>MessageSourceAware's {@code setMessageSource}
* (only applicable when running in an application context)
* <li>ApplicationContextAware's {@code setApplicationContext}
* (only applicable when running in an application context)
* <li>ServletContextAware's {@code setServletContext}
* (only applicable when running in a web application context)
* <li>{@code postProcessBeforeInitialization} methods of BeanPostProcessors
* <li>InitializingBean's {@code afterPropertiesSet}
* <li>a custom init-method definition
* <li>{@code postProcessAfterInitialization} methods of BeanPostProcessors
* </ol>

脉络总览

 

分步骤讲解

关键方法 ApplicationContext.refresh();

refresh 方法

@Override
public void refresh() throws BeansException, IllegalStateException {
    //startupShutdownMonitor对象在spring环境刷新和销毁的时候都会用到，确保刷新和销毁不会同时执行
    synchronized (this.startupShutdownMonitor) {
        // 准备工作，例如记录事件，设置标志，检查环境变量等，并有留给子类扩展的位置，用来将属性加入到applicationContext中
        prepareRefresh();

        // 创建beanFactory，这个对象作为applicationContext的成员变量，可以被applicationContext拿来用,
        // 并且解析资源（例如xml文件），取得bean的定义，放在beanFactory中
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 对beanFactory做一些设置，例如类加载器、spel解析器、指定bean的某些类型的成员变量对应某些对象等
        prepareBeanFactory(beanFactory);

        try {
            // 子类扩展用，可以设置bean的后置处理器（bean在实例化之后这些后置处理器会执行）
            postProcessBeanFactory(beanFactory);

            // 执行beanFactory后置处理器（有别于bean后置处理器处理bean实例，beanFactory后置处理器处理bean定义）
            invokeBeanFactoryPostProcessors(beanFactory);

            // 将所有的bean的后置处理器排好序，但不会马上用，bean实例化之后会用到
            registerBeanPostProcessors(beanFactory);

            // 初始化国际化服务
            initMessageSource();

            // 创建事件广播器
            initApplicationEventMulticaster();

            // 空方法，留给子类自己实现的，在实例化bean之前做一些ApplicationContext相关的操作
            onRefresh();

            // 注册一部分特殊的事件监听器，剩下的只是准备好名字，留待bean实例化完成后再注册
            registerListeners();

            // 单例模式的bean的实例化、成员变量注入、初始化等工作都在此完成
            finishBeanFactoryInitialization(beanFactory);

            // applicationContext刷新完成后的处理，例如生命周期监听器的回调，广播通知等
            finishRefresh();
        }

        catch (BeansException ex) {
            logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);

            // 刷新失败后的处理，主要是将一些保存环境信息的集合做清理
            destroyBeans();

            // applicationContext是否已经激活的标志，设置为false
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }
    }
}

1、创建 BeanFactory 容器

2、加载配置文件，解析 Bean 定义信息，包装成 BeanDafination

BeanDifinationConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
--> refreshBeanFactory();
　　--> try{
　　　　　　// 创建 DefaultListableBeanFactory 对象
　　　　　　DefaultListableBeanFactory beanFactory = createBeanFactory();
　　　　　　// 为了序列化指定 id，可以从id反序列化到 BeanFactory 对象
　　　　　　beanFactory.setSerializationId(getId());
　　　　　　// 定制 beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
　　　　　　customizeBeanFactory(beanFactory);
　　　　　　// 初始化 documentReader，并进行 XML 文件读取及解析，默认命名空间的解析，自定义标签的解析
　　　　　　loadBeanDefinitions(beanFactory);
　　　　　　this.beanFactory = beanFactory;
　　　　　}

在 obtainFreshBeanFactory() 方法中，先创建了一个 DefaultListableBeanFactory，再向其中设置一些基本属性，后通过 loadBeanDifinations(beanFactory) 将自定义的对象加入到 beanDifinationMap 中，在 map 中完成将每一个对象包装成 BeanDifination；

 

3、执行 BeanFactoryPostProcesser

invokeBeanFactoryPostProcessors(beanFactory);

执行后，BeanDifination 已经确定。

 

4、准备工作：准备 BeanPostProcesser，广播器，监听器

initApplicationEventMulticaster();

registerListeners();

初始化当前应用的事件广播器

注册监听器

 

5、实例化操作

6、初始化操作

finishBeanFactoryInitialization(beanFactory);
--> beanFactory.preInstantiateSingletons();
　　--> // 将所有的 beanDefinitionNames 创建一个集合
　　　　 List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
　　　　 // 触发所有非延迟加载单例 bean 的初始化，遍历集合的对象
　　　　 for () {
　　　　　　　...
　　　　　　　getBean(beanName);
　　　　　　　--> doGetBean(name, null, null, false);
　　　　　　　　　 --> // bean 对象实现 FactoryBean 接口后会变成 &beanName
　　　　　　　　　　　　String beanName = transformedBeanName(name);
　　　　　　　　　　　　Object bean;
　　　　　　　　　　　　// 提前检查单例缓存中是否有手动注册的单例对象，跟循环依赖有关联
　　　　　　　　　　　　Object sharedInstance = getSingleton(beanName);
　　　　　　　　　　　　if (sharedInstance != null && args == null) {
　　　　　　　　　　　　　　...
　　　　　　　　　　　　} else {
　　　　　　　　　　　　　　createBean(beanName, mbd, args);
　　　　　　　　　　　　　　--> Object beanInstance = doCreateBean(beanName, mbdToUsc, args);
　　　　　　　　　　　　　　　　 --> instanceWrapper = createBeanInstance(beanName, mbd, args);
　　　　　　　　　　　　　　　　　　　--> Constructor<?> ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
　　　　　　　　　　　　　　　　　　　　　 // 使用默认无参构造函数创建对象，如果没有无参构造且存在多个有参构造且没有 @AutoWired 注解构造，会报错
　　　　　　　　　　　　　　　　　　　　　 return instantiateBean(beanName, mbd);
　　　　　　　　　　　　　　　　　　　　　 --> beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
　　　　　　　　　　　　　　　　　　　　　　　　--> constructorToUse = clazz.getDeclaredConstructor();
　　　　　　　　　　　　　　　　　　　　　　　　　　 return BeanUtils.instantiateClass(constructorToUse);
　　　　　　　　　　　　　　　　　　　　　　　　　　 --> return ctor.newInstance(argsWithDefaultValues);
　　　　　　　　　　　　　　// 初始化过程 填充属性
　　　　　　　　　　　　　　populateBean(beanName, mbd, instanceWrapper);
　　　　　　　　　　　　　　// 执行初始化逻辑
　　　　　　　　　　　　　　exposedObject = initializeBean(beanName, exposedObject, mbd);
　　　　　　　　　　　　　　--> // Aware 接口处理器，调用 BeanNameAware、BeanClassLoaderAware、beanFactoryAware
　　　　　　　　　　　　　　　　 invokeAwareMethods(beanName, bean);
　　　　　　　　　　　　　　　　 // 将 BeanPostProcessors 应用到给定的现有 Bean 实例，调用它们的postProcessBeforeInitialization 初始化方法。
　　　　　　　　　　　　　　　　 wrappedBean = applyBeanPostProcessorBeforeInitialization(wrappedBean, beanName);
　　　　　　　　　　　　　　　　 // 调用初始化方法，先调用 bean 的 InitializingBean 接口方法，后调用 bean 的自定义初始化方法
　　　　　　　　　　　　　　　　 invokeInitMethods(beanName, wrappedBean, mbd);
　　　　　　　　　　　　　　　　 // 将 BeanPostProcessors 应用到给定的现有 Bean 实例，调用它们的 postProcessAfterInitialization方法
　　　　　　　　　　　　　　　　 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
　　　　　　　　　　　　}
　　　　 }

实例化所有 剩余的 非懒加载的 单例对象

Aware接口是方便自定义对象获取到容器对象

 

7、获取对象

略