Spring IoC源码分析

总览

具体说明

1. 初始化Ioc容器

• 核心思想：首先创建Bean工厂对象DefaultListableBeanFactory，然后委托给多个阅读器(如：BeanDefinitionDocumentReader、BeanDefinitionParserDelegate等)解析配置元数据，加载Bean定义，最后存入本地缓存 Map<String, BeanDefinition> beanDefinitionMap

• 整体跳转流程：AbstractApplicationContext#obtainFreshBeanFactory() -> AbstractApplicationContext#refreshBeanFactory() -> AbstractRefreshableApplicationContext#refreshBeanFactory() -> AbstractRefreshableApplicationContext#loadBeanDefinitions() -> AbstractXmlApplicationContext#loadBeanDefinitions() -> XmlBeanDefinitionReader#loadBeanDefinitions() -> XmlBeanDefinitionReader#doLoadBeanDefinitions() -> XmlBeanDefinitionReader#registerBeanDefinitions() -> BeanDefinitionDocumentReader#registerBeanDefinitions() -> DefaultBeanDefinitionDocumentReader#registerBeanDefinitions() -> DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions(Element root)

• 核心代码分析

  //入口
  @Override
  public void refresh() throws BeansException, IllegalStateException {
      synchronized (this.startupShutdownMonitor) {
          StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
          //初始化前的准备
          prepareRefresh();
          // =========初始化Ioc容器===========
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
          // 为Ioc容器集成各个功能：如BeanPostProcessor、EnvironmentAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware等
          prepareBeanFactory(beanFactory);
          try {
              //bean工厂后置扩展器
              postProcessBeanFactory(beanFactory);
              StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
              //实例化并调用所有已注册的BeanFactoryPostProcessor
              invokeBeanFactoryPostProcessors(beanFactory);
              //实例化并注册所有BeanPostProcessor
              registerBeanPostProcessors(beanFactory);
              beanPostProcess.end();
              // 初始化消息源
              initMessageSource();
              // 初始化事件广播器
              initApplicationEventMulticaster();
              // 初始化其他特殊bean
              onRefresh();
              // 注册监听器（添加实现ApplicationListener的bean）
              registerListeners();
              // ======实例化Bean=======
              finishBeanFactoryInitialization(beanFactory);
              // 完成应用上下文的刷新：清除资源缓存、初始化应用上下文的生命周期处理器、事件发布给所有监听器等
              finishRefresh();
          }catch (BeansException ex) {
              //异常执行回滚操作
              destroyBeans();
              cancelRefresh(ex);
              throw ex;
          }finally {
              resetCommonCaches();
              contextRefresh.end();
          }
      }
  }
  

  //管理bean工厂的生命周期
  @Override
  protected final void refreshBeanFactory() throws BeansException {
      //关闭之前的bean工厂
      if (hasBeanFactory()) {
          destroyBeans();
          closeBeanFactory();
      }
      //初始化一个新的bean工厂
      try {
          //创建一个内部bean工厂 BeanFactory
          DefaultListableBeanFactory beanFactory = createBeanFactory();
          beanFactory.setSerializationId(getId());
          //设置bean工厂
          customizeBeanFactory(beanFactory);
          //加载bean定义：将bean定义加载到给定的bean工厂中，通常是通过委托给一个或多个bean定义阅读器。
          //通过委托给XmlBeanDefinitionReader对象加载bean定义
          loadBeanDefinitions(beanFactory);
          this.beanFactory = beanFactory;
      }
      catch (IOException ex) {
          throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
      }
  }
  

  //委托XmlBeanDefinitionReader对象，加载bean定义
  @Override
  protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
      // 为给定的bean工厂创建一个XmlBeanDefinitionReader对象
      XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
  
      //为XmlBeanDefinitionReader对象设置环境、资源加载器、实体类资源等
      beanDefinitionReader.setEnvironment(this.getEnvironment());
      beanDefinitionReader.setResourceLoader(this);
      beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
  
      //初始化XmlBeanDefinitionReader对象
      initBeanDefinitionReader(beanDefinitionReader);
      //加载bean定义
      loadBeanDefinitions(beanDefinitionReader);
  }
  

  //XmlBeanDefinitionReader加载bean定义
  protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
      //1. 获取bean定义资源路径
      Resource[] configResources = getConfigResources();
      if (configResources != null) {
          //2. 加载bean定义：xml配置文件、properties配置文件、Groovy脚本
          reader.loadBeanDefinitions(configResources);
      }
      String[] configLocations = getConfigLocations();
      if (configLocations != null) {
          reader.loadBeanDefinitions(configLocations);
      }
  }
  

2. 实例化Bean、Bean属性赋值、初始化Bean

• 核心思想：利用反射技术，根据bean定义中的路径找到bean对应的类完成bean实例化、属性赋值操作、利用回调完成初始化操作
• 整体跳转流程：
  • 实例化Bean：AbstractApplicationContext#finishBeanFactoryInitialization() -> ConfigurableListableBeanFactory#preInstantiateSingletons() -> DefaultListableBeanFactory#preInstantiateSingletons() -> DefaultListableBeanFactory#getBean() -> AbstractBeanFactory#getBean() -> AbstractBeanFactory#doGetBean() -> AbstractBeanFactory#createBean() -> AbstractAutowireCapableBeanFactory#createBean() -> AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation() -> InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation() -> AbstractAutowireCapableBeanFactory#doCreateBean() -> AbstractAutowireCapableBeanFactory#createBeanInstance() -> BeanWrapper
  • 属性赋值：AbstractAutowireCapableBeanFactory#populateBean() -> InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation() -> MutablePropertyValues#List
  • 初始化Bean：AbstractAutowireCapableBeanFactory#initializeBean() -> AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization() -> AbstractAutowireCapableBeanFactory#invokeInitMethods() -> AbstractAutowireCapableBeanFactory#invokeCustomInitMethod() -> AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization() -> Object wrappedBean -> Map<String, Object>
• 核心源码分析

  //实例化Bean、Bean属性赋值、初始化Bean
  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
      //1. 实例化Bean
      BeanWrapper instanceWrapper = null;
      if (instanceWrapper == null) {
          instanceWrapper = createBeanInstance(beanName, mbd, args);
      }
      //...
      Object exposedObject = bean;
      try {
          //2. 依赖注入Bean属性赋值
          populateBean(beanName, mbd, instanceWrapper);
          //3. 初始化Bean
          exposedObject = initializeBean(beanName, exposedObject, mbd);
      }
      //...
      return exposedObject;
  }
  

  //实例化Bean
  protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
      //验证bean对应的类是否可以实例化
      Class<?> beanClass = resolveBeanClass(mbd, beanName);
      ...
      //使用工厂方法对bean进行实例化
      if (mbd.getFactoryMethodName() != null)  {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
      }
      ...
      //使用构造函数进行实例化
      Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
      if (ctors != null ||
          mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
          mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
      return autowireConstructor(beanName, mbd, ctors, args);
      }
      //使用默认的构造函数进行实例化
      return instantiateBean(beanName, mbd);
  }
  

  //Bean属性赋值
  protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
      //...
      boolean continueWithPropertyPopulation = true;
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
          if (bp instanceof InstantiationAwareBeanPostProcessor) {
          InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
          //实例化后置处理
          if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
              continueWithPropertyPopulation = false;
              break;
          }
          }
      }
      }
      //依赖注入
      PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
          mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
          MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
          //根据Autowire注入
          if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
              autowireByName(beanName, mbd, bw, newPvs);
          }
          if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
              autowireByType(beanName, mbd, bw, newPvs);
          }
          pvs = newPvs;
      }
      //...
      //根据PropertyValues注入
      if (pvs != null) {
          applyPropertyValues(beanName, mbd, bw, pvs);
      }
  }
  

  //初始化Bean
  protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
      //调用AwareMethods设置bean的BeanName、BeanClassLoader、BeanFactory属性
      invokeAwareMethods(beanName, bean);
      //...
      
      Object wrappedBean = bean;
      //后置扩展器：初始化前的自定义操作
      if (mbd == null || !mbd.isSynthetic()) {
          wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
      }
      try {
          //调用初始化Bean方法
          invokeInitMethods(beanName, wrappedBean, mbd);
      }
      //...
      //后置扩展器：初始化后的自定义操作
      if (mbd == null || !mbd.isSynthetic()) {
          wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
      }
      return wrappedBean;
  }