前面几篇文章主要分析了 Spring IoC 容器如何初始化，以及解析和注册我们定义的 bean 信息。
其中，「Spring 中的 IoC 容器」对 Spring 中的容器做了一个概述，「Spring IoC 容器初始化」和「Spring IoC 容器初始化(2)」分析了 Spring 如何初始化 IoC 容器，「Spring 是如何解析 标签的？ 」分析了 Spring 如何解析 标签及其子标签，并注册到 BeanFactory。
主要流程如下：
IoC 容器已经建立，而且把我们定义的 bean 信息放入了容器，那么如何从容器中获取对象呢？
本文继续分析。
配置及测试代码
为便于查看，这里再贴一下 bean 配置文件和测试代码。
配置文件 application-ioc.xml
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
测试代码
public class IocTests {
@Test
public void test01() {
ApplicationContext context = new ClassPathXmlApplicationContext("application-ioc.xml");
System.out.println(context.getBean("person"));
System.out.println(context.getBean("dog"));
}
}
/*
* 输出结果：
* Person{id=12, name='Jack-12'}
* Dog{age=1}
*/
如何从容器获取对象？
从容器中获取对象是通过 BeanFactory#getBean 方法，它有多个重载的方法，但最终都是通过
AbstractBeanFactory#doGetBean 方法来实现的。doGetBean 方法代码如下：
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
// ...
protected T doGetBean(
String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
// 从缓存中获取单例 bean 对象
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// ...
// 处理 FactoryBean 的场景
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// 缓存中不存在 bean 对象
else {
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// bean 对象在父容器中，则从父容器中获取 bean 对象
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 是否只做类型检查
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 获取 BeanDefinition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 获取依赖的 bean 对象
// 若创建一个 bean 对象时依赖其他对象，则先创建被依赖对象
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
// ...
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
// ...
}
}
}
// 创建 scope 为 singleton(单例)的对象
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// ...
}
});
// 处理 FactoryBean 的场景
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 创建 scope 为 prototype 的对象
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
// 处理 FactoryBean 的场景
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 创建其他类型对象
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
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, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
// 处理 FactoryBean 的场景
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
// ...
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 类型检查
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
// ...
}
}
return (T) bean;
}
}
获取 bean 对象主要就是通过这个 doGetBean 方法实现的。
该方法虽然看起来稍微有点长，但是呢，它内部的实现更长、更复杂。不过也是有迹可循的，莫慌。
本文先看下这个方法的整体流程，内部逻辑后面再慢慢研究。先上流程图：
代码虽然有点长，但梳理下来其实也没那么复杂了。
这个方法主要做了什么呢？
当从容器中获取 bean 对象时，首先从缓存中获取。如果缓存中存在，处理 FactoryBean 的场景。
BeanFactory 和 FactoryBean，这哥俩长得很像，也有个别面试题可能会问到。
嗯……以后有机会单独分析？
如果缓存中没有，先去父容器获取，前面创建 BeanFactory 时可以指定 parent 参数，就是那个。
不在父容器中，若 bean 对象依赖了其他对象，则先创建被依赖的 bean 对象，再根据 标签的 scope 属性去创建相应的 bean 对象。
是不是有点像我们平时写查询接口时、先从缓存查询，缓存中没的话再查询 DB？
道理是一样的，空间换时间。
小结
先整体，后细节。
本文先从整体上分析了如何从 Spring IoC 容器中获取 bean 对象，内容不多，后文再详细分解吧。
？)
