前面随笔中，结束了对配置文件的解析工作，以及将配置文件转换成对应的BeanDefinition存储在容器中。接下来就该进行bean的加载了。
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
String beanName = this.transformedBeanName(name);
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if (sharedInstance != null && args == null) {
if (this.logger.isDebugEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
try {
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dep = var11[var13];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
this.registerDependentBean(dep, beanName);
this.getBean(dep);
}
}
if (mbd.isSingleton()) {
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
String scopeName = mbd.getScope();
Scope scope = (Scope)this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
this.beforePrototypeCreation(beanName);
Object var4;
try {
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var21) {
throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var21);
}
}
} catch (BeansException var23) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var23;
}
}
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
} else {
return convertedBean;
}
} catch (TypeMismatchException var22) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var22);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
} else {
return bean;
}
}
在这段代码中，我们可以看出bean的加载经历了一个相当复杂的过程，并不是我们想象中简单的用bean的class属性通过反射的方式来实例化bean。其中涉及到方方面面的考虑，不得不佩服开发者缜密的思维。
对于bean加载的过程大致可以总结如下：
1、转换对应的beanName
String beanName = this.transformedBeanName(name);
protected String transformedBeanName(String name) {
return this.canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
这里的目的是通过name得到真正的beanName。
在BeanFactoryUtils.transformedBeanName()中将name前的‘&’符号去除。之前的随笔中有说到过，Spring除了可以通过我们常见的set注入和构造器注入的方式生成bean，还可以通过工厂方法来实例化bean。例如
<bean id="production" class="com.wuzhe.factory.MyBeanFactory"/>
这样通过beanFactory.getBean() 得到的bean就是通过MyBeanFactory实现FactoryBean的getObject()方法实例化而来的。
如果我们想要得到的MyFactoryBean本身这个bean的话，就需要在beanName前加上‘&’符号。例beanFactory.getBean("&production")
回到之前的代码中，处理完‘&’符号的name之后，在cannonicalName()方法里会遍历容器中aliasMap中维护的alia对应beanName的关系，得到真正的beanName
2、尝试从缓存中加载单例
Object sharedInstance = this.getSingleton(beanName);
@Nullable
public Object getSingleton(String beanName) {
return this.getSingleton(beanName, true);
} @Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
Map var4 = this.singletonObjects;
synchronized(this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
} return singletonObject;
}
因为单例的bean只需要初始化一次就足够了，因此在spring中，实例化过得单例bean都被存放在了缓存中，一旦后续再尝试获取该bean时，只需要从缓存中获取就足够了。
在读spring的源码时，经常被spring容器中的各种缓存搞的云里雾里，所以在解读之前先把我们将要用到的缓存名以及其用意列举一下。
singletonObjects:
维护了容器中已被实例化过的单例bean。通过beanName -> Object
factoryBeanObjectCache:
维护了容器中单例工厂FactoryBean对象getObject()得到的单例bean。通过beanName -> Object
singletonsCurrentlyInCreation:
存放了当前正在实例化中的单例bean beanName的集合。 Set<beanName>
earlySingletonObjects:
维护了容器中单例bean。通过beanName -> Object。和singletonObjects的区别是singletonObjects中存放的是已经实例化完成的bean，而在一个bean还未实例化完成时，spring就会通过对应的ObjectFactory的getObject()方法返回一个bean的引用并存放在earlySingletonObjects中，对于后面可能遇到的循环依赖有大用处。
singletonFactories:
维护了容器中还未生产过单例的ObjectFactory。通过beanName -> ObjectFactory。一旦某个ObjectFactory生产过bean，则这个bean会被放置到earlySingletonObjects中，并且这个ObjectFactory在singletonFactories中会被移除。
接下来结合getObjectForBeanInstance方法的代码一起看
protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
if(BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(this.transformedBeanName(name), beanInstance.getClass());
} else if(beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
Object object = null;
if(mbd == null) {
object = this.getCachedObjectForFactoryBean(beanName);
}
if(object == null) {
FactoryBean factory = (FactoryBean)beanInstance;
if(mbd == null && this.containsBeanDefinition(beanName)) {
mbd = this.getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = mbd != null && mbd.isSynthetic();
object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
} else {
return beanInstance;
}
}
我们将从缓存中获取对象的情况分成一下三种情况：
1、根据beanName在singletonObjects中能直接取到对象bean，且当前bean不是FactoryBean类，或者当前bean是FactoryBean类，但name中带有‘&’前缀：
说明这个获取得到的bean就是调用者想要获取的bean。这时只需要直接返回这个bean就可以了。
2、根据beanName在singletonObjects中能直接取到对象bean，但当前bean是FactoryBean类，且name中不带有‘&’前缀：
说明这个获取到的bean是工厂bean，调用者真正想要的是通过工厂生产出来的bean。
这时候spring并不会直接调用FactoryBean的getObject()获取bean，而是先从工厂生产的缓存factoryBeanObjectCache中查找。
protected Object getCachedObjectForFactoryBean(String beanName) {
Object object = this.factoryBeanObjectCache.get(beanName);
return object != NULL_OBJECT?object:null;
}
若找到了，则直接返回该bean。
如果没有找到，则先合并当前的beanDefinition和其父beanDefinition得到mbd。从而取到mbd的synthetic属性。这个属性标识这个bean是否是人工生成的
然后调用getObjectFromFactoryBean()方法
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if(factory.isSingleton() && this.containsSingleton(beanName)) {
synchronized(this.getSingletonMutex()) {
Object ex = this.factoryBeanObjectCache.get(beanName);
if(ex == null) {
ex = this.doGetObjectFromFactoryBean(factory, beanName);
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if(alreadyThere != null) {
ex = alreadyThere;
} else {
if(ex != null && shouldPostProcess) {
try {
ex = this.postProcessObjectFromFactoryBean(ex, beanName);
} catch (Throwable var9) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean\'s singleton object failed", var9);
}
}
this.factoryBeanObjectCache.put(beanName, ex != null?ex:NULL_OBJECT);
}
}
return ex != NULL_OBJECT?ex:null;
}
} else {
Object object = this.doGetObjectFromFactoryBean(factory, beanName);
if(object != null && shouldPostProcess) {
try {
object = this.postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable var11) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean\'s object failed", var11);
}
}
return object;
}
}
如果这个factoryBean生成的不是单例的bean，则直接调用doGetObjectFromFactoryBean()方法
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
if(System.getSecurityManager() != null) {
AccessControlContext ex = this.getAccessControlContext();
try {
object = AccessController.doPrivileged(new PrivilegedExceptionAction() {
public Object run() throws Exception {
return factory.getObject();
}
}, ex);
} catch (PrivilegedActionException var6) {
throw var6.getException();
}
} else {
object = factory.getObject();
}
} catch (FactoryBeanNotInitializedException var7) {
throw new BeanCurrentlyInCreationException(beanName, var7.toString());
} catch (Throwable var8) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);
}
if(object == null && this.isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");
} else {
return object;
}
}
这里的System.getSecurityManager是获取系统的安全管理权限，在安全的情况下，调用了factoryBean的getObject()方法得到了bean。
如果这个factoryBean是单例工厂，则在通过doGetObjectFromFactoryBean()获取bean之后，将bean放置在了factoryBeanObjectCache缓存中。
这里的postProcessObjectFromFactoryBean方法是一个通过工厂生产bean的一个后处理器，关于后处理器在后续章节会详细了解，这里只需要知道在spring获取bean的规则中有一条：尽可能保证所有bean初始化后都会调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理，在实际开发中，大可以针对此特性设计自己的业务逻辑。
3、根据beanName在singletonObjects中不能取到对象bean，但在singletonsCurrentlyInCreation中有此beanName:
说明这个bean正在被创建中，那么spring就会：
1）先尝试在earlySingletonObjects中查找bean的缓存，若找到了则直接返回。
2）如果还是没找到，就会在singletonFactories中查找这个beanName对应的ObjectFactory缓存，如果这时候还没找到，则需要走完创建bean的流程了，return 空。
3）如果找到了对应的ObjectFactory，则通过ObjectFactory的getObject()方法获取bean。并在将其放在earlySingletonObjects的缓存中。并在singletonFactories中移除次ObjectFactory。
这样通过缓存获取bean的过程就结束了。