共计 8492 个字符，预计需要花费 22 分钟才能阅读完成。
本文大致地介绍了 IOC 容器的初始化过程，只列出了比较重要的过程和代码，可以从中看出 IOC 容器执行的大致流程。
接下来的文章会更加深入剖析 Bean 容器如何解析 xml，注册和初始化 bean，以及如何获取 bean 实例等详细的过程。
转自：http://www.importnew.com/1924…
1. 初始化
大致单步跟了下 Spring IOC 的初始化过程，整个脉络很庞大，初始化的过程主要就是读取 XML 资源，并解析，最终注册到 Bean Factory 中：
在完成初始化的过程后，Bean 们就在 BeanFactory 中蓄势以待地等调用了。下面通过一个具体的例子，来详细地学习一下初始化过程，例如当加载下面一个 bean：
<bean id="XiaoWang" class="com.springstudy.talentshow.SuperInstrumentalist">
<property name="instruments">
<list>
<ref bean="piano"/>
<ref bean="saxophone"/>
</list>
</property>
</bean>加载时需要读取、解析、注册 bean，这个过程具体的调用栈如下所示：
下面对每一步的关键的代码进行详细分析：
准备
保存配置位置，并刷新
在调用 ClassPathXmlApplicationContext 后，先会将配置位置信息保存到 configLocations，供后面解析使用，之后，会调用 AbstractApplicationContext 的 refresh 方法进行刷新：
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh,
ApplicationContext parent) throws BeansException {super(parent);
// 保存位置信息，比如 `com/springstudy/talentshow/talent-show.xml`
setConfigLocations(configLocations);
if (refresh) {
// 刷新
refresh();}
}
public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();}
catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
}
}创建载入 BeanFactory
protected final void refreshBeanFactory() throws BeansException {
// ... ...
DefaultListableBeanFactory beanFactory = createBeanFactory();
// ... ...
loadBeanDefinitions(beanFactory);
// ... ...
}创建 XMLBeanDefinitionReader
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// ... ...
// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
initBeanDefinitionReader(beanDefinitionReader);
loadBeanDefinitions(beanDefinitionReader);读取
创建处理每一个 resource
public int loadBeanDefinitions(String location, Set<Resource> actualResources)
throws BeanDefinitionStoreException {
// ... ...
// 通过 Location 来读取 Resource
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
int loadCount = loadBeanDefinitions(resources);
// ... ...
}
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {Assert.notNull(resources, "Resource array must not be null");
int counter = 0;
for (Resource resource : resources) {
// 载入每一个 resource
counter += loadBeanDefinitions(resource);
}
return counter;
}处理 XML 每个元素
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// ... ...
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);
if (node instanceof Element) {Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
// 处理每个 xml 中的元素，可能是 import、alias、bean
parseDefaultElement(ele, delegate);
}
else {delegate.parseCustomElement(ele);
}
}
}
// ... ...
}解析和注册 bean
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 解析
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 注册
// Register the final decorated instance.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to register bean definition with name'" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}本步骤中，通过 parseBeanDefinitionElement 将 XML 的元素解析为 BeanDefinition，然后存在 BeanDefinitionHolder 中，然后再利用 BeanDefinitionHolder 将 BeanDefinition 注册，实质就是把 BeanDefinition 的实例 put 进 BeanFactory 中，和后面将详细的介绍解析和注册过程。
解析
处理每个 Bean 的元素
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
// ... ...
// 创建 beandefinition
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
parseMetaElements(ele, bd);
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 处理“Constructor”parseConstructorArgElements(ele, bd);
// 处理“Preperty”parsePropertyElements(ele, bd);
parseQualifierElements(ele, bd);
// ... ...
}处理属性的值
public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {String elementName = (propertyName != null) ?
"<property> element for property'" + propertyName + "'":"<constructor-arg> element";
// ... ...
if (hasRefAttribute) {
// 处理引用
String refName = ele.getAttribute(REF_ATTRIBUTE);
if (!StringUtils.hasText(refName)) {error(elementName + "contains empty'ref'attribute", ele);
}
RuntimeBeanReference ref = new RuntimeBeanReference(refName);
ref.setSource(extractSource(ele));
return ref;
}
else if (hasValueAttribute) {
// 处理值
TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
valueHolder.setSource(extractSource(ele));
return valueHolder;
}
else if (subElement != null) {
// 处理子类型（比如 list、map 等）return parsePropertySubElement(subElement, bd);
}
// ... ...
}
1.4 注册
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {for (String alias : aliases) {registry.registerAlias(beanName, alias);
}
}
}
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
// ......
// 将 beanDefinition 注册
this.beanDefinitionMap.put(beanName, beanDefinition);
// ......
}
注册过程中，最核心的一句就是：this.beanDefinitionMap.put(beanName, beanDefinition)，也就是说注册的实质就是以 beanName 为 key，以 beanDefinition 为 value，将其 put 到 HashMap 中。
注册
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {for (String alias : aliases) {registry.registerAlias(beanName, alias);
}
}
}
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
// ......
// 将 beanDefinition 注册
this.beanDefinitionMap.put(beanName, beanDefinition);
// ......
理解了以上两个过程，我们就可以自己实现一个简单的 Spring 框架了。于是，我根据自己的理解实现了一个简单的 IOC 框架 Simple Spring，有兴趣可以看看。
注册过程中，最核心的一句就是：this.beanDefinitionMap.put(beanName, beanDefinition)，也就是说注册的实质就是以 beanName 为 key，以 beanDefinition 为 value，将其 put 到 HashMap 中。
注入依赖
当完成初始化 IOC 容器后，如果 bean 没有设置 lazy-init(延迟加载)属性，那么 bean 的实例就会在初始化 IOC 完成之后，及时地进行初始化。初始化时会先建立实例，然后根据配置利用反射对实例进行进一步操作，具体流程如下所示：
创建 bean 的实例
创建 bean 的实例过程函数调用栈如下所示：
注入 bean 的属性
注入 bean 的属性过程函数调用栈如下所示：
在创建 bean 和注入 bean 的属性时，都是在 doCreateBean 函数中进行的，我们重点看下：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd,
final Object[] args) {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建 bean 的实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// ... ...
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 初始化 bean 的实例，如注入属性
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
// ... ...
}
理解了以上两个过程，我们就可以自己实现一个简单的 Spring 框架了。于是，我根据自己的理解实现了一个简单的 IOC 框架 Simple Spring，有兴趣可以看看。
正文完