今天在探索Spring源码的时候,无意中看到这样的情况。
居然是CGLIB的代理对象,可我这个类明明有接口,有无参构造啊,HelloWorldServiceImpl 的源码如下。
@Service("helloWorldService")
public class HelloWorldServiceImpl implements HelloWorldService{
@Value("${name:World}")
private String name;
public HelloWorldServiceImpl() {
System.out.println("create...");
}
@Override
@HelloAop
public String getHelloMessage() {
System.out.println("Hello " + this.name);
return "Hello " + this.name;
}
}
过程
带着这样的疑问,本着在Spring中没啥不能挖出来的想法,我打算研究一下为什么会出现这样的情况,探索过程如下:
其实看源码,最大问题在于断点打在哪,很遗憾的是,我想了半天都没找到一个好的地方,没办法了,只有整个bean的初始流程都走一遍了(其实我猜测到了他是通过beanPostProcessor增强的,但是当时可能犯二了,确实没猜出来是哪一个子类)。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
跟代码很容易就能跟到AbstractAutowireCapableBeanFactory.doCreateBean()这个方法。然后第一眼怀疑的就是这几行
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
很明显,这个地方返回的是JAVA反射构造的对象,跟大家的常识以及网上经常说的内容也符合。因为咱们这个类是无参构造且有接口,完美符合JAVA反射造对象的条件。证据如下图:
那么问题来了,既然初始造对象的时候,是调用的反射,那么后面为啥就能了CGLIB呢,继续走,后面就会发现在走各种后置处理器,太多了,我们根据返回值
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//各种逻辑....
return exposedObject;
}
既然返回值就是代理的对象,那么我们看中间有哪些地方修改了返回值的参数不就行了吗?自然而然定位到了这一行,
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
进initializeBean方法,方法如下
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
//省略部分非本次关注的逻辑,只保留的关键地方
Object wrappedBean = bean;
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
invokeInitMethods(beanName, wrappedBean, mbd);
wrappedBean =applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}
好家伙,这么多后置处理器都处理逻辑都在这,从名字上看一个是初始化之前,一个是执行初始化方法,一个是执行初始化逻辑之后。从名字上来看,都有可能,那么只要挨个看了。省略过程,最后在定位到applyBeanPostProcessorsAfterInitialization,结果如下:
好了,真相大白,到这了,之后的过程就省略了,比较简单,直接放一张最后CGLIB造对象的图:
到最后,我又产生了一个新的问题:
对于AOP的对象,他先产生了一个JAVA反射的实例对象,然后后置处理器又用CGLIB造了一个增强后的对象示例,这里没问题,但是Spring解决循环引用的代码,是在后置处理器之前,意思是在三级缓存里面,放的是JAVA反射对象的实例,而不是CGLIB里面的实例,如果这个时候产生了循环引用,那么又会是什么场景呢?下期我们一起来探索一下!



