Pre

Spring5源码 - 04 invokeBeanFactoryPostProcessors 源码解读_1

Spring5源码 - 05 invokeBeanFactoryPostProcessors 源码解读_2

细说invokeBeanDefinitionRegistryPostProcessors

前两篇博文我们过了一下这个方法的主干流程，其中有个关键的方法，我们没有细说就是这个invokeBeanDefinitionRegistryPostProcessors。

这个方法很重要，本篇博文我们就一起来剖析下。

话不多说，还是下来梳理主干流程，然后再对着源码过一遍

流程图

我们来看流程图

源码分析

我们从头跟一下

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

进入到AnnotationConfigApplicationContext的构造函数中

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    //调用构造函数
    this();
    //注册我们的配置类
    register(annotatedClasses);
    //IOC容器刷新接口
    refresh();
  }

这里我们关注refresh方法，这个方法太重要了，里面非常深的调用链，我们这里先有个大概的认知

@Override
  public void refresh() throws BeansException, IllegalStateException { 
      //1:准备刷新上下文环境
      prepareRefresh();
      //2:获取告诉子类初始化Bean工厂
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      //3:对bean工厂进行填充属性
      prepareBeanFactory(beanFactory);
      try {
        // 第四:留个子类去实现该接口
        postProcessBeanFactory(beanFactory);
        // 调用我们的bean工厂的后置处理器.
        invokeBeanFactoryPostProcessors(beanFactory);
        // 调用我们bean的后置处理器
        registerBeanPostProcessors(beanFactory);
        // 初始化国际化资源处理器.
        initMessageSource();
        // 创建事件多播器
        initApplicationEventMulticaster();
        // 这个方法同样也是留个子类实现的springboot也是从这个方法进行启动tomat的.
        onRefresh();
        //把我们的事件监听器注册到多播器上
        registerListeners();
        //实例化我们剩余的单实例bean.
        finishBeanFactoryInitialization(beanFactory);
        // 最后容器刷新 发布刷新事件(Spring cloud也是从这里启动的)
        finishRefresh();
      }
  }

我们先重点关注【invokeBeanFactoryPostProcessors(beanFactory);】

跟进去，重点看 invokeBeanFactoryPostProcessors

//传入bean工厂和获取applicationContext中的bean工厂后置处理器(但是由于没有任何实例化过程,所以传递进来的为空)
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

继续，重点关注

invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

这个方法就是我们今天要研究的源码

/**
   * Invoke the given BeanDefinitionRegistryPostProcessor beans.
   */
  private static void invokeBeanDefinitionRegistryPostProcessors(
      Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
    //获取容器中的ConfigurationClassPostProcessor的后置处理器进行bean定义的扫描
    for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
      postProcessor.postProcessBeanDefinitionRegistry(registry);
    }
  }

这里就一个，那就是 ConfigurationClassPostProcessor

仅需跟进去，看ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry方法

//真正的解析我们的bean定义
 processConfigBeanDefinitions(registry);

这个方法主要干的三件事儿

找到开发人员传入主配置类
创建一个配置类解析器对象

解析我们的配置类 parser.parse(candidates);
把解析出来的配置类注册到容器中 this.reader.loadBeanDefinitions(configClasses);

我们重点关注第三步和第四步

先看第三步

解析配置类 parser.parse(candidates)

所以重点看

parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());

跟进去

  /**
   * 真的解析我们的配置类
   * @param metadata 配置类的源信息
   * @param beanName 当前配置类的beanName
   * @throws IOException
   */
  protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
    /**
     * 第一步:把我们的配置类源信息和beanName包装成一个ConfigurationClass 对象
     */
    processConfigurationClass(new ConfigurationClass(metadata, beanName));
  }

进入

关注

sourceClass = doProcessConfigurationClass(configClass, sourceClass);

这里面就是处理各种注解【@propertySource、@ComponentScan 、@Import、@ImportResource、@Bean】的地方，我们来看下源码

@Nullable
  protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
      throws IOException {
    // Recursively process any member (nested) classes first
    processMemberClasses(configClass, sourceClass);
    //处理我们的@propertySource注解的
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), PropertySources.class,
        org.springframework.context.annotation.PropertySource.class)) {
      if (this.environment instanceof ConfigurableEnvironment) {
        processPropertySource(propertySource);
      }
      else {
        logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
            "]. Reason: Environment must implement ConfigurableEnvironment");
      }
    }
    //解析我们的 @ComponentScan 注解
    //从我们的配置类上解析处ComponentScans的对象集合属性
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    if (!componentScans.isEmpty() &&
        !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
      //循环解析 我们解析出来的AnnotationAttributes
      for (AnnotationAttributes componentScan : componentScans) {
        //把我们扫描出来的类变为bean定义的集合 真正的解析
        Set<BeanDefinitionHolder> scannedBeanDefinitions =
            this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
        //循环处理我们包扫描出来的bean定义
        for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
          BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
          if (bdCand == null) {
            bdCand = holder.getBeanDefinition();
          }
          //判断当前扫描出来的bean定义是不是一个配置类,若是的话 直接进行递归解析
          if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
            //递归解析
            parse(bdCand.getBeanClassName(), holder.getBeanName());
          }
        }
      }
    }
    // 处理 @Import annotations
    processImports(configClass, sourceClass, getImports(sourceClass), true);
    // 处理 @ImportResource annotations
    AnnotationAttributes importResource =
        AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    if (importResource != null) {
      String[] resources = importResource.getStringArray("locations");
      Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
      for (String resource : resources) {
        String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
        configClass.addImportedResource(resolvedResource, readerClass);
      }
    }
    // 处理 @Bean methods 获取到我们配置类中所有标注了@Bean的方法
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
      configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }
    // 处理配置类接口的
    processInterfaces(configClass, sourceClass);
    // 处理配置类的父类的
    if (sourceClass.getMetadata().hasSuperClass()) {
      String superclass = sourceClass.getMetadata().getSuperClassName();
      if (superclass != null && !superclass.startsWith("java") &&
          !this.knownSuperclasses.containsKey(superclass)) {
        this.knownSuperclasses.put(superclass, configClass);
        // Superclass found, return its annotation metadata and recurse
        return sourceClass.getSuperClass();
      }
    }
    // 没有父类解析完成
    return null;
  }

配置类注册到容器中 this.reader.loadBeanDefinitions(configClasses)

第三步完成了，我们来看下这一步Spring是如和把配置类注册到容器中的

  public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
    //注册我们的配置类到容器中
    for (ConfigurationClass configClass : configurationModel) {
      loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
    }
  }

那自然就是

loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);

很清晰哈

一个个的看下吧

注册@Import的bean

  private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
    //获取我们的配置类的源信息
    AnnotationMetadata metadata = configClass.getMetadata();
    //构建为我们的bean定义
    AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);
    //设置他的scope
    ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
    configBeanDef.setScope(scopeMetadata.getScopeName());
    //获取bean的名称
    String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);
    //处理我们的JRS250组件的
    AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    //注册我们的bean定义到我们的容器中
    this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());
    configClass.setBeanName(configBeanName);
    if (logger.isDebugEnabled()) {
      logger.debug("Registered bean definition for imported class '" + configBeanName + "'");
    }
  }

重点就是

this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.

注册@Bean的bean

处理@Bean可以跟的各种属性

注册@ImportResources的bean

private void loadBeanDefinitionsFromImportedResources(
            Map<String, Class<? extends BeanDefinitionReader>> importedResources) {
    // reader实例缓存
    Map<Class<?>, BeanDefinitionReader> readerInstanceCache = new HashMap<>();
    // 循环处理<配置文件路径-reader>
    importedResources.forEach((resource, readerClass) -> {
        // 如果注解配置的Reader是默认的（我们一般其实也不改）
        if (BeanDefinitionReader.class == readerClass) {
            if (StringUtils.endsWithIgnoreCase(resource, ".groovy")) {
                // 如果文件名是.groovy结尾，则使用GroovyBeanDefinitionReader
                // 说实话我也第一次知道还可以用groovy脚本来做spring的配置文件
                // 后面我去看了一下BeanDefinitionReader这个接口的实现类，发现还一个
                // PropertiesBeanDefinitionReader，感兴趣的同学可以去研究一下
                readerClass = GroovyBeanDefinitionReader.class;
            }
            else {
                // 默认情况下我们使用XmlBeanDefinitionReader  
                readerClass = XmlBeanDefinitionReader.class;
            }
        }
        // 先从缓存拿
        BeanDefinitionReader reader = readerInstanceCache.get(readerClass);
        if (reader == null) {
            try {
                // 拿不到就新建一个，配置的reader类必须有一个只有BeanDefinitionRegistry参数的构造器
                reader = readerClass.getConstructor(BeanDefinitionRegistry.class).newInstance(this.registry);
                // Delegate the current ResourceLoader to it if possible
                if (reader instanceof AbstractBeanDefinitionReader) {
                    AbstractBeanDefinitionReader abdr = ((AbstractBeanDefinitionReader) reader);
                    abdr.setResourceLoader(this.resourceLoader);
                    abdr.setEnvironment(this.environment);
                }
                readerInstanceCache.put(readerClass, reader);
            }
            catch (Throwable ex) {
                throw new IllegalStateException(
                    "Could not instantiate BeanDefinitionReader class [" + readerClass.getName() + "]");
            }
        }
        // 使用reader从文件加载bean
        reader.loadBeanDefinitions(resource);
    });
}

默认情况下是创建一个XmlBeanDefinitionReader来解析加载我们的配置文件中定义的bean的。

注册ImportBeanDefinition的bean

  private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
    registrars.forEach((registrar, metadata) ->
        registrar.registerBeanDefinitions(metadata, this.registry));
  }

很直观了哈，循环直接调用ImportBeanDefinitionRegistrar.registerBeanDefinitions方法进行beanDefinition的注册。

Spring5源码 - 05 invokeBeanFactoryPostProcessors 源码解读_3细说invokeBeanDefinitionRegistryPostProcessors

Pre

细说invokeBeanDefinitionRegistryPostProcessors

流程图

源码分析

解析配置类 parser.parse(candidates)

配置类注册到容器中 this.reader.loadBeanDefinitions(configClasses)

注册@Import的bean

注册@Bean的bean

注册@ImportResources的bean

注册ImportBeanDefinition的bean

热门文章

最新文章

相关课程

相关电子书

相关实验场景