@ConfigurationProperties源码分析四什么时候注册的ConfigurationPropertiesBindingPostProcessorRegistrar？

怼烎@ 2022-03-06 08:04 200阅读 0赞

# 什么时候注册的ConfigurationPropertiesBindingPostProcessorRegistrar？ #

## SpringApplication ##

应用启动Spring 后会调用refresh方法然后会调用

// Invoke factory processors registered as beans in the context.
    				invokeBeanFactoryPostProcessors(beanFactory);

委托 PostProcessorRegistrationDelegate来处理

/**
    	 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
    	 * respecting explicit order if given.
    	 * <p>Must be called before singleton instantiation.
    	 */
    	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    		//委托		PostProcessorRegistrationDelegate来处理
    
    		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
    		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    		}
    	}

## PostProcessorRegistrationDelegate ##

会调用实现BeanDefinitionRegistryPostProcessor 接口的类

/**
    	 * Invoke the given BeanDefinitionRegistryPostProcessor beans.
    	 */
    	private static void invokeBeanDefinitionRegistryPostProcessors(
    			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
    
    		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
    			postProcessor.postProcessBeanDefinitionRegistry(registry);
    		}
    	}

## ConfigurationClassPostProcessor ##

实现了BeanDefinitionRegistryPostProcessor 接口 会被调用  
new ConfigurationClassParser 对象来解析@Configuration 处理ImportSelectors

## ConfigurationClassParser ##

private void processDeferredImportSelectors() {
    		List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
    		this.deferredImportSelectors = null;
    		if (deferredImports == null) {
    			return;
    		}
    
    		deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
    		Map<Object, DeferredImportSelectorGrouping> groupings = new LinkedHashMap<>();
    		Map<AnnotationMetadata, ConfigurationClass> configurationClasses = new HashMap<>();
    		for (DeferredImportSelectorHolder deferredImport : deferredImports) {
    			Class<? extends Group> group = deferredImport.getImportSelector().getImportGroup();
    			DeferredImportSelectorGrouping grouping = groupings.computeIfAbsent(
    					(group != null ? group : deferredImport),
    					key -> new DeferredImportSelectorGrouping(createGroup(group)));
    			grouping.add(deferredImport);
    			configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
    					deferredImport.getConfigurationClass());
    		}
    		for (DeferredImportSelectorGrouping grouping : groupings.values()) {
    			grouping.getImports().forEach(entry -> {
    				ConfigurationClass configurationClass = configurationClasses.get(entry.getMetadata());
    				try {
    					processImports(configurationClass, asSourceClass(configurationClass),
    							asSourceClasses(entry.getImportClassName()), false);
    				}
    				catch (BeanDefinitionStoreException ex) {
    					throw ex;
    				}
    				catch (Throwable ex) {
    					throw new BeanDefinitionStoreException(
    							"Failed to process import candidates for configuration class [" +
    							configurationClass.getMetadata().getClassName() + "]", ex);
    				}
    			});
    		}
    	}

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
    			return;
    		}
    
    		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
    		if (existingClass != null) {
    			if (configClass.isImported()) {
    				if (existingClass.isImported()) {
    					existingClass.mergeImportedBy(configClass);
    				}
    				// Otherwise ignore new imported config class; existing non-imported class overrides it.
    				return;
    			}
    			else {
    				// Explicit bean definition found, probably replacing an import.
    				// Let's remove the old one and go with the new one.
    				this.configurationClasses.remove(configClass);
    				this.knownSuperclasses.values().removeIf(configClass::equals);
    			}
    		}
    
    		// Recursively process the configuration class and its superclass hierarchy.
    		SourceClass sourceClass = asSourceClass(configClass);
    		do {
    			sourceClass = doProcessConfigurationClass(configClass, sourceClass);
    		}
    		while (sourceClass != null);
    
    		this.configurationClasses.put(configClass, configClass);
    	}

这里处理 全部的ConfigurationClass 配置类

/**
    	 * Apply processing and build a complete {@link ConfigurationClass} by reading the
    	 * annotations, members and methods from the source class. This method can be called
    	 * multiple times as relevant sources are discovered.
    	 * @param configClass the configuration class being build
    	 * @param sourceClass a source class
    	 * @return the superclass, or {@code null} if none found or previously processed
    	 */
    	@Nullable
    	protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
    			throws IOException {
    
    		// Recursively process any member (nested) classes first
    		processMemberClasses(configClass, sourceClass);
    
    		// Process any @PropertySource annotations
    		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");
    			}
    		}
    
    		// Process any @ComponentScan annotations
    		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
    				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    		if (!componentScans.isEmpty() &&
    				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
    			for (AnnotationAttributes componentScan : componentScans) {
    				// The config class is annotated with @ComponentScan -> perform the scan immediately
    				Set<BeanDefinitionHolder> scannedBeanDefinitions =
    						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
    				// Check the set of scanned definitions for any further config classes and parse recursively if needed
    				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
    					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
    					if (bdCand == null) {
    						bdCand = holder.getBeanDefinition();
    					}
    					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
    						parse(bdCand.getBeanClassName(), holder.getBeanName());
    					}
    				}
    			}
    		}
    
    		// Process any @Import annotations
    		processImports(configClass, sourceClass, getImports(sourceClass), true);
    
    		// Process any @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);
    			}
    		}
    
    		// Process individual @Bean methods
    		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    		for (MethodMetadata methodMetadata : beanMethods) {
    			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    		}
    
    		// Process default methods on interfaces
    		processInterfaces(configClass, sourceClass);
    
    		// Process superclass, if any
    		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();
    			}
    		}
    
    		// No superclass -> processing is complete
    		return null;
    	}

这里递归获取所有的@Import注解的类

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

/**
    	 * Recursively collect all declared {@code @Import} values. Unlike most
    	 * meta-annotations it is valid to have several {@code @Import}s declared with
    	 * different values; the usual process of returning values from the first
    	 * meta-annotation on a class is not sufficient.
    	 * <p>For example, it is common for a {@code @Configuration} class to declare direct
    	 * {@code @Import}s in addition to meta-imports originating from an {@code @Enable}
    	 * annotation.
    	 * @param sourceClass the class to search
    	 * @param imports the imports collected so far
    	 * @param visited used to track visited classes to prevent infinite recursion
    	 * @throws IOException if there is any problem reading metadata from the named class
    	 */
    	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.startsWith("java") && !annName.equals(Import.class.getName())) {
    					collectImports(annotation, imports, visited);
    				}
    			}
    			imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
    		}
    	}

这里会处理所有的ImportSelector接口类，注册到spring 容器

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
    			Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
    
    		if (importCandidates.isEmpty()) {
    			return;
    		}
    
    		if (checkForCircularImports && isChainedImportOnStack(configClass)) {
    			this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
    		}
    		else {
    			this.importStack.push(configClass);
    			try {
    				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 (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
    							this.deferredImportSelectors.add(
    									new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
    						}
    						else {
    							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
    							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
    							processImports(configClass, currentSourceClass, importSourceClasses, false);
    						}
    					}
    					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 {
    						// 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));
    					}
    				}
    			}
    			catch (BeanDefinitionStoreException ex) {
    				throw ex;
    			}
    			catch (Throwable ex) {
    				throw new BeanDefinitionStoreException(
    						"Failed to process import candidates for configuration class [" +
    						configClass.getMetadata().getClassName() + "]", ex);
    			}
    			finally {
    				this.importStack.pop();
    			}
    		}
    	}

## EnableConfigurationPropertiesImportSelector ##

到这里就注册了 ConfigurationPropertiesBindingPostProcessorRegistrar

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

## EnableConfigurationProperties ##

EnableConfigurationProperties 注解导入了 @Import(EnableConfigurationPropertiesImportSelector.class)

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(EnableConfigurationPropertiesImportSelector.class)
    public @interface EnableConfigurationProperties {
    
    	/**
    	 * Convenient way to quickly register {@link ConfigurationProperties} annotated beans
    	 * with Spring. Standard Spring Beans will also be scanned regardless of this value.
    	 * @return {@link ConfigurationProperties} annotated beans to register
    	 */
    	Class<?>[] value() default {};
    
    }

## 总结 ##

**什么时候注册的ConfigurationPropertiesBindingPostProcessorRegistrar？  
应用启动的时候会调用Spring的refresh方法，然后会调用[前面流程注册的ConfigurationClassPostProcessor][ConfigurationClassPostProcessor]来处理。  
ConfigurationClassPostProcessor会new ConfigurationClassParser来真正处理所有的import注解的类(EnableConfigurationProperties 注解导入了 @Import(EnableConfigurationPropertiesImportSelector.class)  
)，因此EnableConfigurationPropertiesImportSelector被注册进来，从而再注册成功了ConfigurationPropertiesBindingPostProcessorRegistrar**

[ConfigurationClassPostProcessor]: https://blog.csdn.net/qq_15288023/article/details/88635168