Spring源码分析--容器初始化

Spring框架是一个开源的容器性质的轻量级框架。主要有三大特点：容器、IOC（控制反转）、AOP（面向切面编程）。

一、容器的创建

Spring工厂容器有BeanFactory和ApplicationContext，BeanFactory接口是Spring框架的顶层接口，ApplicationContext是对BeanFactory扩展，BeanFactory在第一次getBean时才会初始化Bean, ApplicationContext是会在加载配置文件时初始化Bean。

BeanFactory的三类实现：XmlBeanFactory,StaticListableBeanFactory,SimpleJndiBeanFactory。在创建BeanFactory时默认是创建XmlBeanFactory下的DefaultListableBeanFactory。ListableBeanFactory是一种可以把所有bean列举出来的BeanFactory；AutowireCapableBeanFactory是一种可以对bean进行管理的BeanFactory,扩展了自动装配的功能；ConfigurableListable BeanFactory实现了ListableBeanFactory和AutowireCapableBeanFactory，此基础上扩展了对bean definitions的分析修改，以及预实例化单例bean的功能，并定义了许多bean相关的细节。DefaultListableBeanFactory是最底层的接口，实现了Configurable ListableBeanFactory和BeanDefinitionRegistry，也就是相当于是一个工厂和注册器。

applicationContext.xml

<bean id="helloService" class="HelloService"/>

BeanFactory通过加载XML创建容器：

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
HelloService helloService = (HelloService) beanFactory.getBean("helloService");
helloService.sayHello();

ApplicationContext通过加载XML创建容器：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
HelloService helloService = (HelloService) beanFactory.getBean("helloService");
helloService.sayHello();

我们现在一般都根据BeanFactory的扩展类ApplicationContext来创建容器，所以我们着重了解ApplicationContext通过加载XML创建过程。

public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
		super(parent);
		// 定位配置文件的位置
		setConfigLocations(configLocations);
		if (refresh) {
			// 启动IOC容器
			refresh();
		}
	}

configLocations就是传入的XML文件路径，接着会判断容器是否创建，refresh()方法就是去启动容器的。接下来我们重点看refresh方法。

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();
			
			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();
			}
		}
	}

1、prepareRefresh()

是为beanFactory的刷新做前置准备的，比如设置一些容器的初始化参数，校验自己设置的这些容器初始化参数的设置是否符合要求等。这方法也就是用来增强容器功能的目的。

2、ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()

前面介绍过ConfigurableListableBeanFactory这里就不在说明。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

		refreshBeanFactory();
		return getBeanFactory();
	}

如果是AnnotationConfigApplicationContext启动会进入GenericApplicationContext，在GenericApplication构造方法中会new DefaultListableBeanFactory()，在refreshBeanFactory方法中给容器设置一个序列化过的id，然后返回刚刚创建成功的这个容器。xml启动会进入AbstractRefreshableApplicationContext.refreshBeanFactory方法。

protected final void refreshBeanFactory() throws BeansException {
		// 如果存在beanFactory，销毁单例bean ，关闭beanFactory
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			// 定制beanFactory，设置参数
			customizeBeanFactory(beanFactory);
			// 注册spring的xml配置的bean到beanFactory，此时容器还未指定beanbeanFactory
			loadBeanDefinitions(beanFactory);
			// 给容器指定beanFactory
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

里面就会去加载XML，并且把bean注册到容器中，我们跟踪loadBeanDefinitions方法，一直到XmlBeanDefinitionReader类中的loadBeanDefinitions方法。我截取其中重要一段

try {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				//加载xml配置注册bean
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}

可以看到创建一个输入流去XML中读取bean信息，由此我们可以知道bean的信息是由BeanDefinition来保存的。继续跟进就是到了DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions中。

preProcessXml(root);
parseBeanDefinitions(root, this.delegate);//上下两个方法调用都是空实现
postProcessXml(root);

this.delegate = parent;

if (delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);//默认标签解析
}
else {
delegate.parseCustomElement(ele);//自定义tag标签解析
}

在parseBeanDefinitions中会有两种解析xml方式，我们知道默认xml中会有命名空间的，而beans，bean等元素我们是没有使用命名空间前缀的，其他的都是要添加xmlns:XXX="URI"，所以面对不同的规则Spring带有不同的命名空间解析器去解析相应的标签，NamespaceHandler有如AopNamespaceHandler，MvcNamespaceHandler。

//根据URL查找对应的NameSpaceHandler并初始化
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		//调用对应的解析器解析相应的配置
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));

而解析bean标签会进入

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//解析bean标签
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				// 注册最后修饰后的实例beanDefinition
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

最终会bean注册registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())，也就是到进去DefaultListableBeanFactory中去。

/** Map of bean definition objects, keyed by bean name. */
	// beanName----beanDefinition
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

 

3、prepareBeanFactory(beanFactory)

为创建新创建的好的beanFactory设置一些它作为一个容器应该拥有的东西，设置类加载器，添加Bean后置处理器Application ContextAwareProcessor、 ApplicationListenerDetector等。

4、postProcessBeanFactory(beanFactory)

空方法留作扩展用，用于允许在上下文的子类中对beanFactory进行后处理，比如AbstractRefreshableWebApplicationContext。