Spring5源碼解析7-ConfigurationClassPostProcessor (下)

ConfigurationClassPostProcessor繼承了BeanDefinitionRegistryPostProcessor接口，它實現了postProcessBeanDefinitionRegistry和其父類的BeanFactoryPostProcessor#postProcessBeanFactory方法。

關於postProcessBeanDefinitionRegistry方法的解析能夠參看：Spring5 源碼學習 (5) ConfigurationClassPostProcessor (上)。

如今咱們來看一下ConfigurationClassPostProcessor#postProcessBeanFactory方法的源碼。

---

ConfigurationClassPostProcessor#postProcessBeanFactory

調用時機

ConfigurationClassPostProcessor#postProcessBeanFactory方法也在refresh();方法中執行invokeBeanFactoryPostProcessors(beanFactory);方法時被調用的。

源碼解析

//ConfigurationClassPostProcessor#postProcessBeanFactory源碼
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);
	// 在 this.postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 方法中
	// 調用this.registriesPostProcessed.add(registryId);
	// if條件不成立
	if (!this.registriesPostProcessed.contains(factoryId)) {
		// BeanDefinitionRegistryPostProcessor hook apparently not supported...
		// Simply call processConfigurationClasses lazily at this point then.
		processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
	}

	// 對配置類進行加強
	enhanceConfigurationClasses(beanFactory);
	// 建立 ImportAwareBeanPostProcessor ,來支持 ImportAware ,調用ImportAware.setImportMetadata方法
	beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
複製代碼

主要作了兩件事：

1. 對配置類進行加強
2. 建立ImportAwareBeanPostProcessor 來支持ImportAware接口。

主要來看一下對配置類進行加強方法enhanceConfigurationClasses(beanFactory);的源碼。

enhanceConfigurationClasses(beanFactory)加強 Full Configuration

Spring會對Full Configuration 進行代理，攔截@Bean方法，以確保正確處理@Bean語義。這個加強的代理類就是在enhanceConfigurationClasses(beanFactory)方法中產生的，源碼以下：

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
	Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
	//獲取全部的BeanDefinitionName,以前已經完成了bean的掃描,這裏會獲取到全部的beanName
	for (String beanName : beanFactory.getBeanDefinitionNames()) {
		BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
		// 校驗是否爲FullConfigurationClass,也就是是否被標記了 @Configuration
		if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
			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'.");
			}
			//若是是FullConfigurationClass,則放到變量configBeanDefs中
			configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
		}
	}
	if (configBeanDefs.isEmpty()) {
		// nothing to enhance -> return immediately
		return;
	}

	ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
	for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
		AbstractBeanDefinition beanDef = entry.getValue();
		// If a @Configuration class gets proxied, always proxy the target class
		beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
		try {
			// Set enhanced subclass of the user-specified bean class
			Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);
			if (configClass != null) {
				// 對 FullConfigurationClass 進行加強
				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()));
					}
					//將BeanClass設置爲加強後的類
					beanDef.setBeanClass(enhancedClass);
				}
			}
		} catch (Throwable ex) {
			throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
		}
	}
}
複製代碼

獲取全部爲FullConfigurationClass的BeanDefinition（即標註@Configuration的配置類），而後依次調用enhancer.enhance(configClass, this.beanClassLoader);方法，對配置類進行加強，將方法返回Class<?> enhancedClass的設置到BeanDefinition中（eanDef.setBeanClass(enhancedClass);），以後Spring建立該BeanDefinition時就會使用這個加強類來建立。

下面是enhancer.enhance(configClass, this.beanClassLoader);方法源碼：

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;
	}
	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;
}
複製代碼

建立Full Configuration加強類

具體來看一下newEnhancer(configClass, classLoader方法，這個方法負責建立Full Configuration加強類。

private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
	// Spring從新打包了CGLIB（使用Spring專用補丁;僅供內部使用）
	// 這樣可避免在應用程序級別或第三方庫和框架上與CGLIB的依賴性發生任何潛在衝突
	// https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/cglib/package-summary.html
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(configSuperClass);
	// 設置須要實現的接口,也就是說,咱們的配置類的cglib代理還實現的 EnhancedConfiguration 接口
	enhancer.setInterfaces(new Class<?>[]{EnhancedConfiguration.class});
	enhancer.setUseFactory(false);
	// 設置命名策略
	enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
	// 設置生成器建立字節碼策略
	// BeanFactoryAwareGeneratorStrategy 是 CGLIB的DefaultGeneratorStrategy的自定義擴展，主要爲了引入BeanFactory字段
	enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
	// 設置加強
	enhancer.setCallbackFilter(CALLBACK_FILTER);
	enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
	return enhancer;
}
複製代碼

這裏的Enhancer對象是org.springframework.cglib.proxy.Enhancer，那它和cglib是什麼關係呢？

Spring's repackaging of CGLIB 3.2 (with Spring-specific patches; for internal use only).This repackaging technique avoids any potential conflicts with dependencies on CGLIB at the application level or from third-party libraries and frameworks.

引用自：docs.spring.io/spring/docs…

大體就是說，Spring從新打包了CGLIB（使用Spring專用補丁，僅供內部使用） ，這樣可避免在應用程序級別或第三方庫和框架上與CGLIB的依賴性發生任何潛在衝突。

那具體作了哪些加強呢？

1. 實現EnhancedConfiguration接口。這是一個空的標誌接口，僅由Spring框架內部使用，而且由全部@ConfigurationCGLIB子類實現，該接口繼承了BeanFactoryAware接口。
2. 設置了命名策略
3. 設置生成器建立字節碼的策略。BeanFactoryAwareGeneratorStrategy繼承了cglib的DefaultGeneratorStrategy，其主要做用是爲了讓子類引入BeanFactory字段和設置ClassLoader。
4. 設置加強Callback：

private static final Callback[] CALLBACKS = new Callback[]{
		// 攔截 @Bean 方法的調用,以確保正確處理@Bean語義
		new BeanMethodInterceptor(),
		// 攔截 BeanFactoryAware#setBeanFactory 的調用
		new BeanFactoryAwareMethodInterceptor(),
		NoOp.INSTANCE
};
複製代碼

• BeanMethodInterceptor：負責攔截@Bean方法的調用，以確保正確處理@Bean語義。
• BeanFactoryAwareMethodInterceptor：負責攔截 BeanFactoryAware#setBeanFactory方法的調用，由於加強的配置類實現了EnhancedConfiguration接口（也就是實現了BeanFactoryAwar接口）。

設置加強Callback

下面，咱們就以AppConfig爲例，來學習加強Callback相關源碼。

@Configuration
@ComponentScan
public class AppConfig {

	@Bean
	public String name() throws Exception {
		getUserBean().getObject();
		return "程序員小黑";
	}


	@Bean
	public FactoryBean getUserBean() {
		return new FactoryBean<UserBean>() {
			@Override
			public UserBean getObject() throws Exception {
				System.out.println("1111");
				return new UserBean("shen", 17);
			}

			@Override
			public Class<?> getObjectType() {
				return UserBean.class;
			}
		};
	}
}
複製代碼

BeanMethodInterceptor

主要做用是：攔截@Bean方法的調用，以確保正確處理@Bean語義。當調用@Bean方法時，就會被如下代碼所攔截：

//BeanMethodInterceptor#intercept源碼
public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs, MethodProxy cglibMethodProxy) throws Throwable {

	// enhancedConfigInstance 已是配置類的加強對象了,在加強對象中,有beanFactory字段的
	// 獲取加強對象中的beanFactory
	ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
	// 獲取beanName
	String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);

	// Determine whether this bean is a scoped-proxy
	if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {
		String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
		if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
			beanName = scopedBeanName;
		}
	}

	// To handle the case of an inter-bean method reference, we must explicitly check the
	// container for already cached instances.

	// First, check to see if the requested bean is a FactoryBean. If so, create a subclass
	// proxy that intercepts calls to getObject() and returns any cached bean instance.
	// This ensures that the semantics of calling a FactoryBean from within @Bean methods
	// is the same as that of referring to a FactoryBean within XML. See SPR-6602.

	// 檢查容器中是否存在對應的 FactoryBean 若是存在,則建立一個加強類
	// 經過建立加強類來代理攔截 getObject（）的調用 , 以確保了FactoryBean的語義
	if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&
			factoryContainsBean(beanFactory, beanName)) {
		Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
		if (factoryBean instanceof ScopedProxyFactoryBean) {
			// Scoped proxy factory beans are a special case and should not be further proxied
		} else {
			// It is a candidate FactoryBean - go ahead with enhancement
			// 建立加強類,來代理 getObject（）的調用
			// 有兩種可選代理方式,cglib 和 jdk
			// Proxy.newProxyInstance(
			// factoryBean.getClass().getClassLoader(), new Class<?>[]{interfaceType},
			// (proxy, method, args) -> {
			// if (method.getName().equals("getObject") && args == null) {
			// return beanFactory.getBean(beanName);
			// }
			// return ReflectionUtils.invokeMethod(method, factoryBean, args);
			// });
			return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
		}
	}

	// 判斷當時執行的方法是否爲@Bean方法自己
	// 舉個例子 : 若是是直接調用@Bean方法,也就是Spring來調用咱們的@Bean方法,則返回true
	// 若是是在別的方法內部,咱們本身的程序調用 @Bean方法,則返回false
	if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
		// The factory is calling the bean method in order to instantiate and register the bean
		// (i.e. via a getBean() call) -> invoke the super implementation of the method to actually
		// create the bean instance.
		if (logger.isInfoEnabled() &&
				BeanFactoryPostProcessor.class.isAssignableFrom(beanMethod.getReturnType())) {
			logger.info(String.format("@Bean method %s.%s is non-static and returns an object " +
							"assignable to Spring's BeanFactoryPostProcessor interface. This will " +
							"result in a failure to process annotations such as @Autowired, " +
							"@Resource and @PostConstruct within the method's declaring " +
							"@Configuration class. Add the 'static' modifier to this method to avoid " +
							"these container lifecycle issues; see @Bean javadoc for complete details.",
					beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName()));
		}
		// 若是返回true,也就是Spring在調用這個方法,那麼就去真正執行該方法
		return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
	}

	//不然,則嘗試從容器中獲取該 Bean 對象
	// 怎麼獲取呢? 經過調用 beanFactory.getBean 方法
	// 而這個getBean 方法,若是對象已經建立則直接返回,若是尚未建立,則建立,而後放入容器中,而後返回
	return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
}
複製代碼

1. enhancedConfigInstance是配置類的加強對象。從加強對象中獲取beanFactory和beanName。舉個例子：當Spring調用name()方法時，beanName就是name。
2. 檢查容器中是否存在對應的FactoryBean，若是存在，則建立一個加強類，來代理getObject()的調用。在本示例中，若是讀者將name()方法註釋刪掉以後程序並不會執行到這一步。由於Spring調用getUserBean()方法時，容器中並無存在對應的FactoryBean。由於只有第二次調用getUserBean()方法容器中才會存在對應的FactoryBean。
3. 判斷當時執行的方法是否爲@Bean方法自己，若是是，則直接調用該方法，不作加強攔截；不然，則嘗試從容器中獲取該Bean對象。

BeanFactoryAwareMethodInterceptor

BeanFactoryAwareMethodInterceptor方法就比較簡單，其做用爲攔截 BeanFactoryAware#setBeanFactory的調用，用於獲取BeanFactory對象。

// BeanFactoryAwareMethodInterceptor#intercept 源碼
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
	Field field = ReflectionUtils.findField(obj.getClass(), BEAN_FACTORY_FIELD);
	Assert.state(field != null, "Unable to find generated BeanFactory field");
	field.set(obj, args[0]);

	// Does the actual (non-CGLIB) superclass implement BeanFactoryAware?
	// If so, call its setBeanFactory() method. If not, just exit.
	if (BeanFactoryAware.class.isAssignableFrom(ClassUtils.getUserClass(obj.getClass().getSuperclass()))) {
		return proxy.invokeSuper(obj, args);
	}
	return null;
}
複製代碼

輸出加強類class文件

最後，再補充說明一點，咱們能夠經過以下配置來獲取Spring爲咱們生成的CGLIB代理加強類的class文件：

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "spring-study/docs/classes");
複製代碼

---

源碼註釋GITHUB地址：github.com/shenjianeng…

歡迎關注公衆號：