Spring容器刷新源码剖析

容器刷新核心代码

//@Code AbstractApplicationContextx.refresh()
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		prepareRefresh();
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
		prepareBeanFactory(beanFactory);
		try {
			postProcessBeanFactory(beanFactory);
			invokeBeanFactoryPostProcessors(beanFactory);
			registerBeanPostProcessors(beanFactory);
			initMessageSource();
			initApplicationEventMulticaster();
			onRefresh();
			registerListeners();
			finishBeanFactoryInitialization(beanFactory);
			finishRefresh();
		}
		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}
			destroyBeans();
			cancelRefresh(ex);
			throw ex;
		}
		finally {
			resetCommonCaches();
		}
	}
}

prepareRefresh

容器启动前的准备工作，打标志、替换占位符等。

	protected void prepareRefresh() {
		//记录容器启动时间、标识一些状态
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);
		if (logger.isInfoEnabled()) {
			logger.info("Refreshing " + this);
		}
		//处理上下文文件中的占位符，子类实现。
		initPropertySources();
		//检验环境属性是否符合要求
		getEnvironment().validateRequiredProperties();
		//为保存容器中的早期事件做准备
		this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
	}

obtainFreshBeanFactory⭐

创建BeanFactory(DefaultListableBeanFactory)、为BeanFactory设置ID、配置BeanFactory、解析Bean定义信息并保存到BeanFactory中（beanName和beanDefinition组成的Map）

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		//创建BeanFactory、设置ID、配置BeanFactory、解析并保存配置中的Bean定义信息
		refreshBeanFactory();
		//取出创建好的BeanFactory
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

prepareBeanFactory

BeanFactory的准备工作，在BeanFactory中设置类加载器、表达式解析器、Bean属性管理工具、Bean后置处理器、一些接口的忽略自动装配（很少用到default-autowire）

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		//设置类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
		//设置表达式解析器
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		//设置Bean属性管理工具
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
		//设置Bean后置处理器 【ApplicationContextAwareProcessor】
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置一些接口的忽略自动装配
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
//设置几个自动装配的特殊规则
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

//设置Bean后置处理器 【ApplicationListenerDetector】
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

//按需往BeanFactory中注册一些单实例Bean
//编译时的AspectJ
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
//一些默认的环境
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

postProcessBeanFactory(beanFactory)

BeanFactory准备工作完成后进行的后置处理工作，留给子类实现。

	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

invokeBeanFactoryPostProcessors(beanFactory)

按一定的顺序执行BeanFactory中BeanFactoryPostProcessor的方法。
postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	    //按顺序执行BeanFactory中BeanFactoryPostProcessor的方法
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

//BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor 
interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor{
   void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
   //继承自BeanFactoryPostProcessor
   void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

registerBeanPostProcessors(beanFactory)

按一定的顺序向容器中设置BeanPostProcessor

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}
		// First, register the BeanPostProcessors that implement PriorityOrdered.
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
		// Next, register the BeanPostProcessors that implement Ordered.
		...
		// Now, register all regular BeanPostProcessors.
		...
		// Finally, re-register all internal BeanPostProcessors.
		...
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

initMessageSource

国际化，BeanFactory中注入messageSource单实例

initApplicationEventMulticaster

初始化事件广播器，BeanFactory中注入applicationEventMulticaster单实例

onRefresh

模板方法(钩子方法)，留给子类实现。可以在此初始化一些特殊的Bean（在初始化 singleton beans 之前）

registerListeners

注册事件监听器，广播this.earlyApplicationEvents事件

finishBeanFactoryInitialization(beanFactory)⭐

初始化所有的非Lazy_Init的singleton beans 方法详解

finishRefresh

最后广播容器初始化完成事件