Spring IOC 容器预启动流程源码探析

registerAnnotationConfigProcessors(registry, null)中主要做了以下几件事情：

• 为DefaultListableBeanFactory赋值了两个引用

  //依赖排序器，用于处理添加了Priority、Order注解以及实现了Ordered接口的bean
  beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
  //@Autowire候选解析器
  beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
  

• 往容器中注册了6个后置处理器的bean定义

  注册配置类的后置处理器

  RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
  def.setSource(source);
  registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME);
  

  注册处理@Autowired注解的后置处理器

  RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
  def.setSource(source);
  registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME);
  

  注册处理@Required注解的后置处理器(5.1版本开始已被废弃)

  RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
  def.setSource(source);
  registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME);
  

  注册处理JSR-250规范注解的后置处理器，@Resource,@PostConstruct,@PreDestroy

  RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
  def.setSource(source);
  registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME);
  

  注册处理@EventListener注解的后置处理器

  RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
  def.setSource(source);
  registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME);
  

  注册事件监听工厂，给上面的EventListenerMethodProcessors使用

  RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
  def.setSource(source);
  registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME);
  

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
    this(registry, true);
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
    this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
   Environment environment) {
    this(registry, useDefaultFilters, environment,
  (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
   Environment environment, @Nullable ResourceLoader resourceLoader) {

    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    this.registry = registry;
	//默认为true
    if (useDefaultFilters) {
 //注册默认的过滤器
 registerDefaultFilters();
    }
    //设置环境
    setEnvironment(environment);
    //设置资源加载器
    setResourceLoader(resourceLoader);
}

protected void registerDefaultFilters() {
    //加入扫描@Component注解的过滤器，这样就能扫到@Controller,@Service...
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    try {
 //JSR-250规范的注解
 this.includeFilters.add(new AnnotationTypeFilter(
     ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
    }
    catch (ClassNotFoundException ex) {
    }
    try {
 //JSR-330规范的注解
 this.includeFilters.add(new AnnotationTypeFilter(
     ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
    }
    catch (ClassNotFoundException ex) {
    }
}

public void register(Class<?>... annotatedClasses) {
    Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
    //这里就使用了刚刚初始化的AnnotatedBeanDefinitionReader扫码器
    //annotatedClasses即为在入口处传进的自定义配置类Config.class
    this.reader.register(annotatedClasses);
}

public void register(Class<?>... annotatedClasses) {
    for (Class<?> annotatedClass : annotatedClasses) {
 //这里我们只传了一个，只有一次循环
 registerBean(annotatedClass);
    }
}

public void registerBean(Class<?> annotatedClass) {
    //spring的特点，真正实现的都是do开头的方法
    doRegisterBean(annotatedClass, null, null, null);
}

 void doRegisterBean(Class annotatedClass, @Nullable Supplier instanceSupplier, @Nullable String name,
   @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
    //将class封装到bean定义中
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    //由于配置类并未使用@Conditional注解，直接返回false
    if (this.conditionevaluator.shouldSkip(abd.getmetadata())) {
 return;
    }

    abd.setInstanceSupplier(instanceSupplier);
    //解析bean定义的作用域
    Scopemetadata scopemetadata = this.scopemetadataResolver.resolveScopemetadata(abd);
    abd.setScope(scopemetadata.getScopeName());
    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    //处理普通的bean定义注解，@Lazy @Primary @DependsOn @Role @Description
    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);
    //根据scopemetadata中的proxy-mode属性判断是否需要进行代理封装，默认否
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopemetadata, definitionHolder, this.registry);
    //将bean定义注册到容器中
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}