Spring的整体流程其实就是通过配置 xml、注解将自定义bean类信息进行配置，然后通过BeanDefinitionReader读取配置信息，由Dom转换成xml解析成Docment。在通过加载的配置信息进行初始化Bean对象，然后在对象的前后进行处理，也就是不同的处理器，AOP、自动装配、事务等其实都是这个原理。而我们的IOC容器本质其实就是一个Map对象。

spring-bean最核心的两个类：DefaultListableBeanFactory和XmlBeanDefinitionReader

DefaultListableBeanFactory

上面类图中各个类及接口的作用如下：

• AliasRegistry：定义对alias的简单增删改等操作
• SimpleAliasRegistry：主要使用map作为alias的缓存，并对接口AliasRegistry进行实现
• SingletonBeanRegistry：定义对单例的注册及获取
• BeanFactory：定义获取bean及bean的各种属性
• DefaultSingletonBeanRegistry：默认对接口SingletonBeanRegistry各函数的实现
• HierarchicalBeanFactory：继承BeanFactory，也就是在BeanFactory定义的功能的基础上增加了对parentFactory的支持
• BeanDefinitionRegistry：定义对BeanDefinition的各种增删改操作
• FactoryBeanRegistrySupport：在DefaultSingletonBeanRegistry基础上增加了对FactoryBean的特殊处理功能
• ConfigurableBeanFactory：提供配置Factory的各种方法
• ListableBeanFactory：根据各种条件获取bean的配置清单
• AbstractBeanFactory：综合FactoryBeanRegistrySupport和ConfigurationBeanFactory的功能
• AutowireCapableBeanFactory：提供创建bean、自动注入、初始化以及应用bean的后处理器
• AbstractAutowireCapableBeanFactory：综合AbstractBeanFactory并对接口AutowireCapableBeanFactory进行实现
• ConfigurableListableBeanFactory：BeanFactory配置清单，指定忽略类型及接口等
• DefaultListableBeanFactory：综合上面所有功能，主要是对Bean注册后的处理
  XmlBeanFactory对DefaultListableBeanFactory类进行了扩展，主要用于从XML文档中读取BeanDefinition，对于注册及获取Bean都是使用从父类DefaultListableBeanFactory继承的方法去实现，而唯独与父类不同的个性化实现就是增加了XmlBeanDefinitionReader类型的reader属性。在XmlBeanFactory中主要使用reader属性对资源文件进行读取和注册

XmlBeanDefinitionReader

XML配置文件的读取是Spring中重要的功能，因为Spring的大部分功能都是以配置作为切入点的，可以从XmlBeanDefinitionReader中梳理一下资源文件读取、解析及注册的大致脉络，首先看看各个类的功能

ResourceLoader：定义资源加载器，主要应用于根据给定的资源文件地址返回对应的Resource
BeanDefinitionReader：主要定义资源文件读取并转换为BeanDefinition的各个功能
EnvironmentCapable：定义获取Environment方法
DocumentLoader：定义从资源文件加载到转换为Document的功能
AbstractBeanDefinitionReader：对EnvironmentCapable、BeanDefinitionReader类定义的功能进行实现
BeanDefinitionDocumentReader：定义读取Document并注册BeanDefinition功能
BeanDefinitionParserDelegate：定义解析Element的各种方法

ClassPathXmlApplicationContext

因为我们是使用XML进行加载启动的。

		ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("beans.xml");ServiceA beanServiceA = classPathXmlApplicationContext.getBean(ServiceA.class);

启动的时候会刷新容器

	public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)throws BeansException {super(parent);setConfigLocations(configLocations);if (refresh) {refresh(); //刷新容器}}

而这个刷新方法其实是比较核心的方法

	public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");//准备上下文环境 Prepare this context for refreshing.prepareRefresh();// Tell the subclass to refresh the internal bean factory.// 工厂创建：BeanFactory第一次开始创建的时候,有xml解析逻辑。ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//给容器中注册了环境信息作为单实例Bean方便后续自动装配；放了一些后置处理器处理（监听、xxAware功能） Prepare the bean factory for use in this context.prepareBeanFactory(beanFactory);try {//留给子类的模板方法，允许子类继续对工厂执行一些处理； Allows post-processing of the bean factory in context subclasses.postProcessBeanFactory(beanFactory);StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");//【大核心】工厂增强：执行所有的BeanFactory后置增强器；利用BeanFactory后置增强器对工厂进行修改或者增强,配置类会在这里进行解析。 Invoke factory processors registered as beans in the context.invokeBeanFactoryPostProcessors(beanFactory);//【核心】注册所有的Bean的后置处理器 Register bean processors that intercept bean creation.registerBeanPostProcessors(beanFactory);beanPostProcess.end();//初始化国际化功能 Initialize message source for this context.initMessageSource();//初始化事件多播功能（事件派发） Initialize event multicaster for this context.initApplicationEventMulticaster();// Initialize other special beans in specific context subclasses.onRefresh();//注册监听器，从容器中获取所有的ApplicationListener； Check for listener beans and register them.registerListeners();// Instantiate all remaining (non-lazy-init) singletons.//【大核心】bean创建；完成 BeanFactory 初始化。（工厂里面所有的组件都好了）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();contextRefresh.end();}}}

	protected final void refreshBeanFactory() throws BeansException {if (hasBeanFactory()) {destroyBeans();closeBeanFactory();}try {DefaultListableBeanFactory beanFactory = createBeanFactory(); //创建保存所有Bean定义信息的档案馆beanFactory.setSerializationId(getId());customizeBeanFactory(beanFactory);loadBeanDefinitions(beanFactory);this.beanFactory = beanFactory;}catch (IOException ex) {throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);}}

	protected DefaultListableBeanFactory createBeanFactory() {return new DefaultListableBeanFactory(getInternalParentBeanFactory()); //创建档案馆}

因为是通过XML配置的，所以就使用XMLWebApplicationContext

	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {// Create a new XmlBeanDefinitionReader for the given BeanFactory.//XML读取器XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);// Configure the bean definition reader with this context's// resource loading environment.beanDefinitionReader.setEnvironment(getEnvironment());beanDefinitionReader.setResourceLoader(this);beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));// Allow a subclass to provide custom initialization of the reader,// then proceed with actually loading the bean definitions.initBeanDefinitionReader(beanDefinitionReader);loadBeanDefinitions(beanDefinitionReader);}

解析以及注册BeanDefinitions

	public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {Assert.notNull(encodedResource, "EncodedResource must not be null");if (logger.isTraceEnabled()) {logger.trace("Loading XML bean definitions from " + encodedResource);}Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();if (!currentResources.add(encodedResource)) {throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");}try (InputStream inputStream = encodedResource.getResource().getInputStream()) {InputSource inputSource = new InputSource(inputStream);if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());}return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); //这里是重点}catch (IOException ex) {throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), ex);}finally {currentResources.remove(encodedResource);if (currentResources.isEmpty()) {this.resourcesCurrentlyBeingLoaded.remove();}}}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)throws BeanDefinitionStoreException {try {Document doc = doLoadDocument(inputSource, resource); //利用dom解析工具把xml变成Documentint count = registerBeanDefinitions(doc, resource); //根据document信息注册bean信息if (logger.isDebugEnabled()) {logger.debug("Loaded " + count + " bean definitions from " + resource);}return count;}
}

这里主要就是验证XML文件 调用loadDocument根据xml文件获取Document实例，调用registerBeanDefinitions 注册Bean实例。具体的XML转换成Docuemnt流程这里不细说。

	protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,getValidationModeForResource(resource), isNamespaceAware());}

解析及注册BeanDefinitions

上面是进行加载xml文件转换成Document对象后，就调用了registerBeanDefinitions方法。

	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();int countBefore = getRegistry().getBeanDefinitionCount();documentReader.registerBeanDefinitions(doc, createReaderContext(resource));return getRegistry().getBeanDefinitionCount() - countBefore;}

BeanDefinitionDocumentReader是一个接口，具体实现其实是DefaultBeanDefinitionDocumentReader，createBeanDefinitionDocumentReader是利用工具实现 DefaultBeanDefinitionDocumentReader，而这里显然使用的是接口表达。也就是面向接口编程。

	protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {return BeanUtils.instantiateClass(this.documentReaderClass);}

	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {this.readerContext = readerContext;doRegisterBeanDefinitions(doc.getDocumentElement());}

解析逻辑的核心方法doRegisterBeanDefinitions

	protected void doRegisterBeanDefinitions(Element root) {// Any nested <beans> elements will cause recursion in this method. In// order to propagate and preserve <beans> default-* attributes correctly,// keep track of the current (parent) delegate, which may be null. Create// the new (child) delegate with a reference to the parent for fallback purposes,// then ultimately reset this.delegate back to its original (parent) reference.// this behavior emulates a stack of delegates without actually necessitating one.BeanDefinitionParserDelegate parent = this.delegate;this.delegate = createDelegate(getReaderContext(), root, parent);if (this.delegate.isDefaultNamespace(root)) {String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);if (StringUtils.hasText(profileSpec)) {String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);// We cannot use Profiles.of(...) since profile expressions are not supported// in XML config. See SPR-12458 for details.if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {if (logger.isDebugEnabled()) {logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +"] not matching: " + getReaderContext().getResource());}return;}}}preProcessXml(root);parseBeanDefinitions(root, this.delegate);postProcessXml(root);this.delegate = parent;}

最终解析动作落地在两个方法处：parseDefaultElement(ele, delegate) 和 delegate.parseCustomElement(root)。我们知道在 Spring 有两种 Bean 声明方式：

配置文件式声明：
自定义注解方式：tx:annotation-driven

	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {if (delegate.isDefaultNamespace(root)) {NodeList nl = root.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);if (node instanceof Element) {Element ele = (Element) node;if (delegate.isDefaultNamespace(ele)) { //遍历文档中的所有节点parseDefaultElement(ele, delegate);}else {delegate.parseCustomElement(ele);}}}}else {delegate.parseCustomElement(root);}}

至此，整个bean加载的过程就完毕了，但是后续其实还有对bean的初始化、实例化以及AOP、事务等流程。

小结

本篇其实主要就是从bean是如何加载xml文件生成 解析及注册BeanDefinitions过程。后续我们会接着介绍Bean的生命周期、初始化、AOP、MVC以及tomcat源码。