【Spring源码阅读】 Spring容器初始化流程

以下面测试代码为例：

public class BaseTest {
   
    public static void main(String[] args) {
   
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
        TestBean testBean = context.getBean("testBean", TestBean.class);
        testBean.echo();
    }
}

运行后，首先调用ClassPathXmlApplicationContext构造函数

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
   
	this(new String[] {
   configLocation}, true, null);
}

具体调用以下构造方法：

// configLocations = new String[] {configLocation}
// refresh = true，表示要刷新初始化容器
// parent = null,表示不存在父容器
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
		throws BeansException {
   
    // 通过层层调用父构造函数，主要初始化了this.resourcePatternResolver=new PathMatchingResourcePatternResolver(this);后续可以通过适配符寻找符合条件的java类
	super(parent);
	// 遍历解析传入的配置文件路径，将路径中的占位符替换成相关的环境变量。
	setConfigLocations(configLocations);
	if (refresh) {
    // true
	    // 调用父类AbstractApplicationContext中定义的refresh方法，完成Spring容器和应用上下文的创建工作。
		refresh();
	}
}

refresh方法源码

具体refresh代码如下：

public void refresh() throws BeansException, IllegalStateException {
   
	synchronized (this.startupShutdownMonitor) {
   
		// 供子类拓展，添加创建前必需属性，校验如果必需属性不存在则抛出MissingRequiredPropertiesException异常
		prepareRefresh();

		// 调用子类实现方法获取（创建或刷新）BeanFacotry容器，对于ClassPathXmlApplicationContext，主要调用了AbstractRefreshableApplicationContext中实现的方法
		// 在这里，将xml配置文件中 的Bean解析成了一个个BeanDefinition,建立一个beanName-> beanDefinition 的 map
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 设定类加载器，spel解析器，属性编辑解析器等，忽略特定接口的依赖注册（在特定时刻相关Bean再完成注入)，注册一些系统Bean供依赖注入使用。
		prepareBeanFactory(beanFactory);

		try {
   
			// BeanFactory创建完的后置处理。当前为空实现，供子类拓展
			postProcessBeanFactory(beanFactory);

			// 调用BeanFacotry的相关后置处理器，如果实现了Order相关接口，会先进行排序。
			invokeBeanFactoryPostProcessors(beanFactory);

			// 注册相关BeanPostProcessor，供Bean生成前后调用。
			registerBeanPostProcessors(beanFactory);

			// 初始化国际化信息源
			initMessageSource();

			// 初始化Spring相关上下文时间广播器
			initApplicationEventMulticaster();

			// 模版方法供子类实现，用于初始化一些特殊Bean配置等
			onRefresh();

			// 注册实现了ApplicationListener接口的事件监听器，用于后续广播器广播事件
			registerListeners();

			// BeanFactory初始化完成时调用，初始ConversionService Bean，冻结beanFactory配置，并开始创建BeanFactory中所有非懒加载的单例Bean
			finishBeanFactoryInitialization(beanFactory);

			// 初始化Lifecycle处理器，调用onRefresh方法，广播ContextRefreshedEvent。
			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;
		}
	}
}

prepareRefresh实现

下面先粗略讲解refresh函数下每一步操作的源码实现：

// 供子类拓展，添加创建前必需属性，校验如果必需属性不存在则抛出MissingRequiredPropertiesException异常
protected void prepareRefresh() {
   
	this.startupDate = System.currentTimeMillis();

	synchronized (this.activeMonitor) {
   
		this.active = true;
	}

	if (logger.isInfoEnabled()) {
   
		logger.info("Refreshing " + this);
	}

	// 内部是一个空实现，主要供子类拓展自己ApplicationContext，设置必需的属性
	initPropertySources();

	// 校验必需的属性是否存在，具体参考下面的代码
	getEnvironment().validateRequiredProperties();
}

public void validateRequiredProperties() {
   
	MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
	for (String key : this.requiredProperties) {
   
	    // 如果存在属性缺失，记录下来
		if (this.getProperty(key) == null) {
   
			ex.addMissingRequiredProperty(key);
		}
	}
	// 存在缺失属性则抛出异常
	if (!ex.getMissingRequiredProperties().isEmpty()) {
   
		throw ex;
	}
}

obtainFreshBeanFactory实现

// 调用子类实现方法获取（创建或刷新）BeanFacotry容器，对于ClassPathXmlApplicationContext，主要调用了AbstractRefreshableApplicationContext中实现的方法
// 在这里，将xml配置文件中 的Bean解析成了一个个BeanDefinition,建立一个beanName-> beanDefinition 的 map
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   
    // 刷新初始化BeanFactory，核心在这一步
	refreshBeanFactory();
	// 获取上一步初始化的BeanFactory
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
   
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}

refreshBeanFactory方法实现

具体实现位于AbstractRefreshableApplicationContext类下：

protected final void refreshBeanFactory() throws BeansException {
   
    // 如果已经存在，先销毁存在的
	if (hasBeanFactory()) {
   
	    // 销毁工厂的所有相关单例Bean
		destroyBeans();
		// 清理工厂相关配置
		closeBeanFactory();
	}
	try {
   
	    // 通过new DefaultListableBeanFactory(getInternalParentBeanFactory())创建一个空工厂实例
	    // 其中getInternalParentBeanFactory()=null
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		// 记录映射id -> DefaultListableBeanFactory到一个静态Map
		beanFactory.setSerializationId(getId());
		// 定制Bean工厂，主要供用户自定义子类拓展是否允许BeanDefinition重写(默认true)、循环引用(默认true)等功能。
		customizeBeanFactory(beanFactory);
		// 读取xml配置，将配置中定义的Bean以BeanDefinition封装保存到beanFactory中。
		loadBeanDefinitions(beanFactory);
		// 记录引用。
		synchronized (this.beanFactoryMonitor) {
   
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
   
		throw new ApplicationContextException("I/O error parsing bean definition source for "