IOC容器初始化之invokeBeanFactoryPostProcessor学习（三）

序言

0. 从传入的beanFactoryPostProcessors执行。比如SpringBoot提供的：
   SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor。主要是为了用SharedMetadataReaderFactoryBean替换ConfigurationClassPostProcessor的默认的CachingMetadataReaderFactory

   	@Override
   	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
   	    // 向IOC容器中注册SharedMetadataReaderFactoryBean的BeanDefinition
   		register(registry);
   		// 获取IOC容器中存在的ConfigurationClassPostProcessor的BeanDefinition
   		// 向该beanDefinition中添加metadataReaderFactory属性，
   		// 值为SharedMetadataReaderFactoryBean的BeanDefinition
   		configureConfigurationClassPostProcessor(registry);
   	}
   

   这个0步的作用就是，处理那些在ConfigurationClassPostProcessor之前的场景，比如对ConfigurationClassPostProcessor的beanDefinition的处理，或者是warn信息（SpringBoot）等。
   实现这个场景的方式：
   第一：实现ApplicationContextInitializer
   第二：在实现类中定义BeanDefinitionRegistryPostProcessor处理器进行处理
1. 从已注册的beanDefinition中获取BeanDefinitionRegistryPostProcessor类型的beanDefinitions【】。
2. 调用getBean方法优先创建实现了PriorityOrder的bean对象 -> ConfigurationClassPostProcessor
3. 执行ConfigurationClassPostProcessor对象的processBeanDefinitionRegistry方法：
   3.1 向beanFactory中注册两个beanDefinition信息：ImportAwareBeanPostProcessor和EnhancedConfigurationBeanPostProcessor，再调用processConfigBeanDefinitions。
   3.2 创建ConfigurationClassParser对象，并只解析@Configuration和@Component(包括层级该注解层级下的，比如，@Service 和 @Controller)这种beanDefinition。处理一个bean的嵌套类，@PropertyResource标注的，@ComponentScan，@Importy，@ImportResource，@Bean，处理该bean的父类。【这个parse的编码技巧学习一下】
   3.3 如果singletonObjects中没有IMPORT_REGISTRY_BEAN_NAME，registerSingleton（…）
4. 执行实现了Ordered的BeanDefinitionRegistryPostProcessors，并调用getBean创建对象
5. 最后，执行所有的剩下的BeanDefinitionRegistryPostProcessor。比如，如果集成了mybatis-spring，则会创建该MapperScannerConfigurer对象，然后再执行该对象的postBeanDefinitionRegistry【将mapper接口BeanDefinition注册到beanFactory中去，实际执行对象是继承了ClassPathBeanDefinitionScanner的ClassPathMapperScanner对象】
   题外话，如果想扩展Spring的某个功能，完全可参照mybatis-spring的扩展，思路是要有一个能被Spring识别的BeanDefinitionRegistryPostProcessor，通过该重写的postProcessBeanDefinitionRegistry向Spring容器中暴露一些必须要有的beanDefinition，比如mybatis的接口bean，以这个作为扩展功能的入口进行扩展。
6. 执行已经创建过的registryPostProcessor【enhanceConfigurationClass】和regularPostProcessor，对创建完的以及注册过BeanDefinition的beanFactory做一个后置处理。
7. 从已注册的beanDefinition中获取BeanFactoryPostProcessor类型的beanDefinitions。
8. 遍历这些postProcessor，已处理过的跳过去，未处理过的优先处理PriorityOrdered这种，其次处理Ordered.class，最后，非Ordered的postProcessor创建相应的对象。
   总结：
   从这个流程就可以看出BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的关系。

ConfigurationClassParser中的parse编码规范

从BeanDefinitionHolder这里也可以看出，涉及多个参数跨类传参的时候，最好要有一个Holder类，减少代码的阅读难度；
要解析三种BeanDefinition，三种解析方法，解析层层递进，最终在processConfigurationClass中处理BeanDefinition。
预处理parse和真正处理doProcessConfigutationClass的命名方式。

public void parse(Set<BeanDefinitionHolder> configCandidates) {
		this.deferredImportSelectors = new LinkedList<>();

		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					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());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}

		processDeferredImportSelectors();
	}
	protected final void parse(@Nullable String className, String beanName) throws IOException {
		Assert.notNull(className, "No bean class name for configuration class bean definition");
		MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
		processConfigurationClass(new ConfigurationClass(reader, beanName));
	}

	protected final void parse(Class<?> clazz, String beanName) throws IOException {
		processConfigurationClass(new ConfigurationClass(clazz, beanName));
	}

	protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
		processConfigurationClass(new ConfigurationClass(metadata, beanName));
	}
	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);
				for (Iterator<ConfigurationClass> it = this.knownSuperclasses.values().iterator(); it.hasNext();) {
					if (configClass.equals(it.next())) {
						it.remove();
					}
				}
			}
		}

		// 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);
	}
	/**
	 * 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) {
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(
							holder.getBeanDefinition(), this.metadataReaderFactory)) {
						parse(holder.getBeanDefinition().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;
	}