Spring源码解析(8)——ApplicationContext

回顾上篇

上篇文章《属性注入》，我们已经分析完了bean中的属性是如何注入进去的。到目前为止我们已经分析完了Spring创建一个bean的全流程。先是解析配置的xml文件，将xml文件里配置的信息解析成BeanDefinition，然后通过BeanDefinition来创建bean，同时也会将bean的属性值注入。这里面也涉及到一个循环依赖的问题，也分析了一下Spring是如何来解决循环依赖的。上面的分析我们都是基于BeanFacotry接口的实现类XmlBeanFactory来分析的，在Spring中还提供了另外一个接口ApplicationContext，这个接口包含了BeanFacotry的所有功能，也提供了更多的扩展功能。接下来我们就看看ApplicationContext。

分析源码实现

ApplicationContext的使用

package com.guiji.test;

import com.guiji.bean.MyTestBean;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanFactoryTest {

	@Test
	public void testSimpleLoad(){

		//BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("BeanFactoryTest.xml"));
		
		ApplicationContext beanFactory = new ClassPathXmlApplicationContext("BeanFactoryTest.xml");
		
		MyTestBean myTestBean = (MyTestBean) beanFactory.getBean("myTestBean");

		String testStr = myTestBean.getTestStr();

		System.out.println(testStr);

		Assert.assertEquals("javaGuiji",testStr);
		
	}

}

进入到ClassPathXmlApplicationContext中，开始对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);
	//设置xml文件路径
	setConfigLocations(configLocations);
	if (refresh) {
		refresh();
	}
}

这里面首先设置了xml文件的路径，然后在调用了refresh方法。ApplicationContext 的功能几乎都是在refresh方法里面完成的。我们看到refresh方法。

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// 准备刷新的上下文环境
		prepareRefresh();
		// 创建beanFactory,读取xml文件，解析xml文件，注册BeanDefinition
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
		// 添加扩展功能，比如添加SPEL语言支持、属性编辑器支持，
		prepareBeanFactory(beanFactory);
		try {
			// 空方法 允许子类进行扩展
			postProcessBeanFactory(beanFactory);
			// 激活BeanFactory处理器
			invokeBeanFactoryPostProcessors(beanFactory);
			// 注册BeanPostProcessors
			registerBeanPostProcessors(beanFactory);
			// 初始化消息源，国际化处理
			initMessageSource();
			// 初始化广播器，用于广播事件
			initApplicationEventMulticaster();
			// 空方法，留给子类实现
			onRefresh();
			// 注册监听器
			registerListeners();
			// 初始化剩下的单实例
			finishBeanFactoryInitialization(beanFactory);
			// 完成刷新过程，通知生命周期处理器，发布ContextRefreshedEvent事件
			finishRefresh();
		}
		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}
			//发生异常 销毁创建的bean
			destroyBeans();
			cancelRefresh(ex);
			throw ex;
		}
		finally {
			resetCommonCaches();
		}
	}
}

这段代码逻辑很清晰，每一块内容都封装到一个方法里面，下面我们重点分析obtainFreshBeanFactory、invokeBeanFactoryPostProcessors、registerBeanPostProcessors、initApplicationEventMulticaster、registerListeners、finishBeanFactoryInitialization、finishRefresh这几个方法。

obtainFreshBeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	refreshBeanFactory();
	return getBeanFactory();
}
	
@Override
protected final void refreshBeanFactory() throws BeansException {
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	try {
		//创建beanFactory
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		customizeBeanFactory(beanFactory);
		//读取xml文件，解析xml文件，注册BeanDefinition
		loadBeanDefinitions(beanFactory);
		this.beanFactory = beanFactory;
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

这里面首先创建了一个DefaultListableBeanFactory，然后通过loadBeanDefinitions（beanFactory）来去对配置文件进行加载，解析，和注册BeanDefinition。这一步其实就是我们之前2、3、4中的内容，这里不清楚可以回过头去看看。

invokeBeanFactoryPostProcessors

这一步会获取到所有的BeanFactoryPostProcessors去执行postProcessBeanDefinitionRegistry方法和postProcessBeanFactory方法，如果是BeanDefinitionRegistryPostProcessor类型那么两个方法都会执行，不是的话就只会执行postProcessBeanFactory方法。

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		Set<String> processedBeans = new HashSet<>();
		//判断beanFactory是否为BeanDefinitionRegistry，beanFactory为DefaultListableBeanFactory,
		//DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，所以为true
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			//保存BeanFactoryPostProcessor用于最后执行postProcessBeanFactory方法
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			//保存BeanDefinitionRegistryPostProcessor用于最后执行postProcessBeanFactory方法
			//这里面用两个List来保存是因为BeanFactoryPostProcessor
			//和BeanDefinitionRegistryPostProcessor执行postProcessBeanFactory方法有优先级，
			//需要先执行完BeanDefinitionRegistryPostProcessor的
			//postProcessBeanFactory方法再执行BeanFactoryPostProcessor的
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
			//遍历参数中传入的BeanFactoryPostProcessor
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				//如果是BeanDefinitionRegistryPostProcessor类型的执行postProcessBeanDefinitionRegistry方法并且保存到registryProcessor中
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				//不是BeanDefinitionRegistryPostProcessor类型不需要执行postProcessBeanDefinitionRegistry方法，直接保存到regularPostProcessors中
				else {
					regularPostProcessors.add(postProcessor);
				}
			}
			//保存当前要执行postProcessBeanDefinitionRegistry方法的BeanDefinitionRegistryPostProcessor
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
			//获取容器中所有的实现了BeanDefinitionRegistryPostProcessor接口的bean的名称
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			//遍历名称
			for (String ppName : postProcessorNames) {
				//如果实现了PriorityOrdered接口
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					//将这个BeanDefinitionRegistryPostProcessor保存到currentRegistryProcessors中，
					//用于一起执行postProcessBeanDefinitionRegistry方法。
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//并且将bean的名称保存到processedBeans中
					processedBeans.add(ppName);
				}
			}
			//根据PriorityOrdered来排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//将BeanDefinitionRegistryPostProcessor保存到registryProcessors中，用于后面一起执行postProcessBeanFactory方法。
			registryProcessors.addAll(currentRegistryProcessors);
			//对currentRegistryProcessors中的BeanDefinitionRegistryPostProcessor执行postProcessBeanDefinitionRegistry方法		
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			//清空currentRegistryProcessors
			currentRegistryProcessors.clear();

			//同样是获取容器中所有的实现了BeanDefinitionRegistryPostProcessor接口的bean的名称
			//这里不直接用上面的postProcessorNames，要重新获取一遍是因为执行了postProcessBeanDefinitionRegistry之后
			//可能会有新的BeanDefinitionRegistryPostProcessor产生
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				//如果实现类Ordered接口
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			//根据Ordered排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// 最后处理经过上面两个步骤后剩下的BeanDefinitionRegistryPostProcessor
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					//上面两个步骤没有处理过的BeanDefinitionRegistryPostProcessor
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			//最后先执行registryProcessors中的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			//再执行regularPostProcessors中的BeanFactoryPostProcessor的postProcessBeanFactory方法			
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}
		else {
			//如果beanFactory不是BeanDefinitionRegistry类型的，就只需要执行postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}
		//上面处理完了容器中的BeanDefinitionRegistryPostProcessor
		//接下来是处理容器中的BeanFactoryPostProcessor，逻辑和
		//BeanDefinitionRegistryPostProcessor的处理逻辑相似
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}
		
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);


		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		beanFactory.clearMetadataCache();
	}

registerBeanPostProcessors

这里主要是将BeanPostProcessor注册到beanFactory中，在bean的初始化前后分别会调用BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法，这个我们可以看到获取bean的那段代码。

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			//执行所有BeanPostProcessor的postProcessBeforeInitialization方法
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			//执行所有BeanPostProcessor的postProcessAfterInitialization方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

接下来我们看看BeanPostProcessor是如何进行注册的。

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
		//获取所有实现BeanPostProcessor接口的名称
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
		//用于保存实现PriorityOrdered接口的BeanPostProcessor
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		//用于保存Spring内部的BeanPostProcessor
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		//用于保存实现Ordered接口的BeanPostProcessor的beanName
		List<String> orderedPostProcessorNames = new ArrayList<>();
		//用于保存普通BeanPostProcessor的beanName
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		//遍历postProcessorNames, 将BeanPostProcessors保存到不同的List中
		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);
			}
		}

		// 首先, 注册实现PriorityOrdered接口的BeanPostProcessors
		// 排序
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		//注册priorityOrderedPostProcessors
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		//再注册实现Ordered接口的BeanPostProcessors
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		//排序
		sortPostProcessors(orderedPostProcessors, beanFactory);
		//注册orderedPostProcessors
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 处理普通的BeanPostProcessors
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 最后注册内部BeanPostProcessors
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);
		
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

initApplicationEventMulticaster

这里主要是用来初始化广播器的，用于广播事件，通知监听器。在Spring刷新完成的时候就会通过这个广播来发送一个ContextRefreshedEvent事件来通知监听器。

protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		//存在名字为applicationEventMulticaster的bean就使用这个bean作为广播器
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			//不存在就创建一个默认的广播器 SimpleApplicationEventMulticaster
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
						"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
			}
		}
	}

registerListeners

这里主要是把硬编码设置的监听器和容器里的监听器都进行注册。用户广播器对其进行通知。

protected void registerListeners() {
		// 注册硬编码监听器
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		//注册容器中的监听器
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// 如果在监听器注册之前就有事件发布，则要把之前的事件进行发布，通知监听器
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

finishBeanFactoryInitialization

这里主要是将bean冻结，以及实例化所有剩余的非懒加载单例 bean。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		beanFactory.setTempClassLoader(null);
		//冻结所有bean定义，注册的bean定义已经不能再被修改了，因为要开始创建 Bean 实例对象了
		beanFactory.freezeConfiguration();
		//实例化所有剩余的非懒加载单例 bean
		beanFactory.preInstantiateSingletons();
	}

在preInstantiateSingletons中去实例化bean的逻辑，与我们之前在获取bean中分析的逻辑是一样的，不清楚可以再回头去看一下。

finishRefresh

在这里主要是调用实现了Lifecysle接口的bean的start方法，开始生命周期，发送ContextRefreshedEvent事件，通知监听器刷新完成。

protected void finishRefresh() {
		clearResourceCaches();

		//初始化生命周期处理器
		initLifecycleProcessor();

		//调用实现了Lifecysle接口的bean的start方法
		getLifecycleProcessor().onRefresh();

		// 发布ContextRefreshedEvent事件
		publishEvent(new ContextRefreshedEvent(this));

		LiveBeansView.registerApplicationContext(this);
	}