Spring配置类的解析过程

基于JavaConfig的spring配置类解析过程

从下图中的代码开始分析

调用this方法

在此处创建基于注解的beanDefinition的reader，用于解析spring中使用注解注入的bean Definition

存在如下类图中的关系，AnnotationConfigApplicationContext实现了BeanDefinitionRegistry接口，所以具有注册beanDefinition的功能，进而调用如下方法完成AnnotatedBeanDefinitionReader的创建，此外，在该方法中还会进一步调用获取应用上下文环境的方法，如果应用上下文环境已经存在则直接返回，否则创建一个StandardEnvironment应用上下文环境并返回。


进一步调用，在下图中的方法中对类成员变脸registry和conditionEvaluator赋值，ConditionEvaluator类的作用是用于根据条件计算那些类是需要被加载成bean实例，哪些类需要被跳过。

注册注解配置处理器

获取到默认的beanFactory，获取到beanFactory中的dependencyComparator和autowireCandidateResolver，然后判断类型是否是AnnotationAwareOrderComparator和ContextAnnotationAutowireCandidateResolver，如果不是则分别设置。
其中AnnotationAwareOrderComparator的作用是用于后续处理Order接口的实现类、@Order注解、@Priority注解
ContextAnnotationAutowireCandidateResolver的作用是用于处理候选依赖、对依赖进行延迟处理等功能。

（由于下面的代码截图不方便，所以为了更好的分析每一行代码的作用，我们直接粘贴源码）

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

   // 获取到默认的beanFactory
   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
   if (beanFactory != null) {
       // 获取到beanFactory中的dependencyComparator和autowireCandidateResolver，然后判断类型是否是AnnotationAwareOrderComparator和ContextAnnotationAutowireCandidateResolver，如果不是则分别设置。
       // AnnotationAwareOrderComparator的作用是用于后续处理Order接口的实现类、@Order注解、@Priority注解
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
      }
      // ContextAnnotationAutowireCandidateResolver的作用是用于处理候选依赖、对依赖进行延迟处理等功能。
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
         beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
      }
   }

   Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
    // 判断registry中是否拥有处理带@Configuration注解的后置处理器
   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));
   }
    // 判断registry中是否拥有处理带@Autowired、@Value注解的Bean的后置处理器
   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));
   }

   // 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;
}

注册后置处理器，将beanName对应的definition注册成对应的bean Definition

紧接着，在此处调用register方法，将配置类注册成bean

获取到AnnotationConfigurationApplicationContext对象中的read，reader为前面的AnnotatedBeanDefinitionReader对象，使用reader来将配置类注册成bean Definition。



再贴源码

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

    // 将给定的配置类包装成一个AnnotatedGenericBeanDefinition对象。
   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
   // 获取类上的注解信息，判断当前配置类是否需要跳过
   if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
      return;
   }

   abd.setInstanceSupplier(supplier);
   // 判断当前类是否带了@Scope注解，@Scope用来标注对象的作用域，同时可以指定该对象创建的方式，比如CGLIB、jdk动态代理、不使用代理等，默认是一个bean是单例的。
   ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
   abd.setScope(scopeMetadata.getScopeName());
   // 获取beanName
   String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    // 判断当前类上是否携带了@Lazy、@Primary、@DependsOn、@Role、@Description注解，如果有就设置注解中对应的属性到bean Definition中 (@Primary：意思是在众多相同的bean中，优先使用用@Primary注解的bean)
   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);
   // 获取到@Scope注解上指定创建bean的方式，如果没有指定则直接返回对应的原始bean
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
   // 将配置类注册成对应的bean定义
   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

在此处最后将配置类注册成对应的bean Definition对象，同时如果设置了对应的别名，还需要注册别名

接下来，调用refresh方法，在调用invokeBeanFactoryPostProcessors方法处理配置类。


获取到处理@Configuration的后置处理器，然后使用f该处理器去处理配置类中信息。


调用beanDefinition的后置处理器，此处的处理器便是上一步传进来的ConfigurationClassPostProcessor对象

在此处真正来解析配置类中的信息
获取到所有beanDefinition的对象，然后进行遍历，然后从beanDefinitionMap中通过名称获取到对应的beanDefinition，判断当前beanDefinition是不是配置类，如果是就把它加载到配置类候选列表中。
然后会在如下图的parse方法中去解析配置类的信息。


然后进入如下parse方法去解析配置类


在解析之前先判断当前配置类是否需要被跳过，如果不需要被跳过则获取到对应的配置类信息，然后继续执行。

在该方法中解析配置类中的注解，其中包括@Compoent、@PropertySource、@ComponentScans、@ImportSource、@Bean等注解信息，将注解对应的待加载的bean信息放到beanDefinitionMap中，以便后面进行实例化。至此配置类解析完成。