spring源码分析-spring是如何获取组件的

spring这个框架我已经用很久了，差不多两年吧，也写过一些分析源码的文章，当时主要是在b站看培训班课程时写的笔记。一方面是学习spring的基本用法，另一方面是巩固所学，毕竟手和脑一块动起来学的东西比较牢。而且，写点东西后续回顾起来也快。

但是，spring实在太复杂了，尤其是钻入源码层面非常容易迷失，在n个层次的调用栈跳来跳去，晕头转向。尽管如此，每次看还是有新的体会，有些当初看不懂的地方渐渐明白了。想着趁热打铁，把自己的理解记录下来，因此有了这篇文章。

本文内容是从源码角度对spring如何实例化组件的理解。

ApplicationContext和BeanFactory这两个组件在前期我是混淆不清的，觉得他们都差不多，毕竟他们之间互为继承关系。一般工作中使用的ApplicationContext接口实现类是AnnotationConfigApplicationContext，看看其继承图：

再观察下AnnotationConfigApplicationContext的类结构：

// org.springframework.context.annotation.AnnotationConfigApplicationContext
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

   private final AnnotatedBeanDefinitionReader reader;

   private final ClassPathBeanDefinitionScanner scanner;
 //.................省略................   
}

再看看其父类GenericApplicationContext的类结构：

// org.springframework.context.support.GenericApplicationContext
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
	// beanFactory的真面目，实现类为DefaultListableBeanFactory
   private final DefaultListableBeanFactory beanFactory;

   private ResourceLoader resourceLoader;

   private boolean customClassLoader = false;

   private final AtomicBoolean refreshed = new AtomicBoolean();
    //..................省略................
}

所以，我的理解是beanFactory其实是ApplicationContext的一个成员变量（至少在Annotation模式下的spring是如此）。而且，beanFactory是真正的bean工厂，获取bean的真实逻辑来自beanFactory，下面分析其原理。

首先说明下AnnotationConfigApplicationContext的beanFactory是DefaultListableBeanFactory这个是怎么实现的：

// org.springframework.context.support.GenericApplicationContext
// AnnotationConfigApplicationContext的父类是GenericApplicationContext，且一般使用无参构造函数进行实例化，所以不言而喻了吧
public GenericApplicationContext() {
   this.beanFactory = new DefaultListableBeanFactory();
}

获取bean的方式最常见的方式一般是applicationContext.getBean(xxxx.class)，那看看其逻辑：

// org.springframework.context.annotation.AnnotationConfigApplicationContext
@Override
public  T getBean(Class requiredType) throws BeansException {
   assertBeanFactoryActive();
    // 最终使用的是成员变量beanFactory获取bean
   return getBeanFactory().getBean(requiredType);
}

所以beanFactory才是真正管理bean的地方。

既然是管理bean的地方那必然有个地方存放bean单例，分析下DefaultListableBeanFactory的继承体系

看看其父类DefaultSingletonBeanRegistry类结构

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

   
   protected static final Object NULL_OBJECT = new Object();


   
   protected final Log logger = LogFactory.getLog(getClass());

   
    // 完全实例化的组件放在这
   private final Map singletonObjects = new ConcurrentHashMap(256);

   
    // 用于解决循环依赖的问题，组件A依赖组件B，组件B依赖组件A，那么还为完全实例的组件A将被丢入此
   private final Map> singletonFactories = new HashMap>(16);

   
    // 用于解决循环依赖的问题，配合singletonFactories使用，这里存放的组件是还未注入属性的对象
   private final Map earlySingletonObjects = new HashMap(16);

   
   private final Set registeredSingletons = new LinkedHashSet(256);

   
   private final Set singletonsCurrentlyInCreation =
         Collections.newSetFromMap(new ConcurrentHashMap(16));

   
   private final Set inCreationCheckExclusions =
         Collections.newSetFromMap(new ConcurrentHashMap(16));

   
   private Set suppressedExceptions;

   
   private boolean singletonsCurrentlyInDestruction = false;

   
   private final Map disposableBeans = new LinkedHashMap();

   
   private final Map> containedBeanMap = new ConcurrentHashMap>(16);

   
   private final Map> dependentBeanMap = new ConcurrentHashMap>(64);

   
   private final Map> dependenciesForBeanMap = new ConcurrentHashMap>(64);
 //.............省略.................   
}

看了上述类结构大致可以理解为什么beanFactory才是bean工厂了，其有四个很重要的容器对象singletonObjects、singletonFactories、earlySingletonObjects、singletonsCurrentlyInCreation，他们搭配使用可解决循环依赖问题，关于这点后面在介绍实例化的过程中进行穿插分析。

spring是个组件容器，获取组件的过程自然可以猜到：如果容器中有组件实例则直接返回，没有则创建，然后放入容器的某个map存着，最后返回该组件。具体的原理值得分析，下面展开：

经过上面的分析已经知道真正的bean工厂是DefaultListableBeanFactory，因此接下来从这个类切入。

DefaultListableBeanFactory重载了很多getBean方法，其实内部互相调来调去，我们直接关注用于实例化bean的方法：

// org.springframework.beans.factory.support.DefaultListableBeanFactory
protected  T doGetBean(
			final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
		// 处理bean名称，比如beanFacotry带&，比如alias这类的别名，
        //逻辑简单也不是很重要，就不展开了
		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
        // getSingleton这个方法经常出现，后面会展开分析
		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 + "'");
				}
			}
            // 获取bean实例，上述步骤不是获取bean实例了吗？为何还有此步骤？原因其实是考虑bean实例是beanFactory的情况，如果是beanFactory则需调用其getObject方法返回bean单例
			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.
            // 父容器的情况，一般很少用到，springmvc会用到？暂不了解
			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 {
                // 合并bean定义，从没碰到这种用法
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
                // 处理depondsOn的依赖问题，如果是这种方式的循环依赖，spring也无解...
				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()) {
                    // 这里也是个getSingleton，是另一个重载的方法，后续重点分析
					sharedInstance = getSingleton(beanName, new ObjectFactory