Spring容器的初始化过程

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
ac.register(AppConfig.class);
ac.refresh();

一、容器实例化

public AnnotationConfigApplicationContext() {
    
    //spring对外提供了一个解析器
   this.reader = new AnnotatedBeanDefinitionReader(this);

    //Spring完成自己的扫描并不是使用了这个scanner,而是在扫描的时候自己重新new了一个。
    //这个的作用就是对外提供一个接口，可以让程序员自己调用，完成自己的包扫描
   this.scanner = new ClassPathBeanDefinitionScanner(this);
}

spring为什么要对外提供一个解析器？
1.解析配置类。spring的配置类不能自己扫描自己，因此就需要一个类来完成将配置类解析成为一个AnnotatedGenericBeanDefinition的功能，reader就完成了这个功能。
其他的普通类则是在spring执行包扫描的时候，根据配置类上面的配置的包扫描路径被spring解析成为一个ScannedGenericBeanDefinition.
2.对外提供接口，程序员可以动态的注册beanDefinition.AnnotatedBeanDefinitionReader对外暴露了一个register(),可以让程序员自己注册beanDefinition.
为什么spring不是自己new一个AnnotatedGenericBeanDefinition，将配置类解析成beanDefinition?
1.虽然spring可以自己new一个AnnotatedGenericBeanDefinition完成配置类的解析，但是不利于扩展
2。配置类的个数是不一定的，spring没办法知道到底有几个配置类。因此需要一个解析器去解析所有的配置类

spring在初始化解析器的时候将spring bean生命周期过程中至关重要的5个后置处理器放到了beanDefinitionMap中，为spring完成容器初始化过程打下基础
构造方法调用，最后调用到AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    //构造方法调用
   this(registry, getOrCreateEnvironment(registry));
}

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   Assert.notNull(environment, "Environment must not be null");
   this.registry = registry;
   this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
   AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}


下面看AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)到底完成了什么事情
//这里就指出几个重要的

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
      BeanDefinitionRegistry registry, @Nullable Object source) {

    //bean工厂的初始化
   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
   if (beanFactory != null) {
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
      }
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
         beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
      }
   }

   Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

    //解析配置类的beanFactoryPostProcessor 最重要的后置处理器
   if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
   }
    
    //解析@Autowired
   if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
   }
    //解析@Resource
   // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
   if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
   if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition();
      try {
         def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
               AnnotationConfigUtils.class.getClassLoader()));
      }
      catch (ClassNotFoundException ex) {
         throw new IllegalStateException(
               "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
      }
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
   }

   return beanDefs;
}

二。配置类的注册 — ac.register(AppConfig.class) 这里就体现了reader 的价值

public void register(Class<?>... componentClasses) {
   Assert.notEmpty(componentClasses, "At least one component class must be specified");
   //从这里可以看出，本质是调用reader的register()
   this.reader.register(componentClasses);
}

层层调用之后的本质代码如下

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
      @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
      @Nullable BeanDefinitionCustomizer[] customizers) {

    //这里就可以看出 spring是将@Configuration的配置类解析成了一个AnnotatedGenericBeanDefinition
   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
   if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
      return;
   }

   abd.setInstanceSupplier(supplier);
   //解析设置bean的Scope
   ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
   abd.setScope(scopeMetadata.getScopeName());
   
   //解析beanName (具体就不再细述，简单的说就是解析这个beanDefinition，根据不同的类型加上不同的后缀)
   String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

    //解析bean上的注解，判断bean是不是lazy，primary。。。
   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));
         }
      }
   }
   if (customizers != null) {
      for (BeanDefinitionCustomizer customizer : customizers) {
         customizer.customize(abd);
      }
   }

   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
   //将解析之后的配置类put到beanDefinitionMap中
   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

至此spring完成了容器的实例化，bean工厂的初始化，内置beanDefinition和配置类的解析过程（类–>BeanDefinition–>put definitionMap）、解析器和扫描器的初始化

如有理解不正确的地方，欢迎大家指出