接上一篇【Spring源码】Spring IOC 容器源码分析(一)

Bean 容器 实例化 完成后

说到这里，我们回到 refresh 方法，我重新贴了一遍代码，看看我们说到哪了。是的，我们才说完 obtainFreshBean factory 方法。

考虑到篇幅，这里开始大幅缩减掉没必要详细介绍的部分，大家直接看下面的代码中的注释就好了。

 @Override 
public void refresh throws BeansException, IllegalStateException { 
// 来个锁，不然 refresh 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛 
synchronized (this.startupShutdownMonitor) { 
 
// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符 
prepareRefresh; 
 
// 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中， 
// 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了， 
// 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map) 
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory; 
 
// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean 
// 这块待会会展开说 
prepareBeanFactory(beanFactory); 
 
try { 
// 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口， 
// 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】 
 
// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化 
// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事 
postProcessBeanFactory(beanFactory); 
// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 回调方法 
invokeBeanFactoryPostProcessors(beanFactory); 
 
 
 
// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别 
// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization 
// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。这里仅仅是注册，之后会看到回调这两方法的时机 
registerBeanPostProcessors(beanFactory); 
 
// 初始化当前  ApplicationContext  的 MessageSource，国际化这里就不展开说了，不然没完没了了 
initMessageSource; 
 
// 初始化当前 ApplicationContext 的事件广播器，这里也不展开了 
initApplicationEventMulticaster; 
 
// 从方法名就可以知道，典型的模板方法(钩子方法)，不展开说 
// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前） 
onRefresh; 
 
// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过 
registerListeners; 
 
// 重点，重点，重点 
// 初始化所有的 singleton beans 
//（lazy-init 的除外） 
finishBeanFactoryInitialization(beanFactory); 
 
// 最后，广播事件，ApplicationContext 初始化完成，不展开 
finishRefresh; 
} 
 
catch (BeansException ex) { 
if (logger.isWarnEnabled) { 
logger.warn("Exception encountered during context initialization - " + 
"cancelling refresh attempt: " + ex); 
} 
 
// Destroy already created singletons to avoid dangling resources. 
// 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源 
destroyBeans; 
 
// Reset 'active' flag. 
cancelRefresh(ex); 
 
// 把异常往外抛 
throw ex; 
} 
 
finally { 
// Reset common introspection caches in Spring's core, since we 
// might not ever need metadata for singleton beans anymore... 
resetCommonCaches; 
} 
} 
}  

准备 Bean 容器: prepareBeanFactory

之前我们说过，Spring 把我们在 xml 配置的 bean 都注册以后，会”手动”注册一些特殊的 bean。

这里简单介绍下 prepareBeanFactory(factory) 方法：

 /** 
* Configure the factory's standard context characteristics, 
* such as the context's ClassLoader and post-processors. 
* @param beanFactory the BeanFactory to configure 
*/ 
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
// 设置 BeanFactory 的类加载器，我们知道 BeanFactory 需要加载类，也就需要类加载器， 
// 这里设置为加载当前 ApplicationContext 类的类加载器 
beanFactory.setBeanClassLoader(getClassLoader); 
 
// 设置 BeanExpressionResolver 
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader)); 
// 
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment)); 
 
// 添加一个 BeanPostProcessor，这个 processor 比较简单： 
// 实现了 Aware 接口的 beans 在初始化的时候，这个 processor 负责回调， 
// 这个我们很常用，如我们会为了获取 ApplicationContext 而 implement ApplicationContextAware 
// 注意：它不仅仅回调 ApplicationContextAware， 
// 还会负责回调 EnvironmentAware、ResourceLoaderAware 等，看下源码就清楚了 
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); 
 
// 下面几行的意思就是，如果某个 bean 依赖于以下几个接口的实现类，在自动装配的时候忽略它们， 
// Spring 会通过其他方式来处理这些依赖。 
beanFactory.ignore dep endencyInterface(EnvironmentAware.class); 
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); 
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); 
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); 
beanFactory.ignoreDependencyInterface(MessageSourceAware.class); 
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); 
 
/** 
* 下面几行就是为特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值， 
* 之前我们说过，"当前 ApplicationContext 持有一个 BeanFactory"，这里解释了第一行 
* ApplicationContext 还继承了 ResourceLoader、ApplicationEventPublisher、MessageSource 
* 所以对于这几个依赖，可以赋值为 this，注意 this 是一个 ApplicationContext 
* 那这里怎么没看到为 MessageSource 赋值呢？那是因为 MessageSource 被注册成为了一个普通的 bean 
*/ 
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); 
beanFactory.registerResolvableDependency(ResourceLoader. Class , this); 
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); 
beanFactory.registerResolvableDependency(ApplicationContext.class, this); 
 
// 这个 BeanPostProcessor 也很简单，在 bean 实例化后，如果是 ApplicationListener 的子类， 
// 那么将其添加到 listener 列表中，可以理解成：注册 事件监听器 
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); 
 
// 这里涉及到特殊的 bean，名为：loadTimeWeaver，这不是我们的重点，忽略它 
// tips: ltw 是 AspectJ 的概念，指的是在运行期进行织入，这个和 Spring AOP 不一样， 
// 感兴趣的读者请参考我写的关于 AspectJ 的另一篇文章 https:// www. javadoop .com /post/aspectj 
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { 
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); 
// Set a temporary ClassLoader for type matching. 
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader)); 
} 
 
/** 
* 从下面几行代码我们可以知道，Spring 往往很 "智能" 就是因为它会帮我们默认注册一些有用的 bean， 
* 我们也可以选择覆盖 
*/ 
 
// 如果没有定义 "environment" 这个 bean，那么 Spring 会 "手动" 注册一个 
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { 
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment); 
} 
// 如果没有定义 "systemProperties" 这个 bean，那么 Spring 会 "手动" 注册一个 
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { 
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment.getSystemProperties); 
} 
// 如果没有定义 "systemEnvironment" 这个 bean，那么 Spring 会 "手动" 注册一个 
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { 
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment.getSystemEnvironment); 
} 
}  

在上面这块代码中，Spring 对一些特殊的 bean 进行了处理，读者如果暂时还不能消化它们也没有关系，慢慢往下看。

初始化所有的 singleton beans

我们的重点当然是 finishBeanFactoryInitialization(beanFactory); 这个巨头了，这里会负责初始化所有的 singleton beans。

注意，后面的描述中，我都会使用初始化或预初始化来代表这个阶段，Spring 会在这个阶段完成所有的 singleton beans 的实例化。

我们来总结一下，到目前为止，应该说 BeanFactory 已经创建完成，并且所有的实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化并且其中的 postProcessBeanFactory(factory) 方法已经得到回调执行了。而且 Spring 已经“手动”注册了一些特殊的 Bean，如 ‘environment’、‘systemProperties’ 等。

剩下的就是初始化 singleton beans 了，我们知道它们是单例的，如果没有设置懒加载，那么 Spring 会在接下来初始化所有的 singleton beans。

// AbstractApplicationContext.java 834

 // 初始化剩余的 singleton beans 
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
 
// 首先，初始化名字为 conversionService 的 Bean。本着送佛送到西的精神，我在附录中简单介绍了一下 ConversionService，因为这实在太实用了 
// 什么，看代码这里没有初始化 Bean 啊！ 
// 注意了，初始化的动作包装在 beanFactory.getBean(...) 中，这里先不说细节，先往下看吧 
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && 
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { 
beanFactory.setConversionService( 
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); 
} 
 
// Register a default embedded value resolver if no bean post-processor 
// (such as a PropertyPlaceholderConfigurer bean) registered any before: 
// at this point, primarily for resolution in annotation attribute values. 
if (!beanFactory.hasEmbeddedValueResolver) { 
beanFactory.addEmbeddedValueResolver(new StringValueResolver { 
@Override 
public String resolveStringValue(String strVal) { 
return getEnvironment.resolvePlaceholders(strVal); 
} 
}); 
} 
 
// 先初始化 LoadTimeWeaverAware 类型的 Bean 
// 之前也说过，这是 AspectJ 相关的内容，放心跳过吧 
String weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); 
for (String weaverAwareName : weaverAwareNames) { 
getBean(weaverAwareName); 
} 
 
// Stop using the temporary ClassLoader for type matching. 
beanFactory.setTempClassLoader; 
 
// 没什么别的目的，因为到这一步的时候，Spring 已经开始预初始化 singleton beans 了， 
// 肯定不希望这个时候还出现 bean 定义解析、加载、注册。 
beanFactory.freezeConfiguration; 
 
// 开始初始化 
beanFactory.preInstantiateSingletons; 
}  

从上面最后一行往里看，我们就又回到 DefaultListableBeanFactory 这个类了，这个类大家应该都不陌生了吧。

preInstantiateSingletons

// DefaultListableBeanFactory 728

 @Override 
public void preInstantiateSingletons throws BeansException { 
if (this.logger.isDebugEnabled) { 
this.logger.debug("Pre-instantiating singletons in " + this); 
} 
// this.beanDefinitionNames 保存了所有的 beanNames 
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames); 
 
// 触发所有的非懒加载的 singleton beans 的初始化操作 
for (String beanName : beanNames) { 
 
// 合并父 Bean 中的配置，注意 <bean id="" class="" parent="" /> 中的 parent，用的不多吧， 
// 考虑到这可能会影响大家的理解，我在附录中解释了一下 "Bean 继承"，不了解的请到附录中看一下 
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); 
 
// 非抽象、非懒加载的 singletons。如果配置了 'abstract = true'，那是不需要初始化的 
if (!bd.isAbstract && bd.isSingleton && !bd.isLazyInit) { 
// 处理 FactoryBean(读者如果不熟悉 FactoryBean，请移步附录区了解) 
if (isFactoryBean(beanName)) { 
// FactoryBean 的话，在 beanName 前面 加上  ‘&’ 符号。再调用 getBean，getBean 方法别急 
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName); 
// 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现，此处忽略，直接跳过 
boolean isEagerInit; 
if (System.getSecurityManager != && factory instanceof SmartFactoryBean) { 
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean> { 
@Override 
public Boolean run { 
return ((SmartFactoryBean<?>) factory).isEagerInit; 
} 
}, getAccessControlContext); 
} 
else { 
isEagerInit = (factory instanceof SmartFactoryBean && 
((SmartFactoryBean<?>) factory).isEagerInit); 
} 
if (isEagerInit) { 
 
getBean(beanName); 
} 
} 
else { 
// 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了 
getBean(beanName); 
} 
} 
} 
 
 
// 到这里说明所有的非懒加载的 singleton beans 已经完成了初始化 
// 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里得到回调，忽略 
for (String beanName : beanNames) { 
Object singletonInstance = getSingleton(beanName); 
if (singletonInstance instanceof SmartInitializingSingleton) { 
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; 
if (System.getSecurityManager != ) { 
AccessController.doPrivileged(new PrivilegedAction<Object> { 
@Override 
public Object run { 
smartSingleton.afterSingletonsInstantiated; 
return ; 
} 
}, getAccessControlContext); 
} 
else { 
smartSingleton.afterSingletonsInstantiated; 
} 
} 
} 
}  

接下来，我们就进入到 getBean(beanName) 方法了，这个方法我们经常用来从 BeanFactory 中获取一个 Bean，而初始化的过程也封装到了这个方法里。

getBean

在继续前进之前，读者应该具备 FactoryBean 的知识，如果读者还不熟悉，请移步附录部分了解 FactoryBean。

// AbstractBeanFactory 196

 @Override 
public Object getBean(String name) throws BeansException { 
return doGetBean(name, , , false); 
} 
 
// 我们在剖析初始化 Bean 的过程，但是 getBean 方法我们经常是用来从容器中获取 Bean 用的，注意切换思路， 
// 已经初始化过了就从容器中直接返回，否则就先初始化再返回 
@SuppressWarnings("unchecked") 
protected <T> T doGetBean( 
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) 
throws BeansException { 
// 获取一个 “正统的” beanName，处理两种情况，一个是前面说的 FactoryBean(前面带 ‘&’)， 
// 一个是别名问题，因为这个方法是 getBean，获取 Bean 用的，你要是传一个别名进来，是完全可以的 
final String beanName = transformedBeanName(name); 
 
// 注意跟着这个，这个是返回值 
Object bean; 
 
// 检查下是不是已经创建过了 
Object sharedInstance = getSingleton(beanName); 
 
// 这里说下 args 呗，虽然看上去一点不重要。前面我们一路进来的时候都是 getBean(beanName)， 
// 所以 args 传参其实是 的，但是如果 args 不为空的时候，那么意味着调用方不是希望获取 Bean，而是创建 Bean 
if (sharedInstance != && args == ) { 
if (logger.isDebugEnabled) { 
if (isSingletonCurrentlyInCreation(beanName)) { 
logger.debug("..."); 
} 
else { 
logger.debug("Returning cached instance of singleton bean '" + beanName + "'"); 
} 
} 
// 下面这个方法：如果是普通 Bean 的话，直接返回 sharedInstance， 
// 如果是 FactoryBean 的话，返回它创建的那个实例对象 
// (FactoryBean 知识，读者若不清楚请移步附录) 
bean = getObjectForBeanInstance(sharedInstance, name, beanName, ); 
} 
 
else { 
if (isPrototypeCurrentlyInCreation(beanName)) { 
// 创建过了此 beanName 的 prototype 类型的 bean，那么抛异常， 
// 往往是因为陷入了循环引用 
throw new BeanCurrentlyInCreationException(beanName); 
} 
 
// 检查一下这个 BeanDefinition 在容器中是否存在 
BeanFactory parentBeanFactory = getParentBeanFactory; 
if (parentBeanFactory != && !containsBeanDefinition(beanName)) { 
// 如果当前容器不存在这个 BeanDefinition，试试父容器中有没有 
String nameToLookup = originalBeanName(name); 
if (args != ) { 
// 返回父容器的查询结果 
return (T) parentBeanFactory.getBean(nameToLookup, args); 
} 
else { 
// No args -> delegate to standard getBean method. 
return parentBeanFactory.getBean(nameToLookup, requiredType); 
} 
} 
 
if (!typeCheckOnly) { 
// typeCheckOnly 为 false，将当前 beanName 放入一个 alreadyCreated 的 Set 集合中。 
markBeanAsCreated(beanName); 
} 
 
/* 
* 稍稍总结一下： 
* 到这里的话，要准备创建 Bean 了，对于 singleton 的 Bean 来说，容器中还没创建过此 Bean； 
* 对于 prototype 的 Bean 来说，本来就是要创建一个新的 Bean。 
*/ 
try { 
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 
checkMergedBeanDefinition(mbd, beanName, args); 
 
// 先初始化依赖的所有 Bean，这个很好理解。 
// 注意，这里的依赖指的是 depends-on 中定义的依赖 
String dependsOn = mbd.getDependsOn; 
if (dependsOn != ) { 
for (String dep : dependsOn) { 
// 检查是不是有循环依赖，这里的循环依赖和我们前面说的循环依赖又不一样，这里肯定是不允许出现的，不然要乱套了，读者想一下就知道了 
if (isDependent(beanName, dep)) { 
throw new BeanCreationException(mbd.getResourceDescription, beanName, 
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); 
} 
// 注册一下依赖关系 
registerDependentBean(dep, beanName); 
// 先初始化被依赖项 
getBean(dep); 
} 
} 
 
// 如果是 singleton scope 的，创建 singleton 的实例 
if (mbd.isSingleton) { 
sharedInstance = getSingleton(beanName, new ObjectFactory<Object> { 
@Override 
public Object getObject throws BeansException { 
try { 
// 执行创建 Bean，详情后面再说 
return createBean(beanName, mbd, args); 
} 
catch (BeansException ex) { 
destroySingleton(beanName); 
throw ex; 
} 
} 
}); 
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 
} 
 
// 如果是 prototype scope 的，创建 prototype 的实例 
else if (mbd.isPrototype) { 
// It's a prototype -> create a new instance. 
Object prototypeInstance = ; 
try { 
beforePrototypeCreation(beanName); 
// 执行创建 Bean 
prototypeInstance = createBean(beanName, mbd, args); 
} 
finally { 
afterPrototypeCreation(beanName); 
} 
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); 
} 
 
// 如果不是 singleton 和 prototype 的话，需要委托给相应的实现类来处理 
else { 
String scopeName = mbd.getScope; 
final Scope scope = this.scopes.get(scopeName); 
if (scope == ) { 
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); 
} 
try { 
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object> { 
@Override 
public Object getObject throws BeansException { 
beforePrototypeCreation(beanName); 
try { 
// 执行创建 Bean 
return createBean(beanName, mbd, args); 
} 
finally { 
afterPrototypeCreation(beanName); 
} 
} 
}); 
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); 
} 
catch (IllegalStateException ex) { 
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", 
ex); 
} 
} 
} 
catch (BeansException ex) { 
cleanupAfterBeanCreationFailure(beanName); 
throw ex; 
} 
} 
 
// 最后，检查一下类型对不对，不对的话就抛异常，对的话就返回了 
if (requiredType != && bean != && !requiredType.isInstance(bean)) { 
try { 
return getTypeConverter.convertIfNecessary(bean, requiredType); 
} 
catch (TypeMismatchException ex) { 
if (logger.isDebugEnabled) { 
logger.debug("Failed to convert bean '" + name + "' to required type '" + 
ClassUtils.getQualifiedName(requiredType) + "'", ex); 
} 
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass); 
} 
} 
return (T) bean; 
}  

大家应该也猜到了，接下来当然是分析 createBean 方法：

 protected abstract Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException;  

第三个参数 args 数组代表创建实例需要的参数，不就是给构造方法用的参数，或者是工厂 Bean 的参数嘛，不过要注意，在我们的初始化阶段，args 是 。

这回我们要到一个新的类了 AbstractAutowireCapableBeanFactory，看类名，AutowireCapable？类名是不是也说明了点问题了。

主要是为了以下场景，采用 @Autowired 注解注入属性值：

 public class MessageServiceImpl implements MessageService { 
@Autowired 
private UserService userService; 
 
public String getMessage { 
return userService.getMessage; 
} 
}  

 <bean id="messageService" class="com.javadoop.example.MessageServiceImpl" />  

以上这种属于混用了 xml 和 注解 两种方式的配置方式，Spring 会处理这种情况。

好了，读者要知道这么回事就可以了，继续向前。

// AbstractAutowireCapableBeanFactory 447

 /** 
* Central method of this class: creates a bean instance, 
* populates the bean instance,  app lies post-processors, etc. 
* @see #doCreateBean 
*/ 
@Override 
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { 
if (logger.isDebugEnabled) { 
logger.debug("Creating instance of bean '" + beanName + "'"); 
} 
RootBeanDefinition mbdToUse = mbd; 
 
// 确保 BeanDefinition 中的 Class 被加载 
Class<?> resolvedClass = resolveBeanClass(mbd, beanName); 
if (resolvedClass != && !mbd.hasBeanClass && mbd.getBeanClassName != ) { 
mbdToUse = new RootBeanDefinition(mbd); 
mbdToUse.setBeanClass(resolvedClass); 
} 
 
// 准备方法覆写，这里又涉及到一个概念：MethodOverrides，它来自于 bean 定义中的 <lookup-method /> 
// 和 <replaced-method />，如果读者感兴趣，回到 bean 解析的地方看看对这两个标签的解析。 
// 我在附录中也对这两个标签的相关知识点进行了介绍，读者可以移步去看看 
try { 
mbdToUse.prepareMethodOverrides; 
} 
catch (BeanDefinitionValidationException ex) { 
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription, 
beanName, "Validation of method overrides failed", ex); 
} 
 
try { 
// 让 InstantiationAwareBeanPostProcessor 在这一步有机会返回代理， 
// 在 《Spring AOP 源码分析》那篇文章中有解释，这里先跳过 
Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 
if (bean != ) { 
return bean; 
} 
} 
catch (Throwable ex) { 
throw new BeanCreationException(mbdToUse.getResourceDescription, beanName, 
"BeanPostProcessor before instantiation of bean failed", ex); 
} 
// 重头戏，创建 bean 
Object beanInstance = doCreateBean(beanName, mbdToUse, args); 
if (logger.isDebugEnabled) { 
logger.debug("Finished creating instance of bean '" + beanName + "'"); 
} 
return beanInstance; 
}  

创建 Bean

我们继续往里看 doCreateBean 这个方法：

 /** 
* Actually create the specified bean. Pre-creation processing has already h app ened 
* at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks. 
* <p>Differentiates between default bean instantiation, use of a 
* factory method, and autowiring a constructor. 
* @param beanName the name of the bean 
* @param mbd the merged bean definition for the bean 
* @param args explicit arguments to use for  Constructor  or factory method invocation 
* @return a new instance of the bean 
* @throws BeanCreationException if the bean could not be created 
* @see #instantiateBean 
* @see #instantiateUsingFactoryMethod 
* @see #autowireConstructor 
*/ 
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) 
throws BeanCreationException { 
 
// Instantiate the bean. 
BeanWr app er instanceWr app er = ; 
if (mbd.isSingleton) { 
instanceWr app er = this.factoryBeanInstanceCache.remove(beanName); 
} 
if (instanceWr app er == ) { 
// 说明不是 FactoryBean，这里实例化 Bean，这里非常关键，细节之后再说 
instanceWr app er = createBeanInstance(beanName, mbd, args); 
} 
// 这个就是 Bean 里面的 我们定义的类 的实例，很多地方我直接描述成 "bean 实例" 
final Object bean = (instanceWr app er != ? instanceWr app er.getWr app edInstance : ); 
// 类型 
Class<?> beanType = (instanceWr app er != ? instanceWr app er.getWr app edClass : ); 
mbd.resolvedTargetType = beanType; 
 
//  建议 跳过吧，涉及接口：MergedBeanDefinitionPostProcessor 
synchronized (mbd.postProcessingLock) { 
if (!mbd.postProcessed) { 
try { 
// MergedBeanDefinitionPostProcessor，这个我真不展开说了，直接跳过吧，很少用的 
 app lyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 
} 
catch (Throwable ex) { 
throw new BeanCreationException(mbd.getResourceDescription, beanName, 
"Post-processing of merged bean definition failed", ex); 
} 
mbd.postProcessed = true; 
} 
} 
 
// Eagerly cache singletons to be able to resolve circular references 
// even when triggered by lifecycle interfaces like BeanFactoryAware. 
// 下面这块代码是为了解决循环依赖的问题，以后有时间，我再对循环依赖这个问题进行解析吧 
boolean earlySingletonExposure = (mbd.isSingleton && this.allowCircularReferences && 
isSingletonCurrentlyInCreation(beanName)); 
if (earlySingletonExposure) { 
if (logger.isDebugEnabled) { 
logger.debug("Eagerly caching bean '" + beanName + 
"' to allow for resolving potential circular references"); 
} 
addSingletonFactory(beanName, new ObjectFactory<Object> { 
@Override 
public Object getObject throws BeansException { 
return getEarlyBeanReference(beanName, mbd, bean); 
} 
}); 
} 
 
// Initialize the bean instance. 
Object exposedObject = bean; 
try { 
// 这一步也是非常关键的，这一步负责属性装配，因为前面的实例只是实例化了，并没有设值，这里就是设值 
populateBean(beanName, mbd, instanceWr app er); 
if (exposedObject != ) { 
// 还记得 init-method 吗？还有 InitializingBean 接口？还有 BeanPostProcessor 接口？ 
// 这里就是处理 bean 初始化完成后的各种回调 
exposedObject = initializeBean(beanName, exposedObject, mbd); 
} 
} 
catch (Throwable ex) { 
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName)) { 
throw (BeanCreationException) ex; 
} 
else { 
throw new BeanCreationException( 
mbd.getResourceDescription, beanName, "Initialization of bean failed", ex); 
} 
} 
 
if (earlySingletonExposure) { 
// 
Object earlySingletonReference = getSingleton(beanName, false); 
if (earlySingletonReference != ) { 
if (exposedObject == bean) { 
exposedObject = earlySingletonReference; 
} 
else if (!this.allowRawInjectionDespiteWr app ing && hasDependentBean(beanName)) { 
String dependentBeans = getDependentBeans(beanName); 
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length); 
for (String dependentBean : dependentBeans) { 
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
actualDependentBeans.add(dependentBean); 
} 
} 
if (!actualDependentBeans. isEmpty ) { 
throw new BeanCurrentlyInCreationException(beanName, 
"Bean with name '" + beanName + "' has been injected into other beans [" + 
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + 
"] in its raw version as part of a circular reference, but has eventually been " + 
"wr app ed. This means that said other beans do not use the final version of the " + 
"bean. This is often the result of over-eager type matching - consider using " + 
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example."); 
} 
} 
} 
} 
 
// Register bean as disposable. 
try { 
registerDisposableBeanIfNecessary(beanName, bean, mbd); 
} 
catch (BeanDefinitionValidationException ex) { 
throw new BeanCreationException( 
mbd.getResourceDescription, beanName, "Invalid destruction signature", ex); 
} 
 
return exposedObject; 
}  

到这里，我们已经分析完了 doCreateBean 方法，总的来说，我们已经说完了整个初始化流程。

接下来我们挑 doCreateBean 中的三个细节出来说说。一个是创建 Bean 实例的 createBeanInstance 方法，一个是依赖注入的 populateBean 方法，还有就是回调方法 initializeBean。

注意了，接下来的这三个方法要认真说那也是极其复杂的，很多地方我就点到为止了，感兴趣的读者可以自己往里看，最好就是碰到不懂的，自己写代码去调试它。

创建 Bean 实例

我们先看看 createBeanInstance 方法。需要说明的是，这个方法如果每个分支都分析下去，必然也是极其复杂冗长的，我们挑重点说。此方法的目的就是实例化我们指定的类。

 protected BeanWr app er createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) { 
// 确保已经加载了此 class 
Class<?> beanClass = resolveBeanClass(mbd, beanName); 
 
// 校验一下这个类的访问权限 
if (beanClass != && !Modifier.isPublic(beanClass.getModifiers) && !mbd.isNonPublicAccessAllowed) { 
throw new BeanCreationException(mbd.getResourceDescription, beanName, 
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName); 
} 
 
if (mbd.getFactoryMethodName != ) { 
// 采用工厂方法实例化，不熟悉这个概念的读者请看附录，注意，不是 FactoryBean 
return instantiateUsingFactoryMethod(beanName, mbd, args); 
} 
 
// 如果不是第一次创建，比如第二次创建 prototype bean。 
// 这种情况下，我们可以从第一次创建知道，采用无参 构造函数 ，还是构造函数依赖注入 来完成实例化 
boolean resolved = false; 
boolean autowireNecessary = false; 
if (args == ) { 
synchronized (mbd.constructorArgumentLock) { 
if (mbd.resolvedConstructorOrFactoryMethod != ) { 
resolved = true; 
autowireNecessary = mbd.constructorArgumentsResolved; 
} 
} 
} 
if (resolved) { 
if (autowireNecessary) { 
// 构造函数依赖注入 
return autowireConstructor(beanName, mbd, , ); 
} 
else { 
// 无参构造函数 
return instantiateBean(beanName, mbd); 
} 
} 
 
// 判断是否采用有参构造函数 
Constructor<?> ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); 
if (ctors != || 
mbd.getResolvedAutowireMode == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR || 
mbd.hasConstructorArgumentValues || !ObjectUtils.isEmpty(args)) { 
// 构造函数依赖注入 
return autowireConstructor(beanName, mbd, ctors, args); 
} 
 
// 调用无参构造函数 
return instantiateBean(beanName, mbd); 
}  

挑个简单的无参构造函数构造实例来看看：

 protected BeanWr app er instantiateBean(final String beanName, final RootBeanDefinition mbd) { 
try { 
Object beanInstance; 
final BeanFactory parent = this; 
if (System.getSecurityManager != ) { 
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object> { 
@Override 
public Object run { 
 
return getInstantiationStrategy.instantiate(mbd, beanName, parent); 
} 
}, getAccessControlContext); 
} 
else { 
// 实例化 
beanInstance = getInstantiationStrategy.instantiate(mbd, beanName, parent); 
} 
// 包装一下，返回 
BeanWr app er bw = new BeanWr app erImpl(beanInstance); 
initBeanWr app er(bw); 
return bw; 
} 
catch (Throwable ex) { 
throw new BeanCreationException( 
mbd.getResourceDescription, beanName, "Instantiation of bean failed", ex); 
} 
}  

我们可以看到，关键的地方在于：

 beanInstance = getInstantiationStrategy.instantiate(mbd, beanName, parent);  

这里会进行实际的实例化过程，我们进去看看:

// SimpleInstantiationStrategy 59

 @Override 
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) { 
 
// 如果不存在方法覆写，那就使用 java 反射进行实例化，否则使用  CGLIB , 
// 方法覆写 请参见附录"方法注入"中对 lookup-method 和 replaced-method 的介绍 
if (bd.getMethodOverrides.isEmpty) { 
Constructor<?> constructorToUse; 
synchronized (bd.constructorArgumentLock) { 
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod; 
if (constructorToUse == ) { 
final Class<?> clazz = bd.getBeanClass; 
if (clazz.isInterface) { 
throw new BeanInstantiationException(clazz, "Specified class is an interface"); 
} 
try { 
if (System.getSecurityManager != ) { 
constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>> { 
@Override 
public Constructor<?> run throws Exception { 
return clazz.getDeclaredConstructor((Class[]) ); 
} 
}); 
} 
else { 
constructorToUse = clazz.getDeclaredConstructor((Class[]) ); 
} 
bd.resolvedConstructorOrFactoryMethod = constructorToUse; 
} 
catch (Throwable ex) { 
throw new BeanInstantiationException(clazz, "No default constructor found", ex); 
} 
} 
} 
// 利用构造方法进行实例化 
return BeanUtils.instantiateClass(constructorToUse); 
} 
else { 
// 存在方法覆写，利用 CGLIB 来完成实例化，需要依赖于 CGLIB 生成子类，这里就不展开了。 
// tips: 因为如果不使用 CGLIB 的话，存在 override 的情况 JDK 并没有提供相应的实例化支持 
return instantiateWithMethodInjection(bd, beanName, owner); 
} 
}  

到这里，我们就算实例化完成了。我们开始说怎么进行属性注入。

bean 属性注入

看完了 createBeanInstance(…) 方法，我们来看看 populateBean(…) 方法，该方法负责进行属性设值，处理依赖。

// AbstractAutowireCapableBeanFactory 1203

 protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWr app er bw) { 
// bean 实例的所有属性都在这里了 
PropertyValues pvs = mbd.getPropertyValues; 
 
if (bw == ) { 
if (!pvs.isEmpty) { 
throw new BeanCreationException( 
mbd.getResourceDescription, beanName, "Cannot  app ly property values to instance"); 
} 
else { 
// Skip property population phase for instance. 
return; 
} 
} 
 
// 到这步的时候，bean 实例化完成（通过工厂方法或构造方法），但是还没开始属性设值， 
// InstantiationAwareBeanPostProcessor 的实现类可以在这里对 bean 进行状态修改， 
// 我也没找到有实际的使用，所以我们暂且忽略这块吧 
boolean continueWithPropertyPopulation = true; 
if (!mbd.isSynthetic && hasInstantiationAwareBeanPostProcessors) { 
for (BeanPostProcessor bp : getBeanPostProcessors) { 
if (bp instanceof InstantiationAwareBeanPostProcessor) { 
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; 
// 如果返回 false，代表不需要进行后续的属性设值，也不需要再经过其他的 BeanPostProcessor 的处理 
if (!ibp.postProcessAfterInstantiation(bw.getWr app edInstance, beanName)) { 
continueWithPropertyPopulation = false; 
break; 
} 
} 
} 
} 
 
if (!continueWithPropertyPopulation) { 
return; 
} 
 
if (mbd.getResolvedAutowireMode == RootBeanDefinition.AUTOWIRE_BY_NAME || 
mbd.getResolvedAutowireMode == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
MutablePropertyValues newPvs = new MutablePropertyValues(pvs); 
 
// 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系 
if (mbd.getResolvedAutowireMode == RootBeanDefinition.AUTOWIRE_BY_NAME) { 
autowireByName(beanName, mbd, bw, newPvs); 
} 
 
// 通过类型装配。复杂一些 
if (mbd.getResolvedAutowireMode == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
autowireByType(beanName, mbd, bw, newPvs); 
} 
 
pvs = newPvs; 
} 
 
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors; 
boolean needsDepCheck = (mbd.getDependencyCheck != RootBeanDefinition.DEPENDENCY_CHECK_NONE); 
 
if (hasInstAwareBpps || needsDepCheck) { 
PropertyDescriptor filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); 
if (hasInstAwareBpps) { 
for (BeanPostProcessor bp : getBeanPostProcessors) { 
if (bp instanceof InstantiationAwareBeanPostProcessor) { 
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; 
// 这里有个非常有用的 BeanPostProcessor 进到这里: AutowiredAnnotationBeanPostProcessor 
// 对采用 @Autowired、@Value 注解的依赖进行设值，这里的内容也是非常丰富的，不过本文不会展开说了，感兴趣的读者请自行研究 
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWr app edInstance, beanName); 
if (pvs == ) { 
return; 
} 
} 
} 
} 
if (needsDepCheck) { 
checkDependencies(beanName, mbd, filteredPds, pvs); 
} 
} 
// 设置 bean 实例的属性值 
 app lyPropertyValues(beanName, mbd, bw, pvs); 
}  

initializeBean

属性注入完成后，这一步其实就是处理各种回调了，这块代码比较简单。

 protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { 
if (System.getSecurityManager != ) { 
AccessController.doPrivileged(new PrivilegedAction<Object> { 
@Override 
public Object run { 
invokeAwareMethods(beanName, bean); 
return ; 
} 
}, getAccessControlContext); 
} 
else { 
// 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口，回调 
invokeAwareMethods(beanName, bean); 
} 
 
Object wr app edBean = bean; 
if (mbd == || !mbd.isSynthetic) { 
// BeanPostProcessor 的 postProcessBeforeInitialization 回调 
wr app edBean =  app lyBeanPostProcessorsBeforeInitialization(wr app edBean, beanName); 
} 
 
try { 
// 处理 bean 中定义的 init-method， 
// 或者如果 bean 实现了 InitializingBean 接口，调用 afterPropertiesSet 方法 
invokeInitMethods(beanName, wr app edBean, mbd); 
} 
catch (Throwable ex) { 
throw new BeanCreationException( 
(mbd != ? mbd.getResourceDescription : ), 
beanName, "Invocation of init method failed", ex); 
} 
 
if (mbd == || !mbd.isSynthetic) { 
// BeanPostProcessor 的 postProcessAfterInitialization 回调 
wr app edBean =  app lyBeanPostProcessorsAfterInitialization(wr app edBean, beanName); 
} 
return wr app edBean; 
}  

大家发现没有，BeanPostProcessor 的两个回调都发生在这边，只不过中间处理了 init-method，是不是和读者原来的认知有点不一样了？