IOC 容器的初始化包括 BeanDefinition 的 Resource 定位、载入和注册这三个基本的过程。我们以 ApplicationContext 为例讲解，ApplicationContext 系列容器也许是我们最熟悉的，因为 Web项 目 中 使 用 的 XmlWebApplicationContext 就 属 于 这 个 继 承 体 系 , 还 有ClasspathXmlApplicationContext 等，其继承体系如下图所示：

ApplicationContext 允许上下文嵌套，通过保持父上下文可以维持一个上下文体系。对于 Bean 的查找可以在这个上下文体系中发生，首先检查当前上下文，其次是父上下文，逐级向上，这样为不同的Spring 应用提供了一个共享的 Bean 定义环境。

这里我们以FileSystemXmlApplicationContext 的 IOC 容器流程：

ApplicationContext = new FileSystemXmlApplicationContext(xmlPath);

(1)、先看其构造函数的调用：

public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
		 this(configLocations, true, null);
}

其实际调用的构造函数为：

public FileSystemXmlApplicationContext(
	String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
	throws BeansException {
	super(parent);
	setConfigLocations(configLocations);
	if (refresh) {
		refresh();
	}
}

(2)、设置资源加载器和资源定位
通 过 分 析 FileSystemXmlApplicationContext 的 源 代 码 可 以 知 道 ， 在 创 建
FileSystemXmlApplicationContext 容器时，构造方法做以下两项重要工作：
首先，调用父类容器的构造方法(super(parent)方法)为容器设置好 Bean 资源加载器。
然 后 ， 再 调 用 父 类 AbstractRefreshableConfigApplicationContext 的
setConfigLocations(configLocations)方法设置 Bean 定义资源文件的定位路径。
通 过 追 踪 FileSystemXmlApplicationContext 的 继 承 体 系 ， 发 现 其 父 类 的 父 类AbstractApplicationContext 中初始化 IOC 容器所做的主要源码如下：

public abstract class AbstractApplicationContext extends DefaultResourceLoader
	implements ConfigurableApplicationContext {
		//静态初始化块，在整个容器创建过程中只执行一次
		static {
		//为了避免应用程序在 Weblogic8.1 关闭时出现类加载异常加载问题，加载 IOC 容
		//器关闭事件(ContextClosedEvent)类
		ContextClosedEvent.class.getName();
	}
	public AbstractApplicationContext() {
		this.resourcePatternResolver = getResourcePatternResolver();
	}
		public AbstractApplicationContext(@Nullable ApplicationContext parent) {
		this();
		setParent(parent);
	}
		//获取一个 Spring Source 的加载器用于读入 Spring Bean 定义资源文件
		protected ResourcePatternResolver getResourcePatternResolver() {
		//AbstractApplicationContext 继承 DefaultResourceLoader，因此也是一个资源加载器
		//Spring 资源加载器，其 getResource(String location)方法用于载入资源
		return new PathMatchingResourcePatternResolver(this);
	}
	...
}

AbstractApplicationContext 构造方法中调用 PathMatchingResourcePatternResolver 的构造方法创建 Spring 资源加载器：

public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {
	Assert.notNull(resourceLoader, "ResourceLoader must not be null");
	//设置 Spring 的资源加载器
	this.resourceLoader = resourceLoader;
}

在 设 置 容 器 的 资 源 加 载 器 之 后 ， 接 下 来 FileSystemXmlApplicationContext 执 行setConfigLocations 方法通过调用其父AbstractRefreshableConfigApplicationContext 的方法进行对 Bean 定义资源文件的定位，该方法的源码如下：

//处理单个资源文件路径为一个字符串的情况
public void setConfigLocation(String location) {
	//String CONFIG_LOCATION_DELIMITERS = ",; /t/n";
	//即多个资源文件路径之间用” ,; \t\n”分隔，解析成数组形式
	setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS));
	}
	//解析 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;
	}
}

通过这两个方法的源码我们可以看出，我们既可以使用一个字符串来配置多个 Spring Bean 定义资源
文件，也可以使用字符串数组，即下面两种方式都是可以的：
ClasspathResource res = new ClasspathResource(“a.xml,b.xml,……”);
多个资源文件路径之间可以是用” , ; \t\n”等分隔。
B. ClasspathResource res = new ClasspathResource(newString[]{“a.xml”,”b.xml”,……});
至此，SpringIOC 容器在初始化时将配置的 Bean 定义资源文件定位为 Spring 封装的 Resource。
(3)、AbstractApplicationContext 的 refresh 函数载入 Bean 定义过程：SpringIOC 容器对 Bean 定义资源的载入是从 refresh()函数开始的，refresh()是一个模板方法，refresh()方法的作用是：在创建 IOC 容器前，如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证在 refresh 之后使用的是新建立起来的 IOC 容器。refresh 的作用类似于对 IOC 容器的重启，在新建立好的容器中对容器进行初始化，对 Bean 定义资源进行载入FileSystemXmlApplicationContext 通过调用其父类 AbstractApplicationContext 的 refresh()函数启动整个 IOC 容器对 Bean 定义的载入过程：

	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) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				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...
				resetCommonCaches();
			}
		}
	}

refresh()方法主要为 IOC 容器 Bean 的生命周期管理提供条件，Spring IOC 容器载入 Bean 定义资源文 件 从 其 子 类 容 器 的 refreshBeanFactory() 方 法 启 动 ， 所 以 整 个 refresh() 中“ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();”这句以后代码的都是注册容器的信息源和生命周期事件，载入过程就是从这句代码启动。refresh()方法的作用是：在创建 IOC 容器前，如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证在 refresh 之后使用的是新建立起来的 IOC 容器。refresh 的作用类似于对 IOC 容器的重启，在新建立好的容器中对容器进行初始化，对 Bean 定义资源进行载入。
(4) 、 AbstractApplicationContext 的 obtainFreshBeanFactory() 方 法 调 用 子 类 容 器 的refreshBeanFactory()方法，启动容器载入 Bean 定义资源文件的过程，代码如下：

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	//这里使用了委派设计模式，父类定义了抽象的 refreshBeanFactory()方法，具体实现调用子类容器的 refreshBeanFactory()方
法
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

AbstractApplicationContext 类中只抽象定义了 refreshBeanFactory()方法，容器真正调用的是其子类 AbstractRefreshableApplicationContext 实现的 refreshBeanFactory()方法，方法的源码如下：

	protected final void refreshBeanFactory() throws BeansException {
	//如果已经有容器，销毁容器中的 bean，关闭容器
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			//创建 IOC 容器
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			//对 IOC 容器进行定制化，如设置启动参数，开启注解的自动装配等
			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);
		}
	}

在这个方法中，先判断 BeanFactory 是否存在，如果存在则先销毁 beans 并关闭 beanFactory，接着创建 DefaultListableBeanFactory，并调用loadBeanDefinitions(beanFactory)装载 bean 定义。
(5)、AbstractRefreshableApplicationContext 子类的 loadBeanDefinitions 方法：
AbstractRefreshableApplicationContext 中只定义了抽象的 loadBeanDefinitions 方法，容器真 正 调 用 的 是 其 子 类 AbstractXmlApplicationContext 对 该 方 法 的 实 现 ，
AbstractXmlApplicationContext 的主要源码如下：loadBeanDefinitions 方 法 同 样 是 抽 象 方 法 ， 是 由 其 子 类 实 现 的 ， 也 即 在AbstractXmlApplicationContext 中。

	//实现父类抽象的载入 Bean 定义方法
	@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		//创建 XmlBeanDefinitionReader，即创建 Bean 读取器，并通过回调设置到容器中去，容器使用该读取器读取 Bean 定义资源
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	//为 Bean 读取器设置 Spring 资源加载器，AbstractXmlApplicationContext 的
	//祖先父类 AbstractApplicationContext 继承 DefaultResourceLoader，因此，容器本身也是一个资源加载器
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		//为 Bean 读取器设置 SAX xml 解析器
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		//当 Bean 读取器读取 Bean 定义的 Xml 资源文件时，启用 Xml 的校验机制
		initBeanDefinitionReader(beanDefinitionReader);
		//Bean 读取器真正实现加载的方法
		loadBeanDefinitions(beanDefinitionReader);
	}
	
	protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
		reader.setValidating(this.validating);
	}
	
	//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);
		}
	}

Xml Bean 读取器(XmlBeanDefinitionReader)调用其父类 AbstractBeanDefinitionReader 的reader.loadBeanDefinitions 方法读取 Bean 定义资源。
由于我们使用 FileSystemXmlApplicationContext 作为例子分析，因此getConfigResources 的返回值为 null，因此程序执行reader.loadBeanDefinitions(configLocations)分支。

(6) 、 AbstractBeanDefinitionReader 读 取 Bean 定 义 资 源 , 在 其 抽 象 父 类
AbstractBeanDefinitionReader 中定义了载入过程。
AbstractBeanDefinitionReader 的 loadBeanDefinitions 方法源码如下：

	public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
	//获取在 IOC 容器初始化过程中设置的资源加载器
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}

		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
			//将指定位置的 Bean 定义资源文件解析为 Spring IOC 容器封装的资源
			//加载多个指定位置的 Bean 定义资源文件
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				//委派调用其子类 XmlBeanDefinitionReader 的方法，实现加载功能
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			//将指定位置的 Bean 定义资源文件解析为 Spring IOC 容器封装的资源
			//加载单个指定位置的 Bean 定义资源文件
			Resource resource = resourceLoader.getResource(location);
			//委派调用其子类 XmlBeanDefinitionReader 的方法，实现加载功能
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
			}
			return loadCount;
		}
	}
	
	//重载方法，调用 loadBeanDefinitions(String);
	@Override
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
	Assert.notNull(locations, "Location array must not be null");
	int counter = 0;
	for (String location : locations) {
		counter += loadBeanDefinitions(location);
	}
	return counter;
}

loadBeanDefinitions(Resource…resources)方法和上面分析的 3 个方法类似，同样也是调用XmlBeanDefinitionReader 的 loadBeanDefinitions 方法。