栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring源码探索——有接口,有无参构造器的bean对象,Spring是用的JAVA反射来创建对象的,这句话一定正确吗?

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring源码探索——有接口,有无参构造器的bean对象,Spring是用的JAVA反射来创建对象的,这句话一定正确吗?

机缘巧合

今天在探索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里面的实例,如果这个时候产生了循环引用,那么又会是什么场景呢?下期我们一起来探索一下!

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/939077.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号