Spring源码------IoC源码分析详解
Spring源码------IoC源码分析详解
目录
Spring源码------IoC源码分析详解
1、控制反转（IoC）
2、Spring IoC 源码时序图（详细版）
3、源码追踪
3.1详细版链接
3.2 个人总结浓缩版（方便记忆）
4、总结
1、控制反转（IoC）
控制反转（IoC）原理的Spring Framework实现。IoC也称为依赖注入（DI）。这是一个过程，通过这个过程，对象只能通过构造函数参数，工厂方法的参数或在构造或从工厂方法返回后在对象实例上设置的属性来定义它们的依赖关系（即，它们使用的其他对象）。 。然后容器在创建bean时注入这些依赖项。此过程基本上是bean本身的逆（因此名称，控制反转），通过使用类的直接构造或诸如服务定位器模式的机制来控制其依赖关系的实例化或位置。（官方文档5.x说明）。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。
基于XML的元数据不是唯一允许的配置元数据形式。Spring IoC容器本身完全与实际编写此配置元数据的格式分离。目前，许多开发人员为其Spring应用程序选择 基于Java的配置。
流传的大部分博客对spring生命周期的看法
不知道Spring官方对Bean的生命问题是否有明确的定义或者解析，但是Spring In Action以及市面上流传的大部分博客是这样的：
- 实例化Bean对象，这个时候Bean的对象是非常低级的，基本不能够被我们使用，因为连最基本的属性都没有设置，可以理解为连Autowired注解都是没有解析的；
- 填充属性，当做完这一步，Bean对象基本是完整的了，可以理解为Autowired注解已经解析完毕，依赖注入完成了；
- 如果Bean实现了BeanNameAware接口，则调用setBeanName方法；
- 如果Bean实现了BeanClassLoaderAware接口，则调用setBeanClassLoader方法；
- 如果Bean实现了BeanFactoryAware接口，则调用setBeanFactory方法；
- 调用BeanPostProcessor的postProcessBeforeInitialization方法；
- 如果Bean实现了InitializingBean接口，调用afterPropertiesSet方法；
- 如果Bean定义了init-method方法，则调用Bean的init-method方法；
- 调用BeanPostProcessor的postProcessAfterInitialization方法；当进行到这一步，Bean已经被准备就绪了，一直停留在应用的上下文中，直到被销毁；
- 如果应用的上下文被销毁了，如果Bean实现了DisposableBean接口，则调用destroy方法，如果Bean定义了destory-method声明了销毁方法也会被调用。
注意：本篇所介绍的仅仅是如何将Bean元素信息纳入Spring容器的注册表的过程，并未进行实例化。
Spring Bean的生命周期表：
2、Spring IoC 源码时序图（详细版）
3、源码追踪
3.1详细版链接
《SpringIOC源码详解》
3.2 个人总结浓缩版（方便记忆）
（1）BeanFactory
Spring Bean的创建是典型的工厂模式，这一系列的Bean工厂，也即IOC容器为开发者管理对象间的依赖关系提供了很多便利和基础服务，在Spring中有许多的IOC容器的实现供用户选择和使用，其相互关系如下：
其中BeanFactory作为最顶层的一个接口类，它定义了IOC容器的基本功能规范，BeanFactory 有三个子类：ListableBeanFactory、HierarchicalBeanFactory 和AutowireCapableBeanFactory。但是从上图中我们可以发现最终的默认实现类是 DefaultListableBeanFactory，他实现了所有的接口。
那为何要定义这么多层次的接口呢？查阅这些接口的源码和说明发现，每个接口都有他使用的场合，它主要是为了区分在 Spring 内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如
- ListableBeanFactory 接口表示这些 Bean 是可列表的，
- 而 HierarchicalBeanFactory 表示的是这些 Bean 是有继承关系的，也就是每个Bean 有可能有父 Bean。
- AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。这四个接口共同定义了 Bean 的集合、Bean 之间的关系、以及 Bean 行为.
最基本的IOC容器接口BeanFactory：
public interface BeanFactory {
//对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，
//如果需要得到工厂本身，需要转义
String FACTORY_BEAN_PREFIX = "&";
//根据bean的名字，获取在IOC容器中得到bean实例
Object getBean(String name) throws BeansException;
//根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。
Object getBean(String name, Class requiredType) throws BeansException;
//提供对bean的检索，看看是否在IOC容器有这个名字的bean
boolean containsBean(String name);
//根据bean名字得到bean实例，并同时判断这个bean是不是单例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
//得到bean实例的Class类型
Class getType(String name) throws NoSuchBeanDefinitionException;
//得到bean的别名，如果根据别名检索，那么其原名也会被检索出来
String[] getAliases(String name);
}在BeanFactory里只对IOC容器的基本行为作了定义，根本不关心你的bean是如何定义怎样加载的。正如我们只关心工厂里得到什么的产品对象，至于工厂是怎么生产这些对象的，这个基本的接口不关心。
而要知道工厂是如何产生对象的，我们需要看具体的IOC容器实现，spring提供了许多IOC容器的实现。比如XmlBeanFactory，ClasspathXmlApplicationContext等。其中XmlBeanFactory就是针对最基本的ioc容器的实现，这个IOC容器可以读取XML文件定义的BeanDefinition（XML文件中对bean的描述）,如果说XmlBeanFactory是容器中的屌丝，ApplicationContext应该算容器中的高帅富.
ApplicationContext是Spring提供的一个高级的IoC容器，它除了能够提供IoC容器的基本功能外，还为用户提供了以下的附加服务。
从ApplicationContext接口的实现，我们看出其特点：
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver { @Nullable String getId(); String getApplicationName(); String getDisplayName(); long getStartupDate(); @Nullable ApplicationContext getParent(); AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException; }1. 支持信息源，可以实现国际化。（实现MessageSource接口）
2. 访问资源。(实现ResourcePatternResolver接口，这个后面要讲)
3. 支持应用事件。(实现ApplicationEventPublisher接口)
4.ApplicationContext 继承了 ListableBeanFactory，这个 Listable 的意思就是，通过这个接口，我们可以获取多个 Bean，大家看源码会发现，最顶层 BeanFactory 接口的方法都是获取单个 Bean 的。
(2) BeanDefinition
SpringIOC容器管理了我们定义的各种Bean对象及其相互的关系，Bean对象在Spring实现中是以BeanDefinition来描述的，其继承体系如下：
Bean 的解析过程非常复杂，功能被分的很细，因为这里需要被扩展的地方很多，必须保证有足够的灵活性，以应对可能的变化。Bean 的解析主要就是对 Spring 配置文件的解析，最后封装成一个个的BeanDefinition对象保存在Ioc容器中（注意，这里并没有实例化的对象，只能认为一个bean对象的信息，如是否懒加载，属性引用，是否单例等等）。这个解析过程主要通过下图中的类完成：
（3）各种IOC容器继承体系
IoC容器的初始化包括BeanDefinition的Resource定位、载入和注册这三个基本的过程。我们以ApplicationContext为例讲解，ApplicationContext系列容器也许是我们最熟悉的，因为web项目中使用的XmlWebApplicationContext就属于这个继承体系，还有ClasspathXmlApplicationContext等，其继承体系如下图所示：
（4）精彩部分来了
ApplicationContext允许上下文嵌套，通过保持父上下文可以维持一个上下文体系。对于bean的查找可以在这个上下文体系中发生，首先检查当前上下文，其次是父上下文，逐级向上，这样为不同的Spring应用提供了一个共享的bean定义环境。
下面我们分别简单地演示一下ioc容器的创建过程
—>定位
1 入口 （ClassPathXmlApplicationContext）
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
//调用自己的构造方法
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}2 构造方法里调用父类的构造方法完成资源加载器和父容器设置动作
（AbstractApplicationContext）
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
......
//获取一个Spring Source的加载器用于读入Spring Bean定义资源文件
protected ResourcePatternResolver getResourcePatternResolver() {
//AbstractApplicationContext继承DefaultResourceLoader，因此也是一个资源加载器
//Spring资源加载器，其getResource(String location)方法用于载入资源
return new PathMatchingResourcePatternResolver(this);
}
//-------------父容器赋值
public void setParent(@Nullable ApplicationContext parent) {
this.parent = parent;
if (parent != null) {
Environment parentEnvironment = parent.getEnvironment();
if (parentEnvironment instanceof ConfigurableEnvironment) {
getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
}
}
}
......
}3 调用setConfigLocations(configLocations);将配置文件路径保存到字符串数组
（AbstractRefreshableConfigApplicationContext）
public abstract class AbstractRefreshableConfigApplicationContext extends AbstractRefreshableApplicationContext
implements BeanNameAware, InitializingBean {
......
//解析Bean定义资源文件的路径，处理多个资源文件字符串数组
public void setConfigLocations(@Nullable String... locations) {
if (locations != null) {
Assert.noNullElements(locations, "Config locations must not be null");
this.configLocations = new String[locations.length];
for (int i = 0; i < locations.length; i++) {
// resolvePath为同一个类中将字符串解析为路径的方法
this.configLocations[i] = resolvePath(locations[i]).trim();
}
}
else {
this.configLocations = null;
}
}
......
}4 调用refresh()方法完成容器启动准备 （模板方法）
（AbstractApplicationContext）
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements
public void refresh() throws BeansException, IllegalStateException {
......
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
//1、调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
//2、告诉子类启动refreshBeanFactory()方法，Bean定义资源文件的载入从
//子类的refreshBeanFactory()方法启动
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
//3、为BeanFactory配置容器特性，例如类加载器、事件处理器等
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
//4、为容器的某些子类指定特殊的BeanPost事件处理器
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
//5、调用所有注册的BeanFactoryPostProcessor的Bean
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
//6、为BeanFactory注册BeanPost事件处理器.
//BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
//7、初始化信息源，和国际化相关.
initMessageSource();
// Initialize event multicaster for this context.
//8、初始化容器事件传播器.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
//9、调用子类的某些特殊Bean初始化方法
onRefresh();
// Check for listener beans and register them.
//10、为事件传播器注册事件监听器.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
//11、初始化所有剩余的单例Bean
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
//12、初始化容器的生命周期事件处理器，并发布容器的生命周期事件
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.
//13、销毁已创建的Bean
destroyBeans();
// Reset 'active' flag.
//14、取消refresh操作，重置容器的同步标识。
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
//15、重设公共缓存
resetCommonCaches();
}
}
}
.......
}5 在AbstractApplicationContext的refresh()里调用abtainFreshBeanFactory()，---->进入abtainFreshBeanFactory()，有个refreshBeanFactory()的抽象方法留给子类实现（委派模式）
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//这里使用了委派设计模式，父类定义了抽象的refreshBeanFactory()方法，
//具体实现调用子类容器的refreshBeanFactory()方法
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}6 进入子类AbstractRefreshableApplicationContext的refreshBeanFactory()，然后调用createBeanFactory(),完成容器创建。（AbstractRefreshableApplicationContext）
public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
......
protected DefaultListableBeanFactory createBeanFactory() {
return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
@Override
protected final void refreshBeanFactory() throws BeansException {
//如果已经有容器，销毁容器中的bean，关闭容器
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
//创建IOC容器
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
//配置是否允许 BeanDefinition 覆盖、是否允许循环引用。
customizeBeanFactory(beanFactory);
//调用载入Bean定义的方法，主要这里又使用了一个委派模式，
// 在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
......
}7 接着在refreshBeanFactory()里调用loadBeanDefinitions方法，开始加载bean。 loadBeanDefinitions是抽象方法，留给子类去实现（委派模式）
—>加载
8 进入子类实现AbstractXmlApplicationContext的重写方法loadBeanDefinitions
（AbstractXmlApplicationContext）
a 创建bean的读取器
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
//创建XmlBeanDefinitionReader，即创建Bean读取器，并通过回调
//设置到容器中去，容 器使用该读取器读取Bean定义资源
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);b 带上上一步创建的XmlBanDefinitionReader开始加载bean
//Bean读取器真正实现加载的方法
loadBeanDefinitions(beanDefinitionReader);9 进入AbstractXmlApplicationContext的重载方法loadBeanDefinitions，首先获取Bean的Resource对象，然后XmlBeanDefinitionReader调用loadBeanDefinitions，根据Resource去加载
（AbstractXmlApplicationContext）
//Xml Bean读取器加载Bean定义资源
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
//获取Bean定义资源的定位
Resource[] configResources = getConfigResources();
if (configResources != null) {
//Xml Bean读取器调用其父类AbstractBeanDefinitionReader读取定位
//的Bean定义资源
reader.loadBeanDefinitions(configResources);
}
//如果子类中获取的Bean定义资源定位为空，则获取FileSystemXmlApplicationContext构造方法中setConfigLocations方法设置的资源
String[] configLocations = getConfigLocations();
if (configLocations != null) {
//Xml Bean读取器调用其父类AbstractBeanDefinitionReader读取定位
//的Bean定义资源
reader.loadBeanDefinitions(configLocations);
}
}10 进入AbstractBeanDefinitionReader 的loadBeanDefinitions方法，方法里调用父接口的loadBeanDefinitions去根据Resource加载，不同格式的Resource去对应的子类实现（委派模式）
（AbstractBeanDefinitionReader ）
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
Assert.notNull(resources, "Resource array must not be null");
int counter = 0;
for (Resource resource : resources) {
counter += loadBeanDefinitions(resource);
}
return counter;
}11 进入对应的实现 XmlBeanDefinitionReader的loadBeanDefinitions方法
（XmlBeanDefinitionReader）
a 将Resource转码处理
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
//将读入的XML资源进行特殊编码处理
return loadBeanDefinitions(new EncodedResource(resource));
}b 调用重载方法loadBeanDefinitions以读流方式加载
//将资源文件转为InputStream的IO流
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
//从InputStream中得到XML的解析源
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//这里是具体的读取过程
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
c 调用方法doLoadBeanDefinitions真正加载，读取配置文件转换成Document对象
//将XML文件转换为DOM对象，解析过程由documentLoader实现
Document doc = doLoadDocument(inputSource, resource);d 调用registerBeanDefinitions方法做注册Bean前准备，如获取一个解析Document对象的解析器，然后调用解析器的registerBeanDefinitions方法进行Bean的注册
//按照Spring的Bean语义要求将Bean定义资源解析并转换为容器内部数据结构
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
//获得容器中注册的Bean数量
int countBefore = getRegistry().getBeanDefinitionCount();
//解析过程入口，这里使用了委派模式，BeanDefinitionDocumentReader只是个接口,
//具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
//统计解析的Bean数量
return getRegistry().getBeanDefinitionCount() - countBefore;
}—>注册
12 进入具体解析注册Bean的实现类，开始解析Document (DefautBeanDefinitionDocumentReader)
a 准备解析前的准备工作
//根据Spring DTD对Bean的定义规则解析Bean定义Document对象
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
//获得XML描述符
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
//获得Document的根元素
Element root = doc.getDocumentElement();
doRegisterBeanDefinitions(root);
}b 进入真正解析的方法doRegisterBeanDefinitions，再根据不同的解析策略调用parseBeanDefinitions进行Document对象转换成Bean的操作
//在解析Bean定义之前，进行自定义的解析，增强解析过程的可扩展性
preProcessXml(root);
//从Document的根元素开始进行Bean定义的Document对象
parseBeanDefinitions(root, this.delegate);
//在解析Bean定义之后，进行自定义的解析，增加解析过程的可扩展性
postProcessXml(root);c 进入parseBeanDefinitions方法，循环调用具体解析策略方法解析每个Element
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//Bean定义的Document对象使用了Spring默认的XML命名空间
if (delegate.isDefaultNamespace(root)) {
//获取Bean定义的Document对象根元素的所有子节点
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
//获得Document节点是XML元素节点
if (node instanceof Element) {
Element ele = (Element) node;
//Bean定义的Document的元素节点使用的是Spring默认的XML命名空间
if (delegate.isDefaultNamespace(ele)) {
//使用Spring的Bean规则解析元素节点
parseDefaultElement(ele, delegate);
}
else {
//没有使用Spring默认的XML命名空间，则使用用户自定义的解//析规则解析元素节点
delegate.parseCustomElement(ele);
}
}
}
}
else {
//Document的根节点没有使用Spring默认的命名空间，则使用用户自定义的
//解析规则解析Document根节点
delegate.parseCustomElement(root);
}
}d 进入默认的解析策略方法parseDefautElement方法，再根据具体策略去解析
//使用Spring的Bean规则解析Document元素节点
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//如果元素节点是导入元素，进行导入解析
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
//如果元素节点是别名元素，进行别名解析
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//元素节点既不是导入元素，也不是别名元素，即普通的元素，
//按照Spring的Bean规则解析元素
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
} e 进入标签解析策略的方法 processBeanDefinition方法，然后经过封装成BeanDefinitionHolder，最后调用BeanDefinitionReaderUtil.registerBeanDefinition向容器注册Bean
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
// BeanDefinitionHolder是对BeanDefinition的封装，即Bean定义的封装类
//对Document对象中元素的解析由BeanDefinitionParserDelegate实现
// BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
//向Spring IOC容器注册解析得到的Bean定义，这是Bean定义向IOC容器注册的入口
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
} BeanDefinitonHolder类：
public class BeanDefinitionHolder implements BeanMetadataElement {
private final BeanDefinition beanDefinition;
private final String beanName;
@Nullable
private final String[] aliases;
}13 进入BeanDefinitionReaderUtil.registerBeanDefinition方法，调用BeanDefinitionRegistry.registerBeanDefinition方法beanName和BeanDefinition为入参向容器注册
（BeanDefinitionReaderUtil）
//获取解析的BeanDefinition的名称
String beanName = definitionHolder.getBeanName();
//向IOC容器注册BeanDefinition
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());14 进入registerBeanDefinition的具体实现类DefaultListableBeanFactory，可以happy的看到以key=beanName和value=BeanDefinition向IOC beanDefinitionMap中put
this.beanDefinitionMap.put(beanName, beanDefinition);4、总结
通过上面的代码，总结一下IOC容器初始化的基本步骤：
1、初始化的入口在容器实现中的refresh()调用来完成
2、对Bean定义载入IOC容器使用的方法是loadBeanDefinition()
其中的大致流程如下：
- （定位）通过ResourceLoader来完成资源文件位置的定位，DefaultResourceLoader是默认的实现，同时上下文就给出了ResourceLoader的实现，可以从类路径，文件系统，URL等方式来定位资源的位置。
- 如果是XMLBeanFactory作为IOC容器，那么需要为他指定Bean定义的资源，也就是说Bean定义文件时通过抽象成Resource来被IOC容器处理的
- （加载）容器通过BeanDefinition来完成定义信息的解析和Bean信息的注册，往往使用的是XmlBeanDefinitionReader来解析Bean的XML定义文件--实际的处理过程是委托给BeanDefinitionParserDelegate来完成的，从而得到bean的定义信息，这些信息在Spring中使用BeanDefinition对象来表示
- （注册）这个名字可以让我们想到loadBeanDefinition() , reagisterBeanDefinition() 这些相关方法。他们都是为处理BeanDefinition服务的，容器解析得到BeanDefinition以后，需要把他在IOC容器中注册，这由IOC实现BeanDefinitionRegistry接口来实现。
- 注册过程就是在IOC容器内部维护一个HashMap来保存得到的BeanDefinition的过程。这个HashMap是IOC容器持有Bean信息的场所，以后对Bean的操作都是围绕这个Hashmap来实现的。