Spring源码分析

为什么要看Spring源码

• 解决使用框架时遇到的问题
• 深入理解底层原理，帮助更好的使用框架
• 深入理解面向对象思想和深入理解设计模式
• 高级程序员的常见面试点

如何看源码

• 确定主线，即想看那个流程的源码
• 找到流程入口
• 参考相关文档
• 寻找源代码规律

Spring中的IoC容器

在Spring中，有两种主要的容器类型，一种是BeanFactory，一种是ApplicationContext。其中BeanFactory是底层的容器实现，提供了IoC容器的基础功能，而ApplicationContext是一种应用级的容器，除了基础功能外还提供了更加丰富的功能，例如：

• 支持不同的信息源
• 支持事件发布
• 在ApplicationContext中提供附加服务

BeanFactory

BeanFactory是Spring中对IoC容器的核心抽象，在BeanFactory中定义了IoC容器的核心方法

Object getBean(String name) throws BeansException;
 T getBean(String name, Class requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
 T getBean(Class requiredType) throws BeansException;
 T getBean(Class requiredType, Object... args) throws BeansException;
boolean containsBean(String name);
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class typeToMatch) throws NoSuchBeanDefinitionException;
Class getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);

从接口中的方法签名可以很清楚的看到，BeanFactory提供了作为容器的基本功能。

基于BeanFactory，Spring提供了一系列的子接口即实现类来丰富BeanFactory，使其成为一个强大的IoC容器。BeanFactory的主体结构如下图所示：

Spring源码乍看给人一种很复杂的感觉，但如果把主体结构抽取出来，就可以很清楚的看到它的轮廓。

从图中可以看出，接口层主要包含了四个层次，从上到下依次是一个不断丰富功能的过程。

首先是BeanFactory，这是Spring IoC容器的顶级接口，上面已经介绍过。

往下走，分别是三个平级的接口，分别是ListableBeanFactory/AutowireCapableBeanFactory/HierachialBeanFactory，这三个接口都对BeanFactory进行了扩展。从名称可以比较明显的看出这几个接口扩展的方面。

ListableBeanFactory

boolean containsBeanDefinition(String beanName);
int getBeanDefinitionCount();
String[] getBeanDefinitionNames();
String[] getBeanNamesForType(ResolvableType type);
String[] getBeanNamesForType(Class type);
String[] getBeanNamesForType(Class type, boolean includeNonSingletons, boolean allowEagerInit);
 Map getBeansOfType(Class type) throws BeansException;
 Map getBeansOfType(Class type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException;
String[] getBeanNamesForAnnotation(Class annotationType);
Map getBeansWithAnnotation(Class annotationType) throws BeansException;
 A findAnnotationOnBean(String beanName, Class annotationType)
			throws NoSuchBeanDefinitionException;

从接口签名中可以看出，ListablebeanFactory提供了Bean枚举相关的功能，如获取所有bean的名称及bean的总数量，获取bean名称和bean的映射等。

第二个接口是AutowireCapableBeanFactory，这个接口在BeanFactory的基础上扩展了自动装配的功能，例如创建Bean/自动配置bean/解析依赖以及与bean生命周期相关的功能。

代码略。

第三个接口是HieracicalBeanFactory，这个接口同样扩展子BeanFactory，它提供了在容器存在父子关系场景下与容器继承相关的操作。例如WebApplicationContext及ApplicationContext。

代码略。

至此，第二层继承接口就完事了。下面就是ConfigurablebeanFactory这个接口，这个接口继承自HieracicalBeanFactory，同时又扩展了SingletonBeanFactory，也就是与单例模式的Bean注册相关的功能，之所以这么做，个人理解单例模式是bean最常见的形式，将其注册能力加到稍顶级的接口中，有利于规范下层实现的行为。

代码略。

ConfigurableListableBeanFactory是第三层接口，这个接口同时继承了ListableBeanFactory,AutowrieCapablebeanFactory和ConfigurableBeanFactory这三个接口，可以把它理解为spring中常用容器的顶级接口，它定义了一个功能完善的IoC容器的几乎所有行为。

代码略。

至此，BeanFactory体系的主体框架就看完了。

BeanDefinition

BeanDefinition是spring中对bean及bean依赖关系的抽象，如果把spring比做一个制造并管理bean的工厂的话，那BeanDefinition就是创造bean的原材料。

在spring启动过程中，spring会解析配置文件或配置类，将对应的bean定义解析成BeanDefinition并注册到spring容器中，在后续，spring会根据这些具体的BeanDefinition对象来创建并初始化这些bean。

BeanDefinition的继承结构如下：

Spring容器的初始化流程

由于我们在日常开发中经常使用的IoC容器是ApplicationContext，而不是更加底层的BeanFactory，所以在分析Spring容器初始化时，就以ApplicationContext为例，下面是ApplicationContext的体系结构

IoC容器的使用

由于在日常开发中，最常见的是ClassPathXmlApplicationContext，所以就以此为例来分析。首先看一下在日常开发中基本的使用方式。

	contextConfigLocation
	classpath:spring.xml


	
        org.springframework.web.context.ContextLoaderListener
    


ApplicationContext ctx = new ClasspPthXmlApplicationContext("spring.xml");

容器初始化入口

ClassPathXmlApplicationContext.java

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
			throws BeansException {

		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
			refresh();
		}
	}

AbstractApplicationContext.java

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//Step1: 刷新预处理
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//Step2：创建IoC容器，解析xml，注册BeanDefinition
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			//Step3:对IoC容器进行预处理
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//Step4:
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//Step5:调用BeanFactoryPostProcessor后置处理器对BeanDefinition进行处理
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				
				//Step6:注册BeanPostProcessor
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				//Step7:初始化消息源（国际化）
				initMessageSource();

				// Initialize event multicaster for this context.
				//Step8:初始化应用事件广播
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				//Step9:初始化一些特殊的bean
				onRefresh();

				// Check for listener beans and register them.
				//Step10:注册监听器
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//Step11:实例话单例Bean，Bean的依赖注入和AOP都发生在这一步
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				//Step12:完成，发布事件
				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();
			}
		}
	}

在分析源码前，要先明确一下spring容器初始化的核心流程：

1. 创建容器
2. 加载配置资源文件
3. 解析并注册BeanDefinition
4. 完成bean的创建与初始化

这四个步骤对应到上面的refresh方法中，其中前三步是在step2中完成，第四步主要是在step11中完成。

解析&注册BeanDefinition

1.AbstractApplicationContext.java
/**
    a）创建IoC容器
    b）加载xml文件
    c）解析并生成BeanDefinition，并注册到容器中
*/
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

2.AbstractApplicationContext.java
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        /**
            a）销毁存在的容器
            b）创建BeanFactory
            c）加载资源文件，并向容器中注册BeanDefinition
        */
		refreshBeanFactory();
		/**
		    返回上一步创建的BeanFactory
		*/
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

3.AbstractRefreshableApplicationContext.java
protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
		    /**
		      创建BeanFactory，这一步直接通过new创建来一个DefaultListableBeanFactory
		      
		      new DefaultListableBeanFactory(getInternalParentBeanFactory());
		    */
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			/**
			  加载BeanDefinition
			*/
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}


4.AbstractXmlApplicationContext.java
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
		
		/**
		   初始化BeanDefinitionReader来完成文件都读取和
		   加载BeanDefinition。
		*/
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
		
		initBeanDefinitionReader(beanDefinitionReader);
		
		/**
		   加载BeanDefinition，由子类完成。
		   
		   protected Resource[] getConfigResources() {
		return null;
	}
		*/
		loadBeanDefinitions(beanDefinitionReader);
	}
	
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        /**
            由子类完成：ClassPathXmlApplicationContext
            protected Resource[] getConfigResources() ;
        */
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			reader.loadBeanDefinitions(configLocations);
		}
	}

	
5.ClassPathXmlApplicationContext.java
//初始化Resource是在创建具体的ClassPathXmlApplicationContext时进行的。
public ClassPathXmlApplicationContext(String[] paths, Class clazz, ApplicationContext parent)
			throws BeansException {

		super(parent);
		Assert.notNull(paths, "Path array must not be null");
		Assert.notNull(clazz, "Class argument must not be null");
		this.configResources = new Resource[paths.length];
		for (int i = 0; i < paths.length; i++) {
			this.configResources[i] = new ClassPathResource(paths[i], clazz);
		}
		refresh();
	}
@Override
protected Resource[] getConfigResources() {
	return this.configResources;
}

6.AbstractBeanDefinitionReader.java
public int loadBeanDefinitions(String location, Set actualResources) throws BeanDefinitionStoreException {
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}

		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				/**
				 此处时核心调用逻辑，最终会进入到具体实现类
				 XmlBeanDefinitionReader中进行处理
				*/
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
			}
			return loadCount;
		}
	}
	
7.XmlBeanDefinitionReader.java 
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	
		try {
		    
		    /**
		      此处调用的getResource是由具体的ApplicationContext
		      提供的。
		    */
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				/**
				  最终执行加载xml/解析BeanDefinition并进行注册的
				  核心方法。
				*/
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
	}

8.XmlBeanDefinitionReader.java
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource){
    /**
      BeanDefinitionReader这个组件的主要作用就是将xml解析成
      Document对象，然后它就会将任务转交给BeanDefinitionDocumentReader
    */
    Document doc = doLoadDocument(inputSource, resource);
	return registerBeanDefinitions(doc, resource);
}

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


9.上接getResource
getResoruce()方法的作用是加载配置信息对应的Resource流对象，这个方法被定义在ResourceLoader接口中
public interface ResourceLoader {
    String CLASSPATH_URL_PREFIX = "classpath:";
    Resource getResource(String var1);
    ClassLoader getClassLoader();
}

而ApplicationContext的顶级父类AbstractApplicationContext继承了DefaultResourceLoader()，子类ApplicationContext可以同覆盖getResource()来实现自己的加载配置信息的方式。



10.XmlBeanDocumentReader.java
BeanDefinitionReader会将解析&注册任务交给BeanDefinitionDocumentReader来完成

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        // 创建DocumentReader
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		// 将任务转交给DocumentReader
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
}

11.DefaultBeanDefinitionDocumentReader.java
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);
		}
	}
这里涉及到一个重要的操作，就是确定NamespaceHandler，在parseCustomElement方法中主要来处理
import/bean/beans等spring的核心标签，在parseCustomElement方法中主要来处理aop/context/mvc
等其他名称空间中的标签。

在处理其他名称空间的标签时，需要首先找到对应的NamespaceHandler，这个过程是通过加载classpath
下的spring.handler文件完成的，在spring.hander文件中定义了每一种名称空间对应的NameSpaceHandler


12.BeanDefinitionParserDelegate.java
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
		String namespaceUri = getNamespaceURI(ele);
		/**
		 这一步就是从spring.handler中寻找对应的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));
	}

BeanDefinitionReader继承结构

BeanDefinitionReader的主要作用是读取外部资源文件，解析成BeanDefintion

BeanDefinitionReader
  AbstractBeanDefinitionReader
    GroovyBeanDefinitionReader
    XmlBeanDefinitionReader
    PropertiesBeanDefinitionReader

总结一下

• spring容器的启动入口是refresh()方法，在refresh()方法中定义了spring IoC容器初始化的骨架，为Bean的生命周期管理提供了条件；
• 默认的IoC Bean工厂是DefaultListableBeanFactory；
• BeanDefinition是spring中对Bean对象及其依赖关系的抽象；
• ApplicationContext通过实现ResourceLoader接口实现加载Bean定义信息的具体方式；
• BeanDefinitionReader负责从Resource中解析BeanDefinition，并将BeanDefintion注册到IoC 容器中；
• BeanDefinitionReader注册BeanDefinition是通过BeanFactory实现的BeanDefinitionRegistry接口提供的相关能力实现的；
• ApplicationContext是一个持有BeanFactory的/功能被强化了的IoC容器
• 最终被解析出来的BeanDefinition被注册到了BeanFactory的HashMap中；
• BeanDefinitionReader的主要任务是将xml解析成Document，然后它就会将具体的解析和注册BeanDefinition的任务交给BeanDefinitionDocumentReader；
• 对于不同的名称空间中的标签，是通过在spring.handler中定义其对应关系来指定对应的NamespaceHandler的；

Bean的实例化&依赖注入

bean实力化

在IoC容器顶级接口BeanFactory中声明了getBean()的一些列重载方法，Bean的实例化和依赖注入都是从这里开始是（lazy-init=false除外），下面我们从AbstractBeanFactory中都getBean开始入手，来看一下Spring bean的实例化过程。

@Override                                                                     
public Object getBean(String name) throws BeansException {                    
	return doGetBean(name, null, null, false);                                
}                                                                             
//这里定义了bean初始化和依赖入住的最顶层逻辑
protected  T doGetBean(
			final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {

		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		
		//尝试从缓存中获取单例bean，这里包含了解决循环依赖的核心逻辑，后面再单独进行分析
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			
			//此处，处理FactoryBean
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			
			//此处处理具有继承关系的容器体系，利用递归顺着BeanFactory继承链向上找
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						registerDependentBean(dep, beanName);
						getBean(dep);
					}
				}

				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory