本文已收录于【Spring源码札记专栏】。
关联文章:
(一)Spring IoC源码-2.bean的加载-01整体概览
(一)Spring IoC源码-2.bean的加载-02从缓存中获取单例bean
(一)Spring IoC源码-2.bean的加载-03从bean实例中获取对象
(一)Spring IoC源码-2.bean的加载-04创建bean
无论是已经加载到了单例bean还是创建bean后,都需要通过bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
从bean实例中获取目标对象。
无论是从缓存中获取到的bean还是通过不同的scope策略创建的bean都只是最原始的bean状态,并不一定是我们最终想要的bean。举个例子,假如我们需要对工厂bean,即FactoryBean实例进行处理,那么这里得到的其实是工厂bean的初始状态,但我们真正想要的是工厂bean中定义的factory-method方法中返回的bean。getObjectForBeanInstance方法就是完成这个工作的。
@Nullable
protected Object getObjectForBeanInstance(
@Nullable Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
if (beanInstance == null) {
return null;
}
// 验证参数是否合法
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
//如果不是bean实例不是FactoryBean,直接返回
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
//尝试从缓存中获取对象
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
//如果没能从缓存中获取到对象
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
//将获取对象的工作交给getObjectFromFactoryBean方法
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
//返回获取的对象
return object;
}
从上面的代码来看,这个方法将核心的功能委托给了getObjectFromFactoryBean方法实现。
@Nullable
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//如果是单例模式
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
//从缓存中获取对象
Object object = this.factoryBeanObjectCache.get(beanName);
//如果从缓存中没有获取到
if (object == null) {
//委托给doGetObjectFromFactoryBean方法
object = doGetObjectFromFactoryBean(factory, beanName);
//
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
}
return (object != NULL_OBJECT ? object : null);
}
}
else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
再看doGetObjectFromFactoryBean方法,看到以do开头的方法,我们就知道这就是我们要找的方法。
@Nullable
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
factory.getObject(), acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}
如果bean声明为FactoryBean类型,则当提取bean时候提取的不是FactoryBean,而是FactoryBean中的getObject方法返回的bean。
从上面的源码中将FactoryBean的实现原理总结如下。
通过上述的分析,我们知道最后返回的是通过FactoryBean中对应的getObject方法返回的bean。这是不是和工厂方法模式有些相似呢。下图是工厂方法模式的UML图。
对比一下,FactoryBean可以看做是IFactory;getObject方法可以看做getProduct方法;而FactoryBean的具体实现,比如TransactionProxyFactoryBean,可以看做具体的工厂实现FactoryA;通过getObject方法生成的TransactionProxy可以看做是具体的产品实现PorductA。
最后总结下FactoryBean与BeanFactory的区别。
BeanFactory是用于管理bean的一个工厂。
FactoryBean是一种特殊的bean。在BeanFactory中管理两种bean,一种是标准的Java bean,另一种是工厂bean, 即实现了FactoryBean接口的bean。
通过beanFactory.getBean(beanName)从BeanFactory获取bean实例时,对于标准的Java bean,返回的是类自身的实例。而对于工厂bean,返回的不是自身的实例,而是该工厂bean的getObject方法所返回的实例。如果想要获取工厂bean的实例,可以通过getBean(&+beanName)这种方法来获取。