getBean(String name)
昨天我们讲了单例实例化的时候会先判断是否是FactoryBean类型的，是的话会进行相应处理，但是没讲最关键的getBean，现在我们就开始讲这个，可能需要很多个篇幅，里面涉及了很多东西。废话不多说，我们开始吧。这些是我们要进行实例化的单例：
但是前面有一些已经被创建出来了，可以直接获取：
其实我们就只要关心我们自定义的两个对象：
我们开始吧：
doGetBean开始获取bean
我们来看下这个方法的参数：
name 就是bean名字
requiredType 表示需要的类型，如果有类型，创建后会进行类型转换
args 表示参数，也就是构造方法的参数
typeCheckOnly 表示只是做检查，并不是真的要用，这个会影响一些逻辑
因为代码比较长，我们分段来分析比较好，就保留和核心的代码：
doGetBean分段1
首先判断单例存在，且没有参数，这个时候还不能直接返回，还要做一些处理，因为传进来的名字可能是FactoryBean本身，也就是name=&beanName。
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//获取规范的名字
final String beanName = transformedBeanName(name);
Object bean;
//检查是否手动注册了单例
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {//存在单例了
...
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
AbstractAutowireCapableBeanFactory的getObjectForBeanInstance
这个方法有两个重要的参数name和beanName，name是指传进来的名字，可能是FactoryBean本身的名字，有&前缀，也可能是一般的bean名字，beanName是规范后的名字，去掉了&前缀，所以要进行处理。比如这种：
@Override
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
//如果有正在创建的bean要建立以来关系，后面讲
String currentlyCreatedBean = this.currentlyCreatedBean.get();
if (currentlyCreatedBean != null) {
registerDependentBean(beanName, currentlyCreatedBean);
}
return super.getObjectForBeanInstance(beanInstance, name, beanName, mbd);
}
AbstractBeanFactory的getObjectForBeanInstance
最后调用父类的处理方法，会下判断name是不是FactoryBean自身的名字，如果是，就判断beanInstance 是不是FactoryBean类型的，是的话就直接返回，也就是说，要找的就是FactoryBean自身，而不是他创建的bean。如果不是FactoryBean自身的名字，类型也不是FactoryBean，那就普通的单例，直接返回。否则就是说明应该获取的是FactoryBean创建的bean。如果RootBeanDefinition 不为空的话，设置FactoryBean=true，否则就从FactoryBean的缓存中获取，如果获取到就直接返回，否则就要创建，然后返回。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
if (BeanFactoryUtils.isFactoryDereference(name)) {//是否是FactoryBean名字的前缀
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {//不是FactoryBean的话名字有&会报异常
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {//不是FactoryBean就直接返回
return beanInstance;
}
//创建FactoryBean中的bean
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {//从FactoryBean的缓存中获取
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
if (mbd == null && containsBeanDefinition(beanName)) {//mbd没定义，但是FactoryBean是有定义的，获取mbd
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
getCachedObjectForFactoryBean从缓存里获取
factoryBeanObjectCache就是FactoryBean创建的bean的缓存，创建一次后会进行缓存，下次直接拿。
@Nullable
protected Object getCachedObjectForFactoryBean(String beanName) {
return this.factoryBeanObjectCache.get(beanName);
}
getObjectFromFactoryBean创建bean
这里就是FactoryBean创建bean的过程。如果FactoryBean是单例，且已经创建出来了，先从缓存里获取看看，如果存在直接返回。如果不存在就进行doGetObjectFromFactoryBean创建，其实就是调用了getObject()获取对象。这里又做了一次从缓存中获取，感觉挺奇怪的，前面已经获取不存在了，这里怎么又能存在，其实是因为getObject()创建的时候可以自定义，可能有处理器处理，可能会对factoryBeanObjectCache进行设置，所以这里还要判断一次，如果存在的话，就应该获取存在的，而不是刚创建的，这样的话处理器才算是有扩展的功能，否则处理了也等于没用。如果没有缓存存在，判断是否是否需要处理，其实这里说的就是不是合成的对象!synthetic，比如AOP的advice通知就算是合成的，一般的对象都不合成的，如果需要处理，但是是正在创建中的单例，直接返回不处理，否则要进行处理器处理，最后放进缓存。如果是原型的话每次都创建一个新的。
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) {
object = doGetObjectFromFactoryBean(factory, beanName);
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (shouldPostProcess) {//需要处理
if (isSingletonCurrentlyInCreation(beanName)) {//直接返回
return object;
}
beforeSingletonCreation(beanName);
try {
object = postProcessObjectFromFactoryBean(object, beanName);//进行后置处理器处理
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
afterSingletonCreation(beanName);
}
}
if (containsSingleton(beanName)) {//如果包含了FactoryBean，就将创建的对象缓存
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
else {//FactoryBean是原型的话
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
doGetObjectFromFactoryBean
其实没别的东西，就是调用getObject()创建对象，如果返回null的话，就封装成一个NullBean。
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
...
object = factory.getObject();//调用自定义的FactoryBean的getObject获取对象
...
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {//如果是正在创建的FactoryBean，还没能获得bean，就报异常
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
beforeSingletonCreation和afterSingletonCreation
这个就是标记下，正在创建这个bean，创建处理完了就清除标记。
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);//没有在排除范围里内且添加不成功，可能就是循环引用了
}
}
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
postProcessObjectFromFactoryBean对创建出来的bean进行处理器处理
就是进行BeanPostProcessor的postProcessAfterInitialization处理，也就是可以扩展的地方。
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
实战例子
测试例子：
没有设置原型：
设置了原型：
可见在FactoryBean上设置了@Scope("prototype")会影响创建的bean。
果然讲细了没多少东西好讲，但是不讲清除直接跳过去等于没学什么，走马观花，到头来遇到问题还是得深入探究，学东西还是有点研究精神好。剩下的下篇继续吧。
好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。
