Spring IOC容器的初始化过程：Resource定位，BeanDefinition载入，向IOC容器注册BeanDefinition。整个过程由refresh()方法触发，三个过程由不同的模块完成，使用户更加灵活的对这三个过程剪裁和扩展。
BeanDefinition 就是POJO对象在IOC容器中的抽象。通过BeanDefinition 这个数据结构，使IOC容器能够方便的对POJO对象也就是Bean进行管理。将BeanDefinition 注册到hashmap中，也就是一个IOC容器中，通过hashmap持有这些BeanDefinition结构。就好比我们对物品整理归类，苹果，桃子，草莓都是水果，可以归到水果类，然后对水果进行统一的处理，比如放到冰箱保鲜。这里BeanDefinition就是苹果或桃子或李子，容器就是冰箱。
IOC容器的初始化过程不包括Bean依赖注入。Bean定义的载入和依赖注入是两个独立的过程。依赖注入一般发生在应用第一次通过getBean向容器索取Bean的时候。（配置lazyinit属性除外）
具体过程(以FileSystemXmlApplicationContext为例)：
Resource定位：
指BeanDefinition资源定位。它由ResourceLoader通过统一的Resource接口完成，这个Resource对各种形式的BeanDefinition的使用提供了统一接口。在文件系统中的BeanDefinition可以用FileSystemResource抽象；在类路径中的BeanDefinition可以用ClassPathResource来抽象。Resource定位就是找水果的过程，水果可能在树上，也可能在地里长着。
BeanDefinition载入：
指把用户定义好的Bean表示成IOC容器的数据结构，这个数据结构就是BeanDefinition。
注册：
指向IOC容器注册这些BeanDefinition的过程。通俗的讲就是将BeanDefinition注入到一个hashmap中。
以FileSystemXmlApplicationContext为例来看下IOC容器初始化的过程。
我们先看下FileSystemXmlApplicationContext继承关系：
FileSystemXmlApplicationContext源码：
package org.springframework.context.support;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
/**
* FileSystemXmlApplicationContext是一个支持xml定义BeanDefinition的ApplicationContext，
* 并且可以指定以文件形式的BeanDefinition的读入，这些文件可以使用文件路径和URL定义来表示。
* 在测试环境和独立应用环境中，这个ApplicationContext非常有用。
*/
public class FileSystemXmlApplicationContext extends AbstractXmlApplicationContext {
public FileSystemXmlApplicationContext() {
}
public FileSystemXmlApplicationContext(ApplicationContext parent) {
super(parent);
}
/**
* 从给定的xml文件中加载Bean定义，创建一个FileSystemXmlApplicationContext，并自动刷新上下文
* configLocation包含的是BeanDefinition所在的文件路径
*/
public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
this(configLocations, true, null);
}
/**
* 允许configLocation包含多个BeanDefinition的文件路径的同时，还允许指定自己的双亲IOC容器
*/
public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
this(configLocations, true, parent);
}
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
this(configLocations, refresh, null);
}
/**
* 在对象的初始化过程中，调用refresh函数载入BeanDefinition，
* 这个refresh()启动了BeanDefinition的载入过程
*/
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
/**
* 通过构造一个FileSystemResource来得到一个在文件系统中定位的BeanDefinition
*/
@Override
protected Resource getResourceByPath(String path) {
if (path != null && path.startsWith("/")) {
path = path.substring(1);
}
return new FileSystemResource(path);
}
}
从前面的类图中我们可以看出，FileSystemXmlApplicationContext已经通过继承AbstractApplicationContext具备了ResourceLoader读入以Resource定义的BeanDefinition的能力。因为AbstractApplicationContext的基类是DefaultResourceLoader。
BeanDefinitionReader
在介绍IOC容器初始化过程之前，我们先了解一个类：BeanDefinition读取器-BeanDefinitionReader。BeanDefinitionReader利用ResouceLoader从指定位置加载Bean定义，将物理资源转化生成Resource。
图来自：https://blog.csdn.net/HNU_Csee_wjw/article/details/120406576
以编程的方式使用DefaultListableBeanFactory时，我们定义一个Resource来定位容器使用的BeanDefinition:ClassPathResource res = new ClassPathResource("beans.xml");
这里定义的Resource并不能由DefaultListableBeanFactory直接使用，而是通过BeanDefinitionReader来对这些信息进行处理。Spring为我们提供了一系列加载不同Resource的读取器的实现，使不同的容器可以配置相应的BeanDefinitionReader。比如FileSystemXmlApplicationContext的父类AbstractXmlApplicationContext用的读取器是XmlBeanDefinitionReader类型。
AbstractXmlApplicationContext
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
initBeanDefinitionReader(beanDefinitionReader);
loadBeanDefinitions(beanDefinitionReader);
}
// 用给定的XmlBeanDefinitionReader加载BeanDefinition
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}
推荐阅读：SpringIOC源码解析（4）—— Resource、ResourceLoader、容器之间的微妙关系
下面我们进入正题，看一下FileSystemXmlApplicationContext的初始化流程：
FileSystemXmlApplicationContext的初始化流程由父类AbstractApplicationContext的refresh()方法触发。
AbstractApplicationContext类refresh()方法：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// 子类启动refreshBeanFactory()
// FileSystemXmlApplicationContext 是AbstractApplicationContext的子类
// 在这一步执行refreshBeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 准备用于此上下文的beanFactory
prepareBeanFactory(beanFactory);
try {
// 设置beanFactory的后置处理
postProcessBeanFactory(beanFactory);
// 在上下文中调用注册为bean的后置处理器。
invokeBeanFactoryPostProcessors(beanFactory);
// 注册拦截bean创建的bean处理器。
registerBeanPostProcessors(beanFactory);
// 初始化上下文中的消息源
initMessageSource();
// 为上下文初始化事件多播机制
initApplicationEventMulticaster();
// 初始化其他特殊的Bean
onRefresh();
// 检查监听的Bean并注册他们到容器中
registerListeners();
// 实例化所有剩余的(非懒加载)的单例
finishBeanFactoryInitialization(beanFactory);
// 最后：发布容器事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 为避免资源占用销毁在前面创建的单例
destroyBeans();
// 重置Reset 'active' 表示
cancelRefresh(ex);
// 向调用方抛出异常
throw ex;
}
finally {
// 重置Spring核心中的常见缺省缓存，因为我们可能不再需要单例bean的元数据。。。
resetCommonCaches();
}
}
}先看一张流程图(为了突出关键步骤，只画了关键类,省略了参数)：
FileSystemResource定位
结合流程图可以看到，最后getResourceByPath()方法会被子类FileSystemXmlApplicationContext实现，返回一个FileSystemResource对象，完成BeanDefinition的定位。Spring通过FileSystemResource对象，可以进行相关的IO操作。
定位完成后，就可以用返回的Resource对象来进行BeanDefinition的载入了。
BeanDefinition载入
所谓BeanDefinition载入，就是把xml文件中定义的Bean定义，进过转换和层层解析，根据解析结果，将属性值封装成Property value对象设置到BeanDefinition中，处理成IOC容器中的数据结构。
入口在BeanDefinitionParserDelegate类的parseBeanDefinitionElement(Element ele, BeanDefinition containingBean)方法。
核心处理方法是：
parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean)
我们重点看下：
// 解析bean定义本身，不考虑名称或别名。如果在解析bean定义期间出现问题可能返回null
// 只是把Bean的属性设置载入到BeanDefinition，不涉及对象的实例化过程。
// 对象的实例化在依赖注入时完成
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
try {
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
// 生成需要的BeanDefinition对象，为Bean定义信息的载入做准备
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
// 对当前的Bean元素进行属性解析，并设置description信息
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
// 对各种<bean>元素的信息进行解析
parseMetaElements(ele, bd);
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 解析<bean>的构造函数设置
parseConstructorArgElements(ele, bd);
// 解析<bean>的property设置
parsePropertyElements(ele, bd);
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
// 这里是我们经常见到的异常处理(原来是在载入BeanDefinition时处理的)
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}BeanDefinitionParserDelegate类：
解析<bean>的property设置，对property子元素进行解析，Array、List、Set、Map、prop等各种元素都会在这里解析，生成对应的数据对象。比如MangedList、ManagedArray、ManageSet等，是Spring对具体的BeanDefinition的数据封装。
/**
* 分析给定元素子元素属性
*/
public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
NodeList nl = beanEle.getChildNodes();
// 遍历处理所以的子元素
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
parsePropertyElement((Element) node, bd);
}
}
}
public void parsePropertyElement(Element ele, BeanDefinition bd) {
// 取得property的名字
String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
if (!StringUtils.hasLength(propertyName)) {
error("Tag 'property' must have a 'name' attribute", ele);
return;
}
this.parseState.push(new PropertyEntry(propertyName));
try {
// 如果同一个Bean中已经有同名的property存在，则不进行解析，直接返回。
if (bd.getPropertyValues().contains(propertyName)) {
error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
return;
}
Object val = parsePropertyValue(ele, bd, propertyName);
PropertyValue pv = new PropertyValue(propertyName, val);
parseMetaElements(ele, pv);
pv.setSource(extractSource(ele));
bd.getPropertyValues().addPropertyValue(pv);
}
finally {
this.parseState.pop();
}
}
/**
* 取得每个property的值，也许是一个list或其他
*/
public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
String elementName = (propertyName != null) ?
"<property> element for property '" + propertyName + "'" :
"<constructor-arg> element";
// 应该只有一个子节点: 引用类型, 值类型, 集合等.
NodeList nl = ele.getChildNodes();
Element subElement = null;
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
!nodeNameEquals(node, META_ELEMENT)) {
// Child element is what we're looking for.
if (subElement != null) {
error(elementName + " must not contain more than one sub-element", ele);
}
else {
subElement = (Element) node;
}
}
}
// 这里判断property的属性，是ref还是value。不允许同时是ref和value
boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
if ((hasRefAttribute && hasValueAttribute) ||
((hasRefAttribute || hasValueAttribute) && subElement != null)) {
error(elementName +
" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
}
// 如果是ref，创建一个RuntimeBeanReference类型的对象，封装ref的信息
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;
}
// 如果是value，创建一个TypedStringValue类型的对象，这个对象封装了value的信息
else if (hasValueAttribute) {
TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
valueHolder.setSource(extractSource(ele));
return valueHolder;
}
// 如果还有其他子元素，触发对子元素的解析
else if (subElement != null) {
return parsePropertySubElement(subElement, bd);
}
else {
// Neither child element nor "ref" or "value" attribute found.
error(elementName + " must specify a ref or value", ele);
return null;
}
}
/**
* 分析属性或构造函数arg元素的值、ref或集合子元素。
* @param ele 属性元素的子元素；我们还不知道是哪个
* @param defaultValueType 任何的默认类型（类名）
* {@code <value>} 可能创建的标记
*/
public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {
if (!isDefaultNamespace(ele)) {
return parseNestedCustomElement(ele, bd);
}
// 节点是Bean
else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
if (nestedBd != null) {
nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
}
return nestedBd;
}
// 节点是引用类型
else if (nodeNameEquals(ele, REF_ELEMENT)) {
// 对任何bean的任何名称的通用引用。
String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
boolean toParent = false;
if (!StringUtils.hasLength(refName)) {
// 对同一XML文件中另一个bean的id的引用。
refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);
if (!StringUtils.hasLength(refName)) {
// 对父上下文中另一个bean的id的引用。
refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
toParent = true;
if (!StringUtils.hasLength(refName)) {
error("'bean', 'local' or 'parent' is required for <ref> element", ele);
return null;
}
}
}
if (!StringUtils.hasText(refName)) {
error("<ref> element contains empty target attribute", ele);
return null;
}
RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
ref.setSource(extractSource(ele));
return ref;
}
// 节点是idref类型
else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
return parseIdRefElement(ele);
}
// 节点是value
else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
return parseValueElement(ele, defaultValueType);
}
// 节点是null
else if (nodeNameEquals(ele, NULL_ELEMENT)) {
// 对象是null，创建一个TypedStringValue类型的对象为其保留地址空间
TypedStringValue nullHolder = new TypedStringValue(null);
nullHolder.setSource(extractSource(ele));
return nullHolder;
}
// 节点是数组类型
else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
return parseArrayElement(ele, bd);
}
// 节点是List集合类型
else if (nodeNameEquals(ele, LIST_ELEMENT)) {
return parseListElement(ele, bd);
}
// 节点是Set集合类型
else if (nodeNameEquals(ele, SET_ELEMENT)) {
return parseSetElement(ele, bd);
}
// 节点是Map类型
else if (nodeNameEquals(ele, MAP_ELEMENT)) {
return parseMapElement(ele, bd);
}
// 节点是props类型
else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
return parsePropsElement(ele);
}
else {
error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
return null;
}
}我们看一下List这样的属性配置是如何被解析的：
// 返回ManagedList类型的对象
public List<Object> parseListElement(Element collectionEle, BeanDefinition bd) {
String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
NodeList nl = collectionEle.getChildNodes();
ManagedList<Object> target = new ManagedList<Object>(nl.getLength());
target.setSource(extractSource(collectionEle));
target.setElementTypeName(defaultElementType);
target.setMergeEnabled(parseMergeAttribute(collectionEle));
// 具体的List元素解析过程
parseCollectionElements(nl, target, bd, defaultElementType);
return target;
}
protected void parseCollectionElements(
NodeList elementNodes, Collection<Object> target, BeanDefinition bd, String defaultElementType) {
for (int i = 0; i < elementNodes.getLength(); i++) {
Node node = elementNodes.item(i);
// node需要是element类型
if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {
// 将node添加到taget中，并递归解析下一层子元素
target.add(parsePropertySubElement((Element) node, bd, defaultElementType));
}
}
}经过这样层层解析，我们就将xml文件中定义的Definition加载到了IOC容器中，并在容器中建立了映射，完成了IOC容器管理Bean对象的准备工作。这些数据结构可以以AbstractBeanDefinition为入口，让IOC容器执行索引、查询和操作。你没有看错，这一小节，经过了这么多的处理，就是对xml文件解析，把内容处理成BeanDefinition。看迷茫的同学可以结合类图，往回倒一下处理的入口。
这时候IOC容器BeanDefinition中存在的还只是一些静态的配置信息，要想让容器起作用，还需完成数据向容器的注册
BeanDefinition在IOC容器中的注册
我们回到DefaultBeanDefinitionDocumentReader类
/**
* 处理给定的bean元素，解析bean定义并将其注册到注册表中。
*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// BeanDefinition载入
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 注册实例
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));
}
}将BeanDefinition载入后，开始注册BeanDefinition到IOC容器。
注册的关键代码，在DefaultListableBeanFactory类：
在DefaultListableBeanFactory中，是通过一个hashmap来持有载入的BeanDefinition的：
/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition oldBeanDefinition;
// 如果有相同名字的Bean已经在IOC容器中注册了，如果不允许覆盖，则抛出异常
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(oldBeanDefinition)) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
// 覆盖old beanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
// 检查此工厂的bean创建阶段是否已启动，即,是否有任何bean被标记为同时创建。
if (hasBeanCreationStarted()) {
// 加锁
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}到此，完成了BeanDefinition的注册，完成了IOC容器的初始化过程。此时使用的IOC容器DefaultListableBeanFactory中已经建立了整个Bean的配置信息，而且这些BeanDefinition已经可以被容器使用了，并且可以在BeanDefinitionMap中被检索到和使用。通过容器对这些Bean信息进行处理和维护。
662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
