IOC初始化源码

概念

DI：依赖注入
IOC：控制反转

容器初始化

以注解的方式启动

配置类

@Configuration
@ComponentScan(basePackages = "com.text")
public class MainConfig {
   public MainConfig() {
      System.out.println("MainConfig");
   }
}

启动类

public class MainStat {
   public static void main(String[] args) {
      AnnotationConfigApplicationContext context= new AnnotationConfigApplicationContext(MainConfig.class);
   }
}

容器的初始化就通过new ApplicationContext()完成，下面来看具体做了些什么事情

初始化过程

进入到ApplicationContext()的构造函数中

{
    this();
    
    register();
    
    refresh();
}

一共调用了三个方法

首先来看this()

this调用构造函数，默认会调用父类的构造函数，这里GenericApplicationContext作为父类，父类的构造函数实例化了DefaultListableBeanFactory，为

ApplicationContext spring上下文对象初始化beanFactory
public GenericApplicationContext() {
    this.beanFactory = new DefaultListableBeanFactory();
}

回到AnnotationConfigApplicationContext构造器

public AnnotationConfigApplicationContext() {
   /**
    * 初始化注解模式下的bean定义扫描器
    * 调用AnnotatedBeanDefinitionReader构造方法，传入的是this(AnnotationConfigApplicationContext)对象
    */
   //注册内置BeanPostProcessor以及注册相关的BeanDefinition
   this.reader = new AnnotatedBeanDefinitionReader(this);
   /**
    * 初始化我们的classPath类型的bean定义扫描器
    */
   this.scanner = new ClassPathBeanDefinitionScanner(this);
}

第7行注册6个内置的beanPostProcessor

registry.registerBeanDefinition(beanName, definition);

然后this()就这样走完了，这里再总结一下this已经完成的工作

• 初始化上下文对象beanFactory
• 初始化bean定义扫描器BeanDefinitionReader，并且完成6个内置beanPostProcessor的注册
• 初始化classPath类型的bean定义扫描器，也就是在外边显示调用context.scan()，添加入容器的bean

然后是我们的register()

这里传入了一个参数，本例是注解的方式启动，最开始将注解配置类作为参数传递进来，这里就作为register的参数。进去注册我们的配置类

一路调用，用我们刚刚初始化的bean定义扫描器reader
reader.register() --> for: registerBean(class) --> doRegisterBean(class,null,null,null)

spring的命名有一个规律，do开头的才是真正做事情的

ok，一路调用发现最终doRegisterBean在做事情

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
      @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
   if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
      return;
   }

   abd.setInstanceSupplier(instanceSupplier);
   ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
   abd.setScope(scopeMetadata.getScopeName());
   String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

   AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
   if (qualifiers != null) {
      for (Class<? extends Annotation> qualifier : qualifiers) {
         if (Primary.class == qualifier) {
            abd.setPrimary(true);
         }
         else if (Lazy.class == qualifier) {
            abd.setLazyInit(true);
         }
         else {
            abd.addQualifier(new AutowireCandidateQualifier(qualifier));
         }
      }
   }
   for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
      customizer.customize(abd);
   }

   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

我们对这个方法逐步解析，首先是将配置类传入实例化了一个GenericBeanDefinition对象

AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);

然后判断是否要跳过这个类解析，注解@Conditional

if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
      return;
   }

这里通过配置类构建一个scopeMetadata对象，将解析配置类上的@Scope注解，并将其value设置到abd对象中

ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
   abd.setScope(scopeMetadata.getScopeName());

这里拿到beanName

String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

处理注解bean的通用注解 lazy primary DependsOn Role Description，将解析结果set到abd中

AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

这里是@Qualifier的处理

if (qualifiers != null) {
   for (Class<? extends Annotation> qualifier : qualifiers) {
      if (Primary.class == qualifier) {
         abd.setPrimary(true);
      }
      else if (Lazy.class == qualifier) {
         abd.setLazyInit(true);
      }
      else {
         abd.addQualifier(new AutowireCandidateQualifier(qualifier));
      }
   }
}

将adb和beanName作为参数实例化一个 deanDefinitionHolder，hodler相当于是一个bean的持有者或者说是bean的一个封装对象。

BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

这里将配置类注册到beanDefinitionMap中

BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

这里总结一下register方法，总的来说实质上就是将我们的配置类注入到bean定义map中，这个过程中能发现的是，在将配置类注入之前，首先我们通过配置类构建了一个beanDefinition对象，然后通过解析配置类上的一些注解，诸如@Scope，@Conditional，@lazy等，不断的将这个beanDefinition完善。实质上这个beanDefinition就是这个配置类的描述类，需要将它相关的描述写入。就好比这里是在画一个人的肖像，spring就是画家，bean就是人体模特，而这个beanDefinition就是这幅肖像画

最后是我们的refresh方法

首先整体来看一下里面的方法

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      //1:准备刷新上下文环境
      prepareRefresh();

      //2:获取告诉子类初始化Bean工厂，拿到DefaultListableBeanFactory实例对象
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      //3:对bean工厂进行填充属性
      prepareBeanFactory(beanFactory);

      try {
         // 第四:留个子类去实现该接口
         postProcessBeanFactory(beanFactory);

         // 调用我们的bean工厂的后置处理器,处理BeanFactoryPostProcessors接口的实现，bean实例化之前
         invokeBeanFactoryPostProcessors(beanFactory);

         // 调用我们bean的后置处理器，处理BeanPostProcessors接口的实现，bean实例化之后，流程同上一个方法类似
         registerBeanPostProcessors(beanFactory);

         // 初始化国际化资源处理器.
         initMessageSource();

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

         // 这个方法同样也是留个子类实现的springboot也是从这个方法进行启动tomcat的.
         onRefresh();

         //把我们的事件监听器注册到多播器上
         registerListeners();

         //实例化我们剩余的单实例bean.
         finishBeanFactoryInitialization(beanFactory);

         // 最后容器刷新 发布刷新事件(Spring cloud也是从这里启动的)
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception  encountered during context initialization - " +
                  "cancelling refresh attempt: " + 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();
      }
   }
}

从第18行开始，该方法的描述是调用我们的bean工厂的后置处理器,处理BeanFactoryPostProcessors接口的实现，发生在bean实例化之前
invokeBeanFactoryPostProcessors(beanFactory);

这里由于该方法的篇幅过长我们就简单描述一下该方法的作用，详细的参考另一篇笔记