（Spring源碼分析）AnnotationConfigApplicationContext容器初始化 this() && register()

AnnotationConfigApplicationContext容器初始化目錄
（Spring源碼分析）AnnotationConfigApplicationContext容器初始化 this() && register()
（Spring源碼分析）AnnotationConfigApplicationContext容器初始化 refresh()#invokeBeanFactoryPostProcessors
（Spring源碼分析）AnnotationConfigApplicationContext容器初始化 refresh()#registerBeanPostProcessors
（Spring源碼分析）AnnotationConfigApplicationContext容器初始化 refresh()#finishBeanFactoryInitialization

使用AnnotationConfigApplicationContext容器

public static void main(String[] args) {
  AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
  TestService testService = applicationContext.getBean(TestService.class);
  System.out.println(testService.sout());
}

AppConfig配置類

@Configuration
@ComponentScan("com.wyj.learning.build.applicationcontext")
public class AppConfig {
}

AnnotationConfigApplicationContext容器方法

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);這段代碼會調用AnnotationConfigApplicationContext類的無參構造方法

/**
 * 這個構造方法需要傳入一個javaconfig註解了的配置類
 * 然後會把這個被註解了javaconfig的類通過註解讀取器讀取後繼而解析
 */
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
  // 這裏由於他有父類，故而會先調用父類的無參構造方法，然後纔會調用自己的無參構造方法
  // 在自己構造方法中初始一個讀取器和掃描器
  this();
	register(annotatedClasses); // 這裏僅僅只是將annotatedClasses作爲bean放入beanDefinitionMap中
	refresh(); // AnnotationConfigApplicationContext容器中最重要的方法，將annotatedClasses中掃描的bean加入beanDefinitionMap中
}

1、this()

this()方法主要是初始化BeanFactory容器

在AnnotationConfigApplicationContext父類GenericApplicationContext的無參構造方法中

/**
 * 初始化BeanFactory
 */
public GenericApplicationContext() {
  this.beanFactory = new DefaultListableBeanFactory();
}

然後執行AnnotationConfigApplicationContext自己的無參構造方法

/**
 * 初始化註解讀取器和掃描器
 */
public AnnotationConfigApplicationContext() {
  this.reader = new AnnotatedBeanDefinitionReader(this);
  this.scanner = new ClassPathBeanDefinitionScanner(this);
}

2、register(annotatedClasses)

register(annotatedClasses)方法主要是將傳入的配置類加入到BeanDefinitionMap中，但是配置類中配置的包掃描路徑下的bean並沒有添加到BeanDefinitionMap中

/**
 * 判斷annotatedClasses不爲空，並調用AnnotatedBeanDefinitionReader註解讀取器去讀取配置類annotatedClasses中的配置
 */
public void register(Class<?>... annotatedClasses) {
  Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
  this.reader.register(annotatedClasses); // 調用AnnotatedBeanDefinitionReader註解讀取器去讀取配置類annotatedClasses中的配置
}

2.1、this.reader.register(annotatedClasses)

/**
 * 循環調用AnnotatedBeanDefinitionReader註解讀取器去讀取配置類
 */
public void register(Class<?>... annotatedClasses) {
  for (Class<?> annotatedClass : annotatedClasses) {
    registerBean(annotatedClass);
  }
}

2.1.1、registerBean(annotatedClass)

public void registerBean(Class<?> annotatedClass) {
  doRegisterBean(annotatedClass, null, null, null);
}

2.1.1.1、doRegisterBean(annotatedClass, null, null, null)

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

  // 這裏的這個AnnotatedGenericBeanDefinition對象僅僅只是在new AnnotationConfigApplicationContext(傳入的配置類)
  AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass); // 將Bean的配置信息轉換成AnnotatedGenericBeanDefinition，它繼承了BeanDefinition接口，包含bean的屬性

  // @Conditional裝配條件判斷是否需要跳過註冊
  if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
    return;
  }

  abd.setInstanceSupplier(instanceSupplier);
  ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); // 解析bean作用域，如果使有@Scope註解指定了bean的作用域將設置成指定的作用域，否則默認爲singleton(單例)
  abd.setScope(scopeMetadata.getScopeName()); // 爲AnnotatedGenericBeanDefinition對象設置scope(作用域)屬性
  String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); // 生成beanName
  AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); // 解析AnnotatedGenericBeanDefinition對象中lazy、Primary、DependsOn、Role、Description屬性

  if (qualifiers != null) { // @Qualifier特殊限定符處理
    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));
      }
    }
  }

  // 處理applicationcontext容器加載完成後手動registerBean
  for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
    customizer.customize(abd);
  }

  BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); // 將beanName和AnnotatedGenericBeanDefinition封裝在BeanDefinitionHolder中
  definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); // 創建代理對象
  BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); // 將BeanDefinition註冊到BeanDefinitionMap中
}

2.1.1.1.1、BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry)

public static void registerBeanDefinition(
  BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
  throws BeanDefinitionStoreException {

  // Register bean definition under primary name.
  String beanName = definitionHolder.getBeanName();
  registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); // 調用BeanDefinitionRegistry方法對BeanDefinition註冊到ConCurrentHashMap中

  // Register aliases for bean name, if any.
  String[] aliases = definitionHolder.getAliases();
  if (aliases != null) {
    for (String alias : aliases) {
      registry.registerAlias(beanName, alias); // 註冊別名
    }
  }
}

2.1.1.1.1.1、registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())

/**
 * 對BeanDefinition註冊到ConCurrentHashMap中
 */
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
  throws BeanDefinitionStoreException {
  // 校驗beanName和beanDefinition不能爲空
  Assert.hasText(beanName, "Bean name must not be empty");
  Assert.notNull(beanDefinition, "BeanDefinition must not be null");

  // beanDefinition校驗
  if (beanDefinition instanceof AbstractBeanDefinition) {
    try {
      ((AbstractBeanDefinition) beanDefinition).validate();
    }
    catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                                             "Validation of bean definition failed", ex);
    }
  }

  BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName); // 判斷beanDefinitionMap中是否含有相同beanName的BeanDefinition

  // 如果beanDefinitionMap中存在相同beanName的BeanDefinition
  if (existingDefinition != null) {
    // 判斷是否允許含有同樣的beanName對BeanDefinition進行覆蓋
    if (!isAllowBeanDefinitionOverriding()) {
      throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                                             "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                                             "': There is already [" + existingDefinition + "] bound.");
    }
    // 參數校驗
    else if (existingDefinition.getRole() < beanDefinition.getRole()) {
      // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
      if (logger.isWarnEnabled()) {
        logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                    "' with a framework-generated bean definition: replacing [" +
                    existingDefinition + "] with [" + beanDefinition + "]");
      }
    }
    else if (!beanDefinition.equals(existingDefinition)) {
      if (logger.isInfoEnabled()) {
        logger.info("Overriding bean definition for bean '" + beanName +
                    "' with a different definition: replacing [" + existingDefinition +
                    "] with [" + beanDefinition + "]");
      }
    }
    else {
      if (logger.isDebugEnabled()) {
        logger.debug("Overriding bean definition for bean '" + beanName +
                     "' with an equivalent definition: replacing [" + existingDefinition +
                     "] with [" + beanDefinition + "]");
      }
    }
    this.beanDefinitionMap.put(beanName, beanDefinition); // 將beanName和beanDefinition存到beanDefinitionMap中
  }

  // 如果beanDefinitionMap中不存在相同beanName的BeanDefinition
  else {
    if (hasBeanCreationStarted()) {
      // Cannot modify startup-time collection elements anymore (for stable iteration)
      synchronized (this.beanDefinitionMap) { // 同步代碼塊
        this.beanDefinitionMap.put(beanName, beanDefinition); // 將beanName和beanDefinition存到beanDefinitionMap中
        List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
        updatedDefinitions.addAll(this.beanDefinitionNames);
        updatedDefinitions.add(beanName);
        this.beanDefinitionNames = updatedDefinitions;
        if (this.manualSingletonNames.contains(beanName)) {
          Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
          updatedSingletons.remove(beanName);
          this.manualSingletonNames = updatedSingletons;
        }
      }
    }
    else {
      // Still in startup registration phase
      this.beanDefinitionMap.put(beanName, beanDefinition);
      this.beanDefinitionNames.add(beanName);
      this.manualSingletonNames.remove(beanName);
    }
    this.frozenBeanDefinitionNames = null;
  }

  if (existingDefinition != null || containsSingleton(beanName)) {
    resetBeanDefinition(beanName);
  }
}