曹工说Spring Boot源码（30）– ConfigurationClassPostProcessor 实在太硬核了，为了了解它，我可能debug了快一天

• 2020 年 7 月 25 日
• 笔记
• spring/boot源码解析

写在前面的话

相关背景及资源：

曹工说Spring Boot源码（1）– Bean Definition到底是什么，附spring思维导图分享

曹工说Spring Boot源码（2）– Bean Definition到底是什么，咱们对着接口，逐个方法讲解

曹工说Spring Boot源码（3）– 手动注册Bean Definition不比游戏好玩吗，我们来试一下

曹工说Spring Boot源码（4）– 我是怎么自定义ApplicationContext，从json文件读取bean definition的？

曹工说Spring Boot源码（5）– 怎么从properties文件读取bean

曹工说Spring Boot源码（6）– Spring怎么从xml文件里解析bean的

曹工说Spring Boot源码（7）– Spring解析xml文件，到底从中得到了什么（上）

曹工说Spring Boot源码（8）– Spring解析xml文件，到底从中得到了什么（util命名空间）

曹工说Spring Boot源码（9）– Spring解析xml文件，到底从中得到了什么（context命名空间上）

曹工说Spring Boot源码（10）– Spring解析xml文件，到底从中得到了什么（context:annotation-config 解析）

曹工说Spring Boot源码（11）– context:component-scan，你真的会用吗（这次来说说它的奇技淫巧）

曹工说Spring Boot源码（12）– Spring解析xml文件，到底从中得到了什么（context:component-scan完整解析)

曹工说Spring Boot源码（13）– AspectJ的运行时织入（Load-Time-Weaving），基本内容是讲清楚了（附源码）

曹工说Spring Boot源码（14）– AspectJ的Load-Time-Weaving的两种实现方式细细讲解，以及怎么和Spring Instrumentation集成

曹工说Spring Boot源码（15）– Spring从xml文件里到底得到了什么（context：load-time-weaver 完整解析）

曹工说Spring Boot源码（16）– Spring从xml文件里到底得到了什么（aop：config完整解析【上】）

曹工说Spring Boot源码（17）– Spring从xml文件里到底得到了什么（aop：config完整解析【中】）

曹工说Spring Boot源码（18）– Spring AOP源码分析三部曲，终于快讲完了 (aop：config完整解析【下】)

曹工说Spring Boot源码（19）– Spring 带给我们的工具利器，创建代理不用愁（ProxyFactory）

曹工说Spring Boot源码（20）– 码网恢恢，疏而不漏，如何记录Spring RedisTemplate每次操作日志

曹工说Spring Boot源码（21）– 为了让大家理解Spring Aop利器ProxyFactory，我已经拼了

曹工说Spring Boot源码（22）– 你说我Spring Aop依赖AspectJ，我依赖它什么了

曹工说Spring Boot源码（23）– ASM又立功了，Spring原来是这么递归获取注解的元注解的

曹工说Spring Boot源码（24）– Spring注解扫描的瑞士军刀，asm技术实战（上）

曹工说Spring Boot源码（25）– Spring注解扫描的瑞士军刀，ASM + Java Instrumentation，顺便提提Jar包破解

曹工说Spring Boot源码（26）– 学习字节码也太难了，实在不能忍受了，写了个小小的字节码执行引擎

曹工说Spring Boot源码（27）– Spring的component-scan，光是include-filter属性的各种配置方式，就够玩半天了

曹工说Spring Boot源码（28）– Spring的component-scan机制，让你自己来进行简单实现，怎么办

曹工说Spring Boot源码（29）– Spring 解决循环依赖为什么使用三级缓存，而不是二级缓存

工程代码地址 思维导图地址

工程结构图：

本篇前言

本篇是单独基于spring-boot 2.1.7.RELEASE的版本写的，本来没有这篇文章的，本来正在写遇到的一个eureka client的问题，然后有一个eureka的自动配置类，我当时准备讲解一下：

@Configuration
@EnableConfigurationProperties
@ConditionalOnClass(EurekaClientConfig.class)
@Import(DiscoveryClientOptionalArgsConfiguration.class)
@ConditionalOnBean(EurekaDiscoveryClientConfiguration.Marker.class)
@ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true)
@ConditionalOnDiscoveryEnabled
@AutoConfigureBefore({ NoopDiscoveryClientAutoConfiguration.class,
		CommonsClientAutoConfiguration.class, ServiceRegistryAutoConfiguration.class })
@AutoConfigureAfter(name = {
		"org.springframework.cloud.autoconfigure.RefreshAutoConfiguration"})
public class EurekaClientAutoConfiguration {

结果，我发现，对于这一坨注解的执行顺序，我并不是很了解，本来以为是spring.factories里配置了这个类，因此最早的入口是在那里，结果，实际debug起来，发现好像并不是，而是由另外一个eureka的自动配置类触发的。

因此，纠结半天，干脆好好好好学研究下spring boot/cloud下configuration类的处理过程。

测试代码

就是一个普通的spring boot下的eureka client程序，pom大致如下

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Greenwich.SR5</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web </artifactId>
		</dependency>

	</dependencies>

一个误会

一点点常识，大家可能都知道ConfigurationClassPostProcessor，这个类，负责处理各种@configuration注解配置的类（full模式），也包括轻量模式下的配置类（没有@configuration配置，但是有@bean方法等）。

ConfigurationClassPostProcessor实现了如下接口：

实现了BeanDefinitionRegistryPostProcessor，总体来说，是对beanDefinition进行各种后置处理，比如增删改beanDefinition。

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	/**
	 * Modify the application context's internal bean definition registry after its
	 * standard initialization. All regular bean definitions will have been loaded,
	 * but no beans will have been instantiated yet. This allows for adding further
	 * bean definitions before the next post-processing phase kicks in.
	 * @param registry the bean definition registry used by the application context
	 * @throws org.springframework.beans.BeansException in case of errors
	 */
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

这个方法，就是对beanFactory进行后置处理，而后置处理主要干啥呢，就是增加beanDefinition，比如我们一个类A上，注解@configuration，同时注解@Import，导入了其他类。

那么，就在这个方法中，就会去扫描configuration配置的类，比如扫描到类A，然后去获取类A上的注解，然后递归获取类A上的注解的元注解，最终检查其中：是否有PropertySource、是否有ComponentScan、是否有Import、是否有@bean方法等等，去获取更多的beanDefinition回来，并注册到beanFactory。

因此，入口基本就是在 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry。

因此，我把断点打在 ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry，准备把这个各种注解的处理顺序搞清楚。

结果，我跟了大半天，还了解了：

在spring cloud下，是有两个applicationContext（如果有feign调用，会有更多，这里暂不考虑）。

其中一个，就是bootStrap applicationContext；另外一个，才是应用程序本身的applicationContext。

而且，bootStrap applicationContext 是应用本身的applicationContext的parent。

我一开始没注意到有两个，因为我以为只有配置了bootStrap.yml才会有；结果跟了很久，都没到我的应用的类，才意识到这个问题。

所以呢，跟了半天多的东西，其实是bootStrap applicationContext的东西，不过代码逻辑都是一样的；而且，学习bootStrap applicationContext也很有必要。

let‘s start

org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
/**
 * Derive further bean definitions from the configuration classes in the registry.
 */
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
   int registryId = System.identityHashCode(registry);
	...
   this.registriesPostProcessed.add(registryId);

   processConfigBeanDefinitions(registry);
}

这里没多少东西，主要就是最后一行开始：

org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

该方法比较长，其实是ConfigurationClassPostProcessor太核心了，几乎是spring boot的基石，所以只能分为多个部分来顺序讲解。

获取候选bean集合

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
   String[] candidateNames = registry.getBeanDefinitionNames();

断点显示，这里获取到了，如下candidate：

过滤出configuration注解的类

for (String beanName : candidateNames) {
   BeanDefinition beanDef = registry.getBeanDefinition(beanName);
   if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
         ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
      if (logger.isDebugEnabled()) {
         logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
      }
   }
   else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
      configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
   }
}

上面的几个候选类，经过这里筛选后，只剩下一个满足条件的bean。

bootstrapImportSelectorConfiguration

生成configuration类解析器

ConfigurationClassParser parser = new ConfigurationClassParser(
      this.metadataReaderFactory, this.problemReporter, this.environment,
      this.resourceLoader, this.componentScanBeanNameGenerator, registry);

这个类，没有继承任何类，也没有实现任何接口

public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,
			ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader,BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry) {

		this.metadataReaderFactory = metadataReaderFactory;
		this.problemReporter = problemReporter;
		this.environment = environment;
		this.resourceLoader = resourceLoader;
		this.registry = registry;
        // 1
		this.componentScanParser = new ComponentScanAnnotationParser(
				environment, resourceLoader, componentScanBeanNameGenerator, registry);
        // 2
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
	}

这里1处，new了一个bean扫描解析器。

	public ComponentScanAnnotationParser(Environment environment, ResourceLoader resourceLoader,
			BeanNameGenerator beanNameGenerator, BeanDefinitionRegistry registry) {

		this.environment = environment;
		this.resourceLoader = resourceLoader;
		this.beanNameGenerator = beanNameGenerator;
		this.registry = registry;
	}

2处，创建了一个condition计算器，负责各种@condition的解析计算。

public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
      @Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {

   this.context = new ConditionContextImpl(registry, environment, resourceLoader);
}

使用ConfigurationClassParser循环解析

do {
   // 1
   parser.parse(candidates);
   parser.validate();

   Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
   configClasses.removeAll(alreadyParsed);

   // Read the model and create bean definitions based on its content
   if (this.reader == null) {
      this.reader = new ConfigurationClassBeanDefinitionReader(
            registry, this.sourceExtractor, this.resourceLoader, this.environment,
            this.importBeanNameGenerator, parser.getImportRegistry());
   }
   this.reader.loadBeanDefinitions(configClasses);
   alreadyParsed.addAll(configClasses);

   candidates.clear();
   if (registry.getBeanDefinitionCount() > candidateNames.length) {
      String[] newCandidateNames = registry.getBeanDefinitionNames();
      Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
      Set<String> alreadyParsedClasses = new HashSet<>();
      for (ConfigurationClass configurationClass : alreadyParsed) {
         alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
      }
      for (String candidateName : newCandidateNames) {
         if (!oldCandidateNames.contains(candidateName)) {
            BeanDefinition bd = registry.getBeanDefinition(candidateName);
            if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                  !alreadyParsedClasses.contains(bd.getBeanClassName())) {
               candidates.add(new BeanDefinitionHolder(bd, candidateName));
            }
         }
      }
      candidateNames = newCandidateNames;
   }
}
while (!candidates.isEmpty());

接下来，先进入1处。

ConfigurationClassParser#parse

注意，进入此处时，参数configCandidates的值为：

该holder中，就包含beanName和beanDefinition，其中bean对应的class类型为：

org.springframework.cloud.bootstrap.BootstrapImportSelectorConfiguration

public void parse(Set<BeanDefinitionHolder> configCandidates) {
   for (BeanDefinitionHolder holder : configCandidates) {
      BeanDefinition bd = holder.getBeanDefinition();
      try {
         if (bd instanceof AnnotatedBeanDefinition) {
            // 1
            parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
         }
         else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
            parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
         }
         else {
            parse(bd.getBeanClassName(), holder.getBeanName());
         }
      }
   }

   this.deferredImportSelectorHandler.process();
}

这里会进入1处。

在进入该方法前，获取了beanDefinition中的MetaData。

(AnnotatedBeanDefinition) bd).getMetadata()

protected final void parse(AnnotationMetadata metadata, String beanName)  {
   processConfigurationClass(new ConfigurationClass(metadata, beanName));
}

这里先去new了一个ConfigurationClass。

public ConfigurationClass(AnnotationMetadata metadata, String beanName) {
		Assert.notNull(beanName, "Bean name must not be null");
		this.metadata = metadata;
		this.resource = new DescriptiveResource(metadata.getClassName());
		this.beanName = beanName;
	}

这个类，主要是对于@configuration注解标注的类的封装。

/**
 * Represents a user-defined {@link Configuration @Configuration} class.
 * Includes a set of {@link Bean} methods, including all such methods
 * defined in the ancestry of the class, in a 'flattened-out' manner.
 *
 */
final class ConfigurationClass {

开始解析

org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
    
protected void processConfigurationClass(ConfigurationClass configClass) {
   // 1
   if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
      return;
}

1处，使用condition计算器，进行判断，看看该bean是否满足

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
   if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
      return false;
   }

因为org.springframework.cloud.bootstrap.BootstrapImportSelectorConfiguration类上，并没有condition注解，所以是默认生效的。

接下来进入下面的地方：

protected void processConfigurationClass(ConfigurationClass configClass){
    	// 0
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}
		
    	// 1
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
		if (existingClass != null) {
			if (configClass.isImported()) {
				if (existingClass.isImported()) {
					existingClass.mergeImportedBy(configClass);
				}
				return;
			}
			else {
				this.configurationClasses.remove(configClass);
				this.knownSuperclasses.values().removeIf(configClass::equals);
			}
		}

		// 2
		SourceClass sourceClass = asSourceClass(configClass);
		do {
            // 3
			sourceClass = doProcessConfigurationClass(configClass, sourceClass);
		}
		while (sourceClass != null);

		this.configurationClasses.put(configClass, configClass);
	}

• 0，就是前面说的判断condition是否满足

• 1，此时不满足条件，直接跳过

• 2，这里根据注解信息，获取sourceClass,不用细究

  private SourceClass asSourceClass(ConfigurationClass configurationClass){
     AnnotationMetadata metadata = configurationClass.getMetadata();
     if (metadata instanceof StandardAnnotationMetadata) {
        return asSourceClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
     }
     return asSourceClass(metadata.getClassName());
  }
  

• 3处，继续解析。

  这个类较长，我们下面细讲。

doProcessConfigurationClass

  protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass){
  // 3.1
     if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
      //3.2 Recursively process any member (nested) classes first
        processMemberClasses(configClass, sourceClass);
     }

这里实际上，会进入3.1处。因为这个类上，加了@configuration注解的。

  @Configuration
  @Import(BootstrapImportSelector.class)
  public class BootstrapImportSelectorConfiguration {
  }

处理member类

然后3.2处，member类处理，这里暂时不太清楚member类是什么，不过我们这个BootstrapImportSelectorConfiguration也没有获取到任何的member class，所以先跳过。

处理PropertySource

接下来，开始解析bean的class上，是否注解了PropertySource.

// Process any @PropertySource annotations
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(PropertySource.class)) {
    if (this.environment instanceof ConfigurableEnvironment) {
        processPropertySource(propertySource);
    }
}

这里，我们并没有注解PropertySource，所以也会跳过。

处理componnet-scan

这里也没有，跳过。

处理@imort

processImports(configClass, sourceClass, getImports(sourceClass), true);

在processImports之前，这里第三个参数，先去调用了getImports。

getImports

/**
 * Returns {@code @Import} class, considering all meta-annotations.
 */
private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
   Set<SourceClass> imports = new LinkedHashSet<>();
   Set<SourceClass> visited = new LinkedHashSet<>();
   collectImports(sourceClass, imports, visited);
   return imports;
}

private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
      throws IOException {

   if (visited.add(sourceClass)) {
      for (SourceClass annotation : sourceClass.getAnnotations()) {
         String annName = annotation.getMetadata().getClassName();
         if (!annName.equals(Import.class.getName())) {
            // 1
            collectImports(annotation, imports, visited);
         }
      }
      // 2
      imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
   }
}

• 1，递归调用自己，获取@Import注解

• 2，将@import注解中value的值取出来，放到imports中。

  这里处理完成后，我们获取到的东西如下：

  

  即：

  org.springframework.cloud.bootstrap.BootstrapImportSelector
  

processImport

processImports(configClass, sourceClass, getImports(sourceClass), true);

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,   Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

   if (importCandidates.isEmpty()) {
      return;
   }

    this.importStack.push(configClass);
    try {
        // 0
        for (SourceClass candidate : importCandidates) {
            // 1
            if (candidate.isAssignable(ImportSelector.class)) {
                // Candidate class is an ImportSelector -> delegate to it to determine imports
                Class<?> candidateClass = candidate.loadClass();
                ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
                ParserStrategyUtils.invokeAwareMethods(
                    selector, this.environment, this.resourceLoader, this.registry);
                if (selector instanceof DeferredImportSelector) {
                    this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                }
                else {
                    String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                    Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
                    processImports(configClass, currentSourceClass, importSourceClasses, false);
                }
            }
            // 2
            else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                // Candidate class is an ImportBeanDefinitionRegistrar ->
                // delegate to it to register additional bean definitions
                Class<?> candidateClass = candidate.loadClass();
                ImportBeanDefinitionRegistrar registrar =
                    BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
                ParserStrategyUtils.invokeAwareMethods(
                    registrar, this.environment, this.resourceLoader, this.registry);
                configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
            }
            else {
                // 3
                // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
                // process it as an @Configuration class
                this.importStack.registerImport(
                    currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                processConfigurationClass(candidate.asConfigClass(configClass));
            }
        }
    }
}

• 1处，当要import的是ImportSelector接口时
• 2处，当要import的bean class是：ImportBeanDefinitionRegistrar
• 3处，当要import的是普通的configuration class时。

我们这里这个类，是实现了DeferredImportSelector，间接实现了ImportSelector：

public class BootstrapImportSelector implements EnvironmentAware, DeferredImportSelector

所以要进入下面这一坨逻辑：

        for (SourceClass candidate : importCandidates) {
            // 1
            if (candidate.isAssignable(ImportSelector.class)) {
                //2  Candidate class is an ImportSelector -> delegate to it to determine imports			
                Class<?> candidateClass = candidate.loadClass();
                // 3
                ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
                // 4
                ParserStrategyUtils.invokeAwareMethods(
                    selector, this.environment, this.resourceLoader, this.registry);
                // 5
                if (selector instanceof DeferredImportSelector) {
                    // 6
                    this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                }
                else {
                    String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                    Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
                    processImports(configClass, currentSourceClass, importSourceClasses, false);
                }
            }

• 1, 判断如果是实现了ImportSelector
• 2，加载对应的bean class
• 3，通过反射实例化该bean
• 4，调用aware方法，注入environment等
• 5，判断是否为DeferredImportSelector，该类型需要被延迟import
• 6，处理该DeferredImportSelector

6处，使用专门的handler，来处理DeferredImportSelector类型的bean。

public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
   // 1
   DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(
         configClass, importSelector);
   if (this.deferredImportSelectors == null) {
      DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
      handler.register(holder);
      handler.processGroupImports();
   }
   else {
      // 2
      this.deferredImportSelectors.add(holder);
   }
}

• 1，将configClass，和importSelector放进一个holder中。

  public DeferredImportSelectorHolder(ConfigurationClass configClass, DeferredImportSelector selector) {
     this.configurationClass = configClass;
     this.importSelector = selector;
  }
  

• 2，往如下的list中，添加一个holder实例。

  @Nullable
  private List<DeferredImportSelectorHolder> deferredImportSelectors = new ArrayList<>();
  

到这里，基本@import就处理完了，因为前面这个importSelector是deferred类型，是需要延期处理的，所以，加入该list后，处理结束。

处理@bean方法

这里没有bean方法，跳过。

处理接口中的默认方法

这个暂时不涉及，跳过。

处理deferredImportSelector

org.springframework.context.annotation.ConfigurationClassParser#parse
    
public void parse(Set<BeanDefinitionHolder> configCandidates) {
   // 0
   for (BeanDefinitionHolder holder : configCandidates) {
      BeanDefinition bd = holder.getBeanDefinition();
      try {
         if (bd instanceof AnnotatedBeanDefinition) {
            // 1
            parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
         }
         else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
            parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
         }
         else {
            parse(bd.getBeanClassName(), holder.getBeanName());
         }
      }
   }
	// 2
   this.deferredImportSelectorHandler.process();
}

接下来，我们回到之前的代码，1处的parse方法终于处理结束了，本来应该进入0处的下一轮循环，但是这里因为集合中只有那么一个元素：bootstrapImportSelectorConfiguration。所以这步就算处理完了。

进入到2处。

org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#process
    
public void process() {
   List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
   this.deferredImportSelectors = null;
   try {
      if (deferredImports != null) {
         //1
         DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
         // 2
         deferredImports.forEach(handler::register);
         // 3
         handler.processGroupImports();
      }
   }
   finally {
      this.deferredImportSelectors = new ArrayList<>();
   }
}

• 1，new了一个handler，专门处理这种延迟导入的bean selector
• 2，对需要延迟导入的bean selector，进行遍历，然后调用handler的register
• 3，调用handler的批量import方法。

我们对2处和3处重点讲解。

handler::registered

public void register(DeferredImportSelectorHolder deferredImport) {
   // 0
   Class<? extends Group> group = deferredImport.getImportSelector()
         .getImportGroup();
   // 1
   DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
         (group != null ? group : deferredImport),
         key -> new DeferredImportSelectorGrouping(createGroup(group)));
   // 2
   grouping.add(deferredImport);
   this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
         deferredImport.getConfigurationClass());
}

• 0，从holder二元组中，获取importSelector，然后获取其importGroup。

  这里的group为null。

  public interface DeferredImportSelector extends ImportSelector {
  
     /**
      * Return a specific import group.
      * <p>The default implementations return {@code null} for no grouping required.
      * @return the import group class, or {@code null} if none
      * @since 5.0
      */
     @Nullable
     default Class<? extends Group> getImportGroup() {
        return null;
     }
  

• 1处，比较复杂。

  这里有个field:

  private final Map<Object, DeferredImportSelectorGrouping> groupings = new LinkedHashMap<>();
  

  1处我们可以看出，是在往上面这个map，放东西。

  key：(group != null ? group : deferredImport)

  因为我们这里group为null，所以这里的key为：DeferredImportSelectorHolder deferredImport，也就是那个二元组。

  value是啥呢？

  key -> new DeferredImportSelectorGrouping(createGroup(group))
  

  我们先看看createGroup吧：

  private Group createGroup(@Nullable Class<? extends Group> type) {
     // 1
     Class<? extends Group> effectiveType = (type != null ? type
           : DefaultDeferredImportSelectorGroup.class);
     Group group = BeanUtils.instantiateClass(effectiveType);
     ParserStrategyUtils.invokeAwareMethods(group,
           ConfigurationClassParser.this.environment,
           ConfigurationClassParser.this.resourceLoader,
           ConfigurationClassParser.this.registry);
     return group;
  }
  

  1处，因为我们传入的参数：type为null，所以这里场景了一个DefaultDeferredImportSelectorGroup的实例，填充Aware字段后，返回。

  然后，我们利用createGroup返回的实例，传给了：

  key -> new DeferredImportSelectorGrouping(createGroup(group))
  

  然后看看这个类呢：

  private static class DeferredImportSelectorGrouping {
  
     private final DeferredImportSelector.Group group;
  
     private final List<DeferredImportSelectorHolder> deferredImports = new ArrayList<>();
     // 1
     DeferredImportSelectorGrouping(Group group) {
        this.group = group;
     }
  

• 2，我们上面一步，往map里放了个key、value。

  private final Map<Object, DeferredImportSelectorGrouping> groupings = new LinkedHashMap<>();
  

• 3，现在需要往value（类型为DeferredImportSelectorGrouping），加入一个延迟importSelector的holder

  public void register(DeferredImportSelectorHolder deferredImport) {
     Class<? extends Group> group = deferredImport.getImportSelector()
           .getImportGroup();
     DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
           (group != null ? group : deferredImport),
           key -> new DeferredImportSelectorGrouping(createGroup(group)));
     // 
     grouping.add(deferredImport);
     this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
           deferredImport.getConfigurationClass());
  }
  

  org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGrouping#add
  public void add(DeferredImportSelectorHolder deferredImport) {
     this.deferredImports.add(deferredImport);
  }
  

• 注册

  public void register(DeferredImportSelectorHolder deferredImport) {
     Class<? extends Group> group = deferredImport.getImportSelector()
           .getImportGroup();
     DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
           (group != null ? group : deferredImport),
           key -> new DeferredImportSelectorGrouping(createGroup(group)));
     grouping.add(deferredImport);
     // 4
     this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
           deferredImport.getConfigurationClass());
  }
  

  然后进入到上面的4处，这里把这个延迟importSelector的metadata作为key，configurationClass作为value，放进map。

  private class DeferredImportSelectorGroupingHandler {
  
     private final Map<Object, DeferredImportSelectorGrouping> groupings = new LinkedHashMap<>();
     // 1
     private final Map<AnnotationMetadata, ConfigurationClass> configurationClasses = new HashMap<>();
  

  即上面1处这个map。

进行group import

public void process() {
   List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
   this.deferredImportSelectors = null;
   try {
      if (deferredImports != null) {
         DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
         deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
         // 0
         deferredImports.forEach(handler::register);
         // 1
         handler.processGroupImports();
      }
   }
   finally {
      this.deferredImportSelectors = new ArrayList<>();
   }
}

前面已经把0处，讲解完毕；这里进入1处。

org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports
    
private Map<Object, DeferredImportSelectorGrouping> groupings = new LinkedHashMap<>();    
public void processGroupImports() {
   // 1
   for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
      // 2
      grouping.getImports().forEach(entry -> {
         ConfigurationClass configurationClass = this.configurationClasses.get(
               entry.getMetadata());
         try {
            processImports(configurationClass, asSourceClass(configurationClass),
                  asSourceClasses(entry.getImportClassName()), false);
         }
      });
   }
}

• 1处，我们这里遍历groupings这个map的value集合

• 2，获取这个grouping中的要import的集合

  org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGrouping#getImports
  
  private final List<DeferredImportSelectorHolder> deferredImports = new ArrayList<>();
  /**
   * Return the imports defined by the group.
   * @return each import with its associated configuration class
   */
  public Iterable<Group.Entry> getImports() {
      // 1
     for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
        // 2
        this.group.process(deferredImport.getConfigurationClass().getMetadata(),
              deferredImport.getImportSelector());
     }
     return this.group.selectImports();
  }
  

  • 1，遍历全部的holder
  • 2，获取holder中的，这个importSelector的类的元数据，和importSelector本身，传给this.group.process方法。

  我们看看这里的process方法

  org.springframework.context.annotation.ConfigurationClassParser.DefaultDeferredImportSelectorGroup
      
  private static class DefaultDeferredImportSelectorGroup implements Group {
  
     private final List<Entry> imports = new ArrayList<>();
  
     @Override
     public void process(AnnotationMetadata metadata, DeferredImportSelector selector) {
        // 1
        for (String importClassName : selector.selectImports(metadata)) {
           this.imports.add(new Entry(metadata, importClassName));
        }
     }
  
     @Override
     public Iterable<Entry> selectImports() {
        return this.imports;
     }
  }
  

  这里的1处，即调用了selector接口的方法了

  public interface ImportSelector {
  
     /**
      * Select and return the names of which class(es) should be imported based on
      * the {@link AnnotationMetadata} of the importing @{@link Configuration} class.
      */
     String[] selectImports(AnnotationMetadata importingClassMetadata);
  
  }
  

  1处的selector.selectImports，我们可以看到，传进去了一个metadata,这个metaData都有啥数据呢？

  

  我们再看一眼下面这个类：

  @Configuration
  @Import(BootstrapImportSelector.class)
  public class BootstrapImportSelectorConfiguration {
  
  }
  

  所以，传入的metaData就是这个被@Import注解，注解了的类的信息。

  相当于说，你在类A上加上@Import注解，那么最终类A的信息，会被当做参数，传给ImportSelector的selectImports方法。

BootstrapImportSelector

前面说到了这个selector实现了DeferredImportSelector，我们看看怎么实现的吧：

public class BootstrapImportSelector implements EnvironmentAware, DeferredImportSelector {

   private Environment environment;

   private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory();

   @Override
   public void setEnvironment(Environment environment) {
      this.environment = environment;
   }

   @Override
   public String[] selectImports(AnnotationMetadata annotationMetadata) {
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
      // 1
      List<String> names = new ArrayList<>(SpringFactoriesLoader
            .loadFactoryNames(BootstrapConfiguration.class, classLoader));
      // 2
      names.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(
            this.environment.getProperty("spring.cloud.bootstrap.sources", ""))));
	  // 3
      List<OrderedAnnotatedElement> elements = new ArrayList<>();
      for (String name : names) {
         try {
            elements.add(
                  // 4
                  new OrderedAnnotatedElement(this.metadataReaderFactory, name));
         }
         catch (IOException e) {
            continue;
         }
      }
      AnnotationAwareOrderComparator.sort(elements);

      String[] classNames = elements.stream().map(e -> e.name).toArray(String[]::new);
	  // 5
      return classNames;
   }

• 1，从spring.factories中，查找以org.springframework.cloud.bootstrap.BootstrapConfiguration为key的property。

  我们目前这个代码中，在如下文件，找到了一处：

  

  然后在eureka的jar包，找到一个：

  

  所以，我们拿到了5个值。

  

• 2处，从spring.cloud.bootstrap.sources属性中获取

• 3处，遍历所有这些要import的类名

• 4处，将类名转换为OrderedAnnotatedElement，这个会获取对应的类的元数据，然后获取其上注解的@order来获取顺序

  OrderedAnnotatedElement(MetadataReaderFactory metadataReaderFactory, String name)
        throws IOException {
     MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(name);
     AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();
     Map<String, Object> attributes = metadata
           .getAnnotationAttributes(Order.class.getName());
     this.name = name;
     if (attributes != null && attributes.containsKey("value")) {
        this.value = (Integer) attributes.get("value");
        this.order = new Order() {
           @Override
           public Class<? extends Annotation> annotationType() {
              return Order.class;
           }
  
           @Override
           public int value() {
              return OrderedAnnotatedElement.this.value;
           }
        };
     }
  }
  

• 5处返回排序后的，要import的class的类名。

将要import的类名，存放起来

private static class DefaultDeferredImportSelectorGroup implements Group {

   private final List<Entry> imports = new ArrayList<>();

   @Override
   public void process(AnnotationMetadata metadata, DeferredImportSelector selector) {
      // 1
      for (String importClassName : selector.selectImports(metadata)) {
         // 2
         this.imports.add(new Entry(metadata, importClassName));
      }
   }

   @Override
   public Iterable<Entry> selectImports() {
      return this.imports;
   }
}

前面讲完了1处，现在看看2处。

2处就是将前面拿到的5个要import的类，加入到这里的imports 集合中。

此时，imports集合如下：

递归处理下一个configuration class

上面我们获取到了5个要import的class。

org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports
    
public void processGroupImports() {
   for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
      // 1
      grouping.getImports().forEach(entry -> {
         ConfigurationClass configurationClass = this.configurationClasses.get(
               entry.getMetadata());
         try {
            processImports(configurationClass, asSourceClass(configurationClass),
                  asSourceClasses(entry.getImportClassName()), false);
         }
      });
   }
}

这里1处的grouping.getImports，就能拿到那5个元素。

这里又去开始循环处理，看下图。

处理PropertySourceBootstrapConfiguration

我们看看这个类

@Configuration
@EnableConfigurationProperties(PropertySourceBootstrapProperties.class)
public class PropertySourceBootstrapConfiguration implements
      ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
      Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

   if (importCandidates.isEmpty()) {
      return;
   }

    this.importStack.push(configClass);
    try {
        for (SourceClass candidate : importCandidates) {
            if (candidate.isAssignable(ImportSelector.class)) {
                // 1
                ...
            }
            else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                // 2
                ...
            }
            else {
                // 3 process it as an @Configuration class
                this.importStack.registerImport(
                    currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                // 4
                processConfigurationClass(candidate.asConfigClass(configClass));
            }
        }
    }
   
}

因为其没有实现ImportSelector等，所以进入3处，当做普通的Configuration类处理。

private static class ImportStack extends ArrayDeque<ConfigurationClass> implements ImportRegistry {

   private final MultiValueMap<String, AnnotationMetadata> imports = new LinkedMultiValueMap<>();
   
   // 
   public void registerImport(AnnotationMetadata importingClass, String importedClass) {
      // 1
      this.imports.add(importedClass, importingClass);
   }

这里直接把其放到map中。

然后进入了前面的4处：

else {
   // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
   // process it as an @Configuration class
   this.importStack.registerImport(
         currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
   // 4
   processConfigurationClass(candidate.asConfigClass(configClass));
}

org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
    
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
   // 1
   if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
      return;
   }

   ...

   // Recursively process the configuration class and its superclass hierarchy.
   SourceClass sourceClass = asSourceClass(configClass);
   do {
       // 2
      sourceClass = doProcessConfigurationClass(configClass, sourceClass);
   }
   while (sourceClass != null);

   this.configurationClasses.put(configClass, configClass);
}

和之前一样，这里，1处，判断是否满足condition注解，因为我们的PropertySourceBootstrapConfiguration，并没有condition，所以是默认生效的。

处理member类

不涉及。

处理PropertySource注解

不涉及。

处理ComponentScan注解

不涉及

处理import注解

由于该类上，加了

@Configuration
@EnableConfigurationProperties(PropertySourceBootstrapProperties.class)
public class PropertySourceBootstrapConfiguration

而：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(EnableConfigurationPropertiesImportSelector.class)
public @interface EnableConfigurationProperties {

所以，处理这里时：

// Process any @Import annotations
processImports(configClass, sourceClass, getImports(sourceClass), true);

在getImports调用，得到如下返回。

org.springframework.boot.context.properties.EnableConfigurationPropertiesImportSelector

然后开始处理该import。

由于其实现了ImportSelector，会进入下面的地方。

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, boolean checkForCircularImports) {



    this.importStack.push(configClass);
    try {
        for (SourceClass candidate : importCandidates) {
            if (candidate.isAssignable(ImportSelector.class)) {
                //1 Candidate class is an ImportSelector -> delegate to it to determine imports
                Class<?> candidateClass = candidate.loadClass();
                ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
                ParserStrategyUtils.invokeAwareMethods(
                    selector, this.environment, this.resourceLoader, this.registry);
                if (selector instanceof DeferredImportSelector) {
                    this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                }
                else {
                    // 2
                    String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                    Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
                    processImports(configClass, currentSourceClass, importSourceClasses, false);
                }
            }

• 1，反射创建该selector

• 2，调用该selector的selectImport方法，得到要import的类

  class EnableConfigurationPropertiesImportSelector implements ImportSelector {
  
     private static final String[] IMPORTS = { ConfigurationPropertiesBeanRegistrar.class.getName(),
           ConfigurationPropertiesBindingPostProcessorRegistrar.class.getName() };
  
     @Override
     public String[] selectImports(AnnotationMetadata metadata) {
        return IMPORTS;
     }
  

  这里，我们就拿到了2个要import的类的类名。

接下来，又开始对这两个要import的类，进行处理。

for (SourceClass candidate : importCandidates) {
   if (candidate.isAssignable(ImportSelector.class)) {
      // Candidate class is an ImportSelector -> delegate to it to determine imports
      Class<?> candidateClass = candidate.loadClass();
      ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
      ParserStrategyUtils.invokeAwareMethods(
            selector, this.environment, this.resourceLoader, this.registry);
      if (selector instanceof DeferredImportSelector) {
         this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
      }
      else {
         String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
         Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
         // 1
         processImports(configClass, currentSourceClass, importSourceClasses, false);
      }
   }

即上面的1这一处地方，进行递归处理，此时要import的两个类，是这样的：

咱们这里不展开了，没完了。。

处理ImportResource注解

不涉及

处理bean方法

不涉及

处理EncryptionBootstrapConfiguration

@Configuration
@ConditionalOnClass({ TextEncryptor.class })
@EnableConfigurationProperties({ KeyProperties.class })
public class EncryptionBootstrapConfiguration {

这个类，大家看看就好。没有新东西，不会说再去import什么东西。

不过这个类上就有condition条件了。

在如下方法时，使用condition计算器，就会发现真的有一个condition要计算。

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
   if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
      return;
   }

然后就又是同样流程，处理member、处理PropertySource、ComponentScan等等。

跳过后续的3个configuration类的处理

org.springframework.cloud.bootstrap.BootstrapConfiguration=\
org.springframework.cloud.bootstrap.config.PropertySourceBootstrapConfiguration,\
org.springframework.cloud.bootstrap.encrypt.EncryptionBootstrapConfiguration,\
org.springframework.cloud.autoconfigure.ConfigurationPropertiesRebinderAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration

这些都跳过，道理类似的。

parse完成后的后续处理

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
   String[] candidateNames = registry.getBeanDefinitionNames();
	...

   // Return immediately if no @Configuration classes were found
   if (configCandidates.isEmpty()) {
      return;
   }


   // Parse each @Configuration class
   ConfigurationClassParser parser = new ConfigurationClassParser(
         this.metadataReaderFactory, this.problemReporter, this.environment,
         this.resourceLoader, this.componentScanBeanNameGenerator, registry);

   Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
   Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
   do {
      // 1
      parser.parse(candidates);
	  // 2
      this.reader.loadBeanDefinitions(configClasses);
      alreadyParsed.addAll(configClasses);

      candidates.clear();
      if (registry.getBeanDefinitionCount() > candidateNames.length) {
         String[] newCandidateNames = registry.getBeanDefinitionNames();
         Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
         Set<String> alreadyParsedClasses = new HashSet<>();
         for (ConfigurationClass configurationClass : alreadyParsed) {
            alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
         }
         for (String candidateName : newCandidateNames) {
            if (!oldCandidateNames.contains(candidateName)) {
               BeanDefinition bd = registry.getBeanDefinition(candidateName);
               if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                     !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                  candidates.add(new BeanDefinitionHolder(bd, candidateName));
               }
            }
         }
         candidateNames = newCandidateNames;
      }
   }
   while (!candidates.isEmpty());
    ...
}

整个过程比较复杂，我们这里分析了那么多，主要是把1处的代码说的差不多了。

2处，加载beanDefinition。

经过这个步骤后，beanFactory中的bean如下：

总结

到此的话，几乎差不多吧，细节还是很多，有些地方肯定没讲到，后续再补上。

demo的源码本身很简单，如果大家需要，可以从这里获取：
//gitee.com/ckl111/all-simple-demo-in-work-1/tree/master/eureka/