【Spring-5】AbstractBeanFactory#doGetBean创建实例完整流程

本文详细分析spring创建对象的完整流程。
入口：AbstractBeanFactory#doGetBean

从缓存中取实例

		// 名称转换，如果传入的是别名会转换为bean的真正名称；如果是针对FactoryBean的，会去掉&
		String beanName = transformedBeanName(name);
		Object beanInstance;

		// 从缓存中取实例
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
   
			if (logger.isTraceEnabled()) {
   
				if (isSingletonCurrentlyInCreation(beanName)) {
   
					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
   
					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			// 对FactoryBean类行的实例进行特殊处理
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

缓存逻辑

	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   
		// spring创建的缓存都是保存在singletonObjects这个map中的。
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
   
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
   
				synchronized (this.singletonObjects) {
   
					// Consistent creation of early reference within full singleton lock
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
   
						singletonObject = this.earlySingletonObjects.get(beanName);
						if (singletonObject == null) {
   
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
   
								singletonObject = singletonFactory.getObject();
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

双检查加锁，缓存中没有的话，从暴露的引用中找，能找到就返回早期的引用；找不到就返回null。这里设计循环引用的逻辑，单独分析。。。

注意：
这里为什么会有三个缓存呢？
第一个缓存singletonObjects，用来保存已经实例化好，并且初始化好的的对象的
第二个缓存earlySingletonObjects，是用来保存已经实例化好的对象，但是没有初始化，所以他叫早期的单例对象，为的是解决循环依赖
第三个缓存singletonFactories，是创建对象的接口，可以理解为懒创建，等需要的时候再创建。

对FactoryBean类型的实例特殊处理

AbstractBeanFactory#getObjectForBeanInstance

protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
   

		// name如果是&开头，说明要的是FactoryBean的实例
		if (BeanFactoryUtils.isFactoryDereference(name)) {
   
			// 如果是nullBean直接返回
			if (beanInstance instanceof NullBean) {
   
				return beanInstance;
			}
			// 如果实例不是FactoryBean类型的，抛异常
			if (!(beanInstance instanceof FactoryBean)) {
   
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
			// 如果是第一个创建，这个这个bd的属性是true
			if (mbd != null) {
   
				mbd.isFactoryBean = true;
			}
			// 返回实例，说明工厂中保存的是factoryBean的实例，如果用户要FactoryBean的实例，name一定是&开头，直接返回实例，如果不是&开头，就是下面的逻辑了。
			return beanInstance;
		}

		// 如果是普通的类型，直接返回实例。
		if (!(beanInstance instanceof FactoryBean)) {
   
			return beanInstance;
		}
		// 下面的逻辑是获得factoryBean中的普通类型的实例
		Object object = null;
		// 如果第一次创建，bd属性设置为true
		if (mbd != null) {