Spring 源码阅读 39：postProcessBeanFactory 对 @Configuration 配置的解析和处理（2）

ConfigurationClassEnhancerenhancer=newConfigurationClassEnhancer();
for (Map.Entry<String, AbstractBeanDefinition>entry : configBeanDefs.entrySet()) {
AbstractBeanDefinitionbeanDef=entry.getValue();
// If a @Configuration class gets proxied, always proxy the target classbeanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
// Set enhanced subclass of the user-specified bean classClass<?>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);
   }
}

// org.springframework.context.annotation.ConfigurationClassEnhancer#enhancepublicClass<?>enhance(Class<?>configClass, @NullableClassLoaderclassLoader) {
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()));
      }
returnconfigClass;
   }
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()));
   }
returnenhancedClass;
}

// org.springframework.context.annotation.ConfigurationClassEnhancer#newEnhancer/*** Creates a new CGLIB {@link Enhancer} instance.*/privateEnhancernewEnhancer(Class<?>configSuperClass, @NullableClassLoaderclassLoader) {
Enhancerenhancer=newEnhancer();
enhancer.setSuperclass(configSuperClass);
enhancer.setInterfaces(newClass<?>[] {EnhancedConfiguration.class});
enhancer.setUseFactory(false);
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(newBeanFactoryAwareGeneratorStrategy(classLoader));
enhancer.setCallbackFilter(CALLBACK_FILTER);
enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
returnenhancer;
}

// org.springframework.context.annotation.ConfigurationClassEnhancer#createClassprivateClass<?>createClass(Enhancerenhancer) {
Class<?>subclass=enhancer.createClass();
// Registering callbacks statically (as opposed to thread-local)// is critical for usage in an OSGi environment (SPR-5932)...Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
returnsubclass;
}

// org.springframework.context.annotation.ConfigurationClassEnhancer#CALLBACKSprivatestaticfinalCallback[] CALLBACKS=newCallback[] {
newBeanMethodInterceptor(),
newBeanFactoryAwareMethodInterceptor(),
NoOp.INSTANCE};

// org.springframework.context.annotation.ConfigurationClassEnhancer.BeanMethodInterceptor#isMatch@OverridepublicbooleanisMatch(MethodcandidateMethod) {
return (candidateMethod.getDeclaringClass() !=Object.class&&!BeanFactoryAwareMethodInterceptor.isSetBeanFactory(candidateMethod) &&BeanAnnotationHelper.isBeanAnnotated(candidateMethod));
}

ConfigurableBeanFactorybeanFactory=getBeanFactory(enhancedConfigInstance);

privateConfigurableBeanFactorygetBeanFactory(ObjectenhancedConfigInstance) {
Fieldfield=ReflectionUtils.findField(enhancedConfigInstance.getClass(), BEAN_FACTORY_FIELD);
Assert.state(field!=null, "Unable to find generated bean factory field");
ObjectbeanFactory=ReflectionUtils.getField(field, enhancedConfigInstance);
Assert.state(beanFactory!=null, "BeanFactory has not been injected into @Configuration class");
Assert.state(beanFactoryinstanceofConfigurableBeanFactory,
"Injected BeanFactory is not a ConfigurableBeanFactory");
return (ConfigurableBeanFactory) beanFactory;
}

StringbeanName=BeanAnnotationHelper.determineBeanNameFor(beanMethod);

// org.springframework.context.annotation.BeanAnnotationHelper#determineBeanNameForpublicstaticStringdetermineBeanNameFor(MethodbeanMethod) {
StringbeanName=beanNameCache.get(beanMethod);
if (beanName==null) {
// By default, the bean name is the name of the @Bean-annotated methodbeanName=beanMethod.getName();
// Check to see if the user has explicitly set a custom bean name...AnnotationAttributesbean=AnnotatedElementUtils.findMergedAnnotationAttributes(beanMethod, Bean.class, false, false);
if (bean!=null) {
String[] names=bean.getStringArray("name");
if (names.length>0) {
beanName=names[0];
         }
      }
beanNameCache.put(beanMethod, beanName);
   }
returnbeanName;
}

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

if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX+beanName) &&factoryContainsBean(beanFactory, beanName)) {
ObjectfactoryBean=beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX+beanName);
if (factoryBeaninstanceofScopedProxyFactoryBean) {
// Scoped proxy factory beans are a special case and should not be further proxied   }
else {
// It is a candidate FactoryBean - go ahead with enhancementreturnenhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
   }
}

// org.springframework.context.annotation.ConfigurationClassEnhancer.BeanMethodInterceptor#enhanceFactoryBeanprivateObjectenhanceFactoryBean(finalObjectfactoryBean, Class<?>exposedType,
finalConfigurableBeanFactorybeanFactory, finalStringbeanName) {
try {
Class<?>clazz=factoryBean.getClass();
booleanfinalClass=Modifier.isFinal(clazz.getModifiers());
booleanfinalMethod=Modifier.isFinal(clazz.getMethod("getObject").getModifiers());
if (finalClass||finalMethod) {
if (exposedType.isInterface()) {
if (logger.isTraceEnabled()) {
logger.trace("Creating interface proxy for FactoryBean '"+beanName+"' of type ["+clazz.getName() +"] for use within another @Bean method because its "+                     (finalClass?"implementation class" : "getObject() method") +" is final: Otherwise a getObject() call would not be routed to the factory.");
            }
returncreateInterfaceProxyForFactoryBean(factoryBean, exposedType, beanFactory, beanName);
         }
else {
if (logger.isDebugEnabled()) {
logger.debug("Unable to proxy FactoryBean '"+beanName+"' of type ["+clazz.getName() +"] for use within another @Bean method because its "+                     (finalClass?"implementation class" : "getObject() method") +" is final: A getObject() call will NOT be routed to the factory. "+"Consider declaring the return type as a FactoryBean interface.");
            }
returnfactoryBean;
         }
      }
   }
catch (NoSuchMethodExceptionex) {
// No getObject() method -> shouldn't happen, but as long as nobody is trying to call it...   }
returncreateCglibProxyForFactoryBean(factoryBean, beanFactory, beanName);
}

// org.springframework.context.annotation.ConfigurationClassEnhancer.BeanMethodInterceptor#createInterfaceProxyForFactoryBeanprivateObjectcreateInterfaceProxyForFactoryBean(finalObjectfactoryBean, Class<?>interfaceType,
finalConfigurableBeanFactorybeanFactory, finalStringbeanName) {
returnProxy.newProxyInstance(
factoryBean.getClass().getClassLoader(), newClass<?>[] {interfaceType},
         (proxy, method, args) -> {
if (method.getName().equals("getObject") &&args==null) {
returnbeanFactory.getBean(beanName);
            }
returnReflectionUtils.invokeMethod(method, factoryBean, args);
         });
}

// org.springframework.context.annotation.ConfigurationClassEnhancer.BeanMethodInterceptor#createCglibProxyForFactoryBeanprivateObjectcreateCglibProxyForFactoryBean(finalObjectfactoryBean,
finalConfigurableBeanFactorybeanFactory, finalStringbeanName) {
Enhancerenhancer=newEnhancer();
enhancer.setSuperclass(factoryBean.getClass());
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setCallbackType(MethodInterceptor.class);
// Ideally create enhanced FactoryBean proxy without constructor side effects,// analogous to AOP proxy creation in ObjenesisCglibAopProxy...Class<?>fbClass=enhancer.createClass();
ObjectfbProxy=null;
if (objenesis.isWorthTrying()) {
try {
fbProxy=objenesis.newInstance(fbClass, enhancer.getUseCache());
      }
catch (ObjenesisExceptionex) {
logger.debug("Unable to instantiate enhanced FactoryBean using Objenesis, "+"falling back to regular construction", ex);
      }
   }
if (fbProxy==null) {
try {
fbProxy=ReflectionUtils.accessibleConstructor(fbClass).newInstance();
      }
catch (Throwableex) {
thrownewIllegalStateException("Unable to instantiate enhanced FactoryBean using Objenesis, "+"and regular FactoryBean instantiation via default constructor fails as well", ex);
      }
   }
   ((Factory) fbProxy).setCallback(0, (MethodInterceptor) (obj, method, args, proxy) -> {
if (method.getName().equals("getObject") &&args.length==0) {
returnbeanFactory.getBean(beanName);
      }
returnproxy.invoke(factoryBean, args);
   });
returnfbProxy;
}

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()));
   }
returncglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
}

// org.springframework.context.annotation.ConfigurationClassEnhancer.BeanMethodInterceptor#isCurrentlyInvokedFactoryMethodprivatebooleanisCurrentlyInvokedFactoryMethod(Methodmethod) {
MethodcurrentlyInvoked=SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
return (currentlyInvoked!=null&&method.getName().equals(currentlyInvoked.getName()) &&Arrays.equals(method.getParameterTypes(), currentlyInvoked.getParameterTypes()));
}

returnresolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);

// org.springframework.context.annotation.ConfigurationClassEnhancer.BeanFactoryAwareMethodInterceptor#isMatch@OverridepublicbooleanisMatch(MethodcandidateMethod) {
returnisSetBeanFactory(candidateMethod);
}
publicstaticbooleanisSetBeanFactory(MethodcandidateMethod) {
return (candidateMethod.getName().equals("setBeanFactory") &&candidateMethod.getParameterCount() ==1&&BeanFactory.class==candidateMethod.getParameterTypes()[0] &&BeanFactoryAware.class.isAssignableFrom(candidateMethod.getDeclaringClass()));
}

// org.springframework.context.annotation.ConfigurationClassEnhancer.BeanFactoryAwareMethodInterceptor#intercept@Override@NullablepublicObjectintercept(Objectobj, Methodmethod, Object[] args, MethodProxyproxy) throwsThrowable {
Fieldfield=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()))) {
returnproxy.invokeSuper(obj, args);
   }
returnnull;
}

enhancer.setStrategy(newBeanFactoryAwareGeneratorStrategy(classLoader));

// org.springframework.context.annotation.ConfigurationClassEnhancer.BeanFactoryAwareGeneratorStrategy#transform@OverrideprotectedClassGeneratortransform(ClassGeneratorcg) throwsException {
ClassEmitterTransformertransformer=newClassEmitterTransformer() {
@Overridepublicvoidend_class() {
declare_field(Constants.ACC_PUBLIC, BEAN_FACTORY_FIELD, Type.getType(BeanFactory.class), null);
super.end_class();
      }
   };
returnnewTransformingClassGenerator(cg, transformer);
}

for (Map.Entry<String, AbstractBeanDefinition>entry : configBeanDefs.entrySet()) {
AbstractBeanDefinitionbeanDef=entry.getValue();
// If a @Configuration class gets proxied, always proxy the target classbeanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
// Set enhanced subclass of the user-specified bean classClass<?>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);
   }
}