Spring注解版执行流程 ConfigurationClassPostProcessor

Spring注解版执行流程 ConfigurationClassPostProcessor

代码往下执行。执行ConfigurationClassPostProcessor#postProcessBeanFactory方法。

invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

获取id，在之前执行postProcessBeanDefinitionRegistry方法时是往registriesPostProcessed添加标识，这里往factoriesPostProcessed添加标识。

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		int factoryId = System.identityHashCode(beanFactory);
		if (this.factoriesPostProcessed.contains(factoryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + beanFactory);
		}
		this.factoriesPostProcessed.add(factoryId);
		if (!this.registriesPostProcessed.contains(factoryId)) {
			// BeanDefinitionRegistryPostProcessor hook apparently not supported...
			// Simply call processConfigurationClasses lazily at this point then.
			// BeanDefinitionRegistryPostProcessor 钩子显然不支持
			// 简单调用 processConfigurationClasses 懒加载在这一点上
			processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
		}
 		// 为满足条件的 @Configuration 注解标识的类进行动态代理，生成的代理对象
		enhanceConfigurationClasses(beanFactory);
		// ImportAwareBeanPostProcessor 处理：对代理的配置类注入 BeanFactory，
		// 方便后续从该对象中获取到容器中的实例对象以及支持获取注解的元数据信息
		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
	}

enhanceConfigurationClasses

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
	Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
	for (String beanName : beanFactory.getBeanDefinitionNames()) {
		BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
		Object configClassAttr = beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);
		MethodMetadata methodMetadata = null;
		if (beanDef instanceof AnnotatedBeanDefinition) {
			methodMetadata = ((AnnotatedBeanDefinition) beanDef).getFactoryMethodMetadata();
		}
		if ((configClassAttr != null || methodMetadata != null) && beanDef instanceof AbstractBeanDefinition) {
			// // 配置类（full or lite）或配置类派生的 @Bean 方法，在这点上找到 bean 具体类型
			AbstractBeanDefinition abd = (AbstractBeanDefinition) beanDef;
			if (!abd.hasBeanClass()) {
				try {
					abd.resolveBeanClass(this.beanClassLoader);
				}
				catch (Throwable ex) {
					throw new IllegalStateException(
							"Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
				}
			}
		}
		// 若 configurationClass 属性为 full，满足这个条件塞入到前面的集合中，后面的代码会对这个配置类进行代理增强处理
		if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
			if (!(beanDef instanceof AbstractBeanDefinition)) {
				throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
						beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
			}
			else if (logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
				logger.info("Cannot enhance @Configuration bean definition '" + beanName +
						"' since its singleton instance has been created too early. The typical cause " +
						"is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
						"return type: Consider declaring such methods as 'static'.");
			}
			configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
		}
	}
	// 没有需要增强的配置类，立即返回
	if (configBeanDefs.isEmpty()) {
		return;
	}
	// 配置类动态代理增强的核心类
	ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
	for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
		AbstractBeanDefinition beanDef = entry.getValue();
		// 若 @Configuration 配置类被代理，就以目标类 CGLIB 进行代理增强
		beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
		// 为指定的配置类设置代理增强子类
		Class<?> configClass = beanDef.getBeanClass();
		Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
		if (configClass != enhancedClass) {
			if (logger.isTraceEnabled()) {
				logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
						"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
			}
			beanDef.setBeanClass(enhancedClass);
		}
	}
}

1.先获取到 BeanDefinition 信息 configurationClass 属性，若当前 BeanDefinition 未找到具体的类型，这边通过类加载器进行加载找到
2.判断该属性值是否等于 full，若等于说明当前就是配置类，然后将其加入到待动态代理增强的集合中，该属性值如何设置的，下面再回顾一下：

// ConfigurationClassUtils#checkConfigurationClassCandidate 方法中
// proxyBeanMethods=true 就会设置为 full
if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
	beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
}
// 若 bean 被 @Configuration 注解标注，且属性 proxyBeanMethods 为 false(使用代理模式)，则将 bean 定义记为 lite
else if (config != null || isConfigurationCandidate(metadata)) {
	beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
}
else {
	return false;
} 

3.遍历待动态代理增强的集合，挨个元素进行动态代理实现，生成 CGLIB 动态代理类然后再覆盖到当前的 beanClass 属性，等类初始化、实例化时再进行创建

public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
	if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
		if (logger.isDebugEnabled()) {
			logger.debug(String.format("Ignoring request to enhance %s as it has " +
					"already been enhanced. This usually indicates that more than one " +
					"ConfigurationClassPostProcessor has been registered (e.g. via " +
					"<context:annotation-config>). This is harmless, but you may " +
					"want check your configuration and remove one CCPP if possible",
					configClass.getName()));
		}
		return configClass;
	}
	// newEnhancer：创建 CGLIB 必备的 enhancer 实例设置好相关参数，createClass：注入实例
	Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
	if (logger.isTraceEnabled()) {
		logger.trace(String.format("Successfully enhanced %s; enhanced class name is: %s",
				configClass.getName(), enhancedClass.getName()));
	}
	return enhancedClass;
}

/**
 * 创建新的 CGLIB 实例
 */
private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(configSuperClass);
	enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
	enhancer.setUseFactory(false);
	// 名称生成策略器,
	enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
	// 自定义的动态代理类生成策略
	enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
	// 回调拦截器类：BeanMethodInterceptor、BeanFactoryAwareMethodInterceptor，当调用配置类下方法时会被拦截处理逻辑
	enhancer.setCallbackFilter(CALLBACK_FILTER);
	enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
	return enhancer;
}

动态代理类创建完成，等到 Bean 创建过程时再将这些配置类进行实例化，通过代理对象来调用实际方法的操作。
对于ConfigurationClassPostProcessor后置处理器类的理解暂时先这样。代码接着往下执行，就会走到EventListenerMethodProcessor#postProcessBeanFactory方法。

EventListenerMethodProcessor 是 Spring 事件机制中非常重要的一个组件。它管理了一组EventListenerFactory组件,用来将应用中每个使用@EventListener注解定义的事件监听方法变成一个ApplicationListener实例注册到容器。

• EventListenerMethodProcessor

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		this.beanFactory = beanFactory;
		// 从容器中获取EventListenerFactory类型的对象，就是其本身
		Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
		List<EventListenerFactory> factories = new ArrayList<>(beans.values());
		AnnotationAwareOrderComparator.sort(factories);
		// 设置时间监听工厂
		this.eventListenerFactories = factories;
	}

这里invokeBeanFactoryPostProcessors(beanFactory)方法就算执行完了。

6.registerBeanPostProcessors

// 在bean对象创建之前。注册一些bean对象的后置处理器。
registerBeanPostProcessors(beanFactory)

进入这个方法，会发现这个和invokeBeanFactoryPostProcessors里执行方法类似。BeanFactoryPostProcessor 是针对 BeanFactory 的扩展，主要用在 bean 实例化之前，读取 bean 的定义，并可以修改它。BeanPostProcessor 是针对 bean 的扩展，主要用在 bean 实例化之后，执行初始化方法前后，允许开发者对 bean 实例进行修改。
applicationContext是我们的注解容器

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		// 从beanDefinitionMap中获取类型为BeanPostProcessor的bean定义信息。
		// org.springframework.context.annotation.internalAutowiredAnnotationProcessor
		// org.springframework.context.annotation.internalCommonAnnotationProcessor
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		// 获取到所有的bean后置处理器的数量
		// 这里count有3个。
		// 刷新方法中prepareBeanFactory方法里添加到容器中。ApplicationContextAwareProcessor、ApplicationListenerDetector。
		// ImportAwareBeanPostProcessor是ConfigurationClassPostProcessor#postProcessBeanFactory
		// + 1是因为添加一个BeanPostProcessorChecker
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		// 添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		//定义不同的变量用于区分: 实现PriorityOrdered接口的BeanPostProcessor
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		// 用于存放Spring内部的BeanPostProcessor
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		//实现Ordered接口的BeanPostProcessor
		List<String> orderedPostProcessorNames = new ArrayList<>();
		//普通BeanPostProcessor
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		//首先, 注册实现PriorityOrdered接口的BeanPostProcessors
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 添加到bean工厂的后置处理器集合中去
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			// 如果ppName对应的Bean实例也实现了MergedBeanDefinitionPostProcessor接口,
            // 则将ppName对应的Bean实例添加到internalPostProcessors
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// Now, register all regular BeanPostProcessors.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		// 把ApplicationListenerDetector移到最后
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

到这里，这个方法就差不多看完了。往工厂对象中添加了一些bean对象的后置处理器，就是在添加时会考虑到每个处理器的优先级，后添加的会覆盖掉之前添加的。

7.initMessageSource

我学Spring这么久，真没用到国际化相关的知识。有兴趣自己了解叭。

8.initApplicationEventMulticaster

容器中初始化事件广播器。

	protected void initApplicationEventMulticaster() {
		//获取工厂对象 
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// 从工厂对象中判断容器中是否包含applicationEventMulticaster
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		  	// 如果包含，则为当前类中的applicationEventMulticaster属性赋值
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			//否则，创建一个简单的事件多播器，并且注册到容器中去。
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
						"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
			}
		}
	}

9.onRefresh

这个方法是Spring框架留给后续做扩展的接口。在这里是一个空方法。SpringBoot内置Tomcat就是在这个方法中实现的。

10.registerListeners

往第八步创建的事件多播器applicationEventMulticaster中添加事件监听器。

	protected void registerListeners() {
		// Register statically specified listeners first.
		// getApplicationListeners()方法获取AbstractApplicationContext的成员变量applicationListeners属性
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let post-processors apply to them!
		// 从容器中获取ApplicationListener
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// Publish early application events now that we finally have a multicaster...
		// 如果有早期事件发布了，由于之前没有事件多播器，这里将发布早期事件执行。
		// 注解容器中这里为空。
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

finishBeanFactoryInitialization(beanFactory)方法是Spring框架的中的核心步重！！！！