我们在上一篇文章中说了一下FactoryBean类型的Bean的getObjectType方法被使用到的一个地方，我们在这一篇文章中会说一下FactoryBean是怎么让Spring容器管理调用它的getObject所生成的Bean的。在这篇文章中我们从getBean方法开始说起(我们这里还是要说一下我们现在的beanName的值为：factoryBeanLearn，Class类型为：FactoryBeanService.class )：
getBean(beanName, requiredType, args)方法，这个方法又调用了doGetBean方法，doGetBean可以说是Spring容器中一个很核心的一个类，里面的功能很多很复杂，我们在这篇文章中只关注和FactoryBean相关的内容。思路是：先分析大内容里面的具体的点，再由点及面的分析。
public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
return doGetBean(name, requiredType, args, false);
}
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//转换传入的BeanName的值，如&name变为name 以及别名(alias)的转换
final String beanName = transformedBeanName(name);
Object bean;
//调用getSingleton方法 从Spring容器中获取单例Bean 具体的获取过程见下面分析
//我们在上一篇文章中分析过 这里的beanName为factoryBeanLearn
//beanName为factoryBeanLearn的Bean 已经在Spring容器中创建过了(创建过程见AbstractApplicationContext的refresh方法)
//所以这里会获取到一个FactoryBeanLearn实例
//这里根据beanName获取bean实例的方法 beanName都是经过处理之后的beanName
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
//这个方法是从实例自身获取对象 像这个实例是一个FactoryBean类型的实例
//我们在下面分析这个方法
//这里要注意的是：我们在这个方法中传入了一个name 又传入了一个beanName
//这里为什么要传入两个beanName？可以想一下
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}getSingleton从Spring容器中获取单例Bean
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//先从singletonObjects中获取单例Bean singletonObjects是一个ConcurrentHashMap
//key是beanName value是单例Bean
Object singletonObject = this.singletonObjects.get(beanName);
//如果没有获取到，则判断是不是当前在创建中的单例Bean
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//这里加锁
synchronized (this.singletonObjects) {
//提前暴露创建的Bean中是否存在beanName的单例Bean
singletonObject = this.earlySingletonObjects.get(beanName);
//如果没有获取到 并且允许提前引用响应的Bean
if (singletonObject == null && allowEarlyReference) {
//singletonFactories是一个HashMap key是beanName，value是ObjectFactory 又一个Factory
//在Spring中很多地方用到了ObjectFactory 包括我们在之前的文章中分析的 Autowired Request
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//从ObjectFactory中获取Bean实例
singletonObject = singletonFactory.getObject();
//放入earlySingletonObjects这个Map中
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}getObjectForBeanInstance的分析
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
//这里判断 name是不是以&开头，不是经过处理的beanName 并且这个bean实例 不是FactoryBean类型的
//如果是&开头 并且不是FactoryBean类型 则抛出异常
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
//不是FactoryBean类型 或者name以&开头 直接返回bean实例
//想一下我们关于FactoryBean的知识：如果要根据beanName获取真正的FactoryBean实例的时候
//需要在beanName前面加上& 这里就可以看到为什么要这样做了。
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
//factoryBeanObjectCache 看看是不是在缓存中存在
//factoryBeanObjectCache
object = getCachedObjectForFactoryBean(beanName);
}
//如果没有
if (object == null) {
//如果能走到这里来 这个bean实例是FactoryBean类型的
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
//从这个方法的名字我们可以看到这个方法的意思是:从FactoryBean中
//获取对象
//getObjectFromFactoryBean的分析在下面
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}getObjectFromFactoryBean的分析
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//FactoryBean类型的实例 调用isSingleton方法返回的是true
//所传入的bean实例也要求是单例类型的
//对应我们这里就是FactoryBeanLearn中的方法返回true
if (factory.isSingleton() && containsSingleton(beanName)) {
//加锁
synchronized (getSingletonMutex()) {
//再从缓存中获取一次
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
//调用doGetObjectFromFactoryBean方法从FactoryBean中获取bean对象
//这里是调用的FactoryBean的getObject方法来获取的
object = doGetObjectFromFactoryBean(factory, beanName);
//再从缓存中获取一次
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
//如果上一步的缓存中获取到了 则用缓存中的替代我们
//我们从FactoryBean中获取的bean
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (object != null && shouldPostProcess) {
try {
//调用BeanPostProcessor中的postProcessAfterInitialization方法进行处理
//这里只会调用BeanPostProcessor的postProcessAfterInitialization方法了
//
object = postProcessObjectFromFactoryBean(object, beanName);
}
//抛出异常
}
//放入到factoryBeanObjectCache中缓存起来 key为beanName
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的分析
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(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
//调用FactoryBean中的getObject()方法获取bean
return factory.getObject();
}
}, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//看这里 调用FactoryBean中的getObject()方法获取bean
object = factory.getObject();
}
}
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}整个流程图大致如下:
流程简化起来就是：
循环Spring容器中所有的beanNames，再根据beanName获取对应的Bean实例，判断获取的Bean实例是不是FactoryBean类型的Bean，如果是，则调用Bean的getObjectType方法获取Class，将获取到的Class和传入的Class进行匹配，如果匹配到，则将此beanName和传入的Class建立一个映射关系。再根据beanName获取到Spring容器中对应的Bean，调用Bean的getObject方法来获取对应的实例。
