一、基本原理和实现逻辑

二、Spring 容器初始化流程源码阅读

Spirng 容器初始化主要包括一下几个主要部分：bean实例化过程、bean的创建流程、bean的依赖注入流程、bean的初始化过程。

2.1 主流程源码分析

  1. 源码入口

    1. //1. 创建IOC容器,并进行初始化
    2. ApplicationContext context = new ClassPathXmlApplicationContext("");
    3. //2. 获取创建的对象进行使用
    4. User user = context.getBean("beanName");

  2. ClassPathXmlApplicationContext 构造方法

    1. public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
    3.  @Nullable
    4.  private Resource[] configResources;
    6.  // 根据String 类型的构造方法，读取bean.xml 配置文件进行后面的初始化操作
    7.  public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    8.  // 调用本方法构造方法
    9.  this(new String[] {configLocation}, true, null);
    10.  }
    12.  public ClassPathXmlApplicationContext(
    13.          String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
    14.          throws BeansException {
    15.      // 实现父类构造方法，由于继承关系比较多,一层层实现最终到顶级父类
    16.      super(parent);
    17.      setConfigLocations(configLocations);
    18.      if (refresh) {
    19.          refresh();
    20.      }
    21.  }
    22. }

  3. AbstractApplicationContext

    1. public abstract class AbstractApplicationContext extends DefaultResourceLoader
    2.      implements ConfigurableApplicationContext {
    3. @Override
    4.  public void refresh() throws BeansException, IllegalStateException {
    5.      synchronized (this.startupShutdownMonitor) {
    6.          // Prepare this context for refreshing.
    7.          // 1. 刷新预处理
    8.          prepareRefresh();
    10.          // Tell the subclass to refresh the internal bean factory.
    11.          // 2:初始化流程
    12.              1）创建IOC容器（DefaultListableBeanFactory）
    13.              2) 加载解析XML文件（最终存储到Document对象中）
    14.              3）读取Document对象，并完成BeanDefinition的加载和注册工作
    15.          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    17.          // Prepare the bean factory for use in this context.
    18.          prepareBeanFactory(beanFactory);
    20.          try {
    21.              // Allows post-processing of the bean factory in context subclasses.
    22.              postProcessBeanFactory(beanFactory);
    24.              // Invoke factory processors registered as beans in the context.
    25.              invokeBeanFactoryPostProcessors(beanFactory);
    27.              // Register bean processors that intercept bean creation.
    28.              registerBeanPostProcessors(beanFactory);
    30.              // Initialize message source for this context.
    31.              initMessageSource();
    33.              // Initialize event multicaster for this context.
    34.              initApplicationEventMulticaster();
    36.              // Initialize other special beans in specific context subclasses.
    37.              onRefresh();
    39.              // Check for listener beans and register them.
    40.              registerListeners();
    42.              // Instantiate all remaining (non-lazy-init) singletons.
    43.              //11 实例化剩余的单例bean(非懒加载方式)
    44.              //注意事项： bean的IoC、DI和AOP都发在此步骤中
    45.              finishBeanFactoryInitialization(beanFactory);
    47.              // Last step: publish corresponding event.
    48.              finishRefresh();
    49.          }
    51.          catch (BeansException ex) {
    52.              if (logger.isWarnEnabled()) {
    53.                  logger.warn("Exception encountered during context initialization - " +
    54.                          "cancelling refresh attempt: " + ex);
    55.              }
    57.              // Destroy already created singletons to avoid dangling resources.
    58.              destroyBeans();
    60.              // Reset 'active' flag.
    61.              cancelRefresh(ex);
    63.              // Propagate exception to caller.
    64.              throw ex;
    65.          }
    67.          finally {
    68.              // Reset common introspection caches in Spring's core, since we
    69.              // might not ever need metadata for singleton beans anymore...
    70.              resetCommonCaches();
    71.          }
    72.      }
    73.  }
    74. }

    2.2 创建BeanFactory流程源码分析

    2.3 加载BeanDifination 流程分析

    2.4 Bean 实例化流程分析