一文带你解读Spring5源码解析 IOC之开启Bean的加载，以及FactoryBean和BeanFactory的区别。

前言

通过往期的文章我们已经了解了Spring对XML配置文件的解析，将分析的信息组装成BeanDefinition，并将其保存到相应的BeanDefinitionRegistry中，至此Spring IOC的初始化工作已经完成，这篇文章主要对Bean的加载进行一个深入的了解及探索。

想要了解Bean就必要要知道接口BeanFactory，接下来我们就从BeanFactory切入

BeanFactory

我们在调用getBean()方法时，无论是显示调用还是隐式调用。都会触发Bean加载的阶段。demo如下：

@Test

public void Test(){

	//使用BeanFactory方式加载XML.

	BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

	MyTestBean myTestBean = (MyTestBean) beanFactory.getBean("myTestBean");

	System.out.println(myTestBean.getName());

}

实际上这个getBean方法是在接口BeanFactory中定义的。我们先看一下BeanFactory的类图：

根据如上类图最一个简单的整理：

BeanFactory作为一个主接口不继承实现任何接口，我们可以定义为一级接口。
有3个子接口都继承了它，进行功能上的增强，这3个子接口我们可以定义为二级接口。
ConfiguratbleBeanFactory我们可以定义为三级接口，对二级接口HierarchicalBeanFactory，进行再次增强。它还继承了另外一个接口SingletomBeanRegistry
ConfigurableListableBeanFactory是一个更强大的接口，继承了上述的所有接口，无所不包，我们可以定义为四级接口，(这4级接口是BeanFactory的基本接口体系，继续，下面是继承关系的2个抽象类和2个实现类)
AbstractBeanFactory作为一个抽象类，实现了三级接口ConfigurableBe·anFactory
AbstractAutowireCapableBeanFactory同样是抽象类继承自AbstractBeanFactory，并额外实现了二级接口AutowireCapableBeanFactory
DefaultListableBeanFactory继承自AbstractAutowireCapableBeanFactory实现了强大的四级接口ConfigurableListableBeanFactory，并实现了一个外来接口BeanDefinitionRegistry，它并非抽象类。
最后就是强大的XmlBeanFactory继承自DefaultListableBeanFactory，重写了一些功能，是自己更强大。

BeanFactory，以Factory结尾，表示它是一个工厂类(接口)，它负责生产和管理Bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。BeanFactory只是一个接口，并不是IOC的具体实现，但Spring容器给出了很多种实现，如：DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，其中XmlBeanFactory就是常用的一个，该实现将以XML方式描述组件应用的对象及对象之间的依赖关系。XmlBeanFactory类将持有此Xml配置元数据，并用它来构建一个完全可配置的系统或应用。

BeanFactory是Spring IOC容器的鼻祖，是IOC容器的基础接口，所有的容器都是从它这里继承实现而来的。可以见其地位是多么重要。BeanFactory提供了最基本的IOC容器的功能，即所有的容器至少需要实现的标准。

XmlBeanFactory，只是提供了最基本的IOC容器的功能。而且XmlBeanFactory继承自DefaultListableBeanFactory。DefaultListableBeanFactory实际包含了基本IOC容器所具有的所有重要功能，是一个完整的IOC容器

ApplicationContext包含了BeanFactory的所有功能，通常建议比BeanFactory优先。

BeanFactory体系结构是典型的工厂方法模式，即什么样的工厂生产什么样的产品。BeanFactory是最基本的抽象工厂，而其它的IOC容器只不过是具体的工厂，对应着各自的Bean定义方法。但同时，其它容器也针对具体场景不同，进行了扩充，提供了具体的服务，如下：

// 1

Resource resource = new FileSystemResource("beans.xml");

BeanFactory factory = new XmlBeanFactory(resource);

// 2

ClassPathResource resource = new ClassPathResource("beans.xml");

BeanFactory factory = new XmlBeanFactory(resource);

// 3

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml"});

BeanFactory factory = (BeanFactory) context;

大概就是这些了，接着使用getBean(String beanName)方法取得bean的实例；BeanFactory提供的方法极其简单，仅仅提供了六种方法供客户调用：

boolean containsBean(String name);判断工厂中是否包含了给定名称的Bean定义，若有则返回true
Object getBean(String name);返回给定名称注册的bean实例。根据Bean的配置情况，如果是singleton模式将返回一个共享的实例，否则将返回一个新建的实例，如果没有找到指定Bean，该方法会抛出异常(BeansException)。
< T> T getBean(String name, Class requiredType) ;返回给定名称注册的Bean实例，并转换为给定class类型。
boolean isSingleton(String name); 判断给定名称的Bean定义是否是单例模式。
Class<?> getType(String name); 返回给定名称的Bean的Class，如果没有找到指定的Bean实例，则抛出NoSuchBeanDefinitionException异常。
String[] getAliases(String name); 返回给定名称Bean的所有别名。

我们大致看一下BeanFactory源码里的所有方法。

public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&";

	Object getBean(String name) throws BeansException;

	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	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;

	@Nullable

	Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	@Nullable

	Class<?> getType(String name, Boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

	String[] getAliases(String name);

}

FactoryBean

概述：一一般情况下，Spring通过反射机制利用< bean>的class属性指定实现类实例化Bean，在某些情况下，实例化Bean的过程比较复杂，如果按照传统的方式，则需要在< bean>中提供大量的配置信息；配置方式的灵活性是受限的，这是采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.beans.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占有重要的地位，Spring自身就提供了70多个Factory Bean的实现，它们隐藏实例化一些复杂Bean的细节，给上层应用带来了便利，从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改为FactoryBean< T>的形式。

以Bean结尾，表示它是一个Bean，不同于普通Bean的是：它实现了FactoryBean< T> 接口的Bean，根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果想要获取FactoryBean对象，请在id前面加一个&符号来获取。

看源码(FactoryBean.java)

public interface FactoryBean<T> {

	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

	@Nullable

	T getObject() throws Exception;

	@Nullable

	Class<?> getObjectType();

	default Boolean isSingleton() {

		return true;

	}

}

从上述源码中我们可以看到，该接口一共定义了3个方法：

T getObject() throws Exception; 返回由FactoryBean创建的Bean实例，如果isSingleton()返回true，则该实例会放到Spring容器中单例实例缓存池中；
Class<?> getObjectType(); 返回FactoryBean创建的Bean实例；
default boolean isSingleton() { return true;} 返回FactoryBean创建的Bean实例的作用域是singleton还是prototype；

补充：当配置文件中< bean>的class属性配置的实现类是FactoryBean时，通过getBean()方法返回的不是FactoryBean本身，而是FactoryBean中的getObject()方法所返回的对象，相当于FactoryBean的getObject()代理了getBean()方法。

例如：如果使用传统方式配置下面的Car的< bean>时，Car的每个属性分别对应一个< property>元素标签。

public class Car {

	private int maxSpeed ;

	private String brand ;

	private double price ;

	//get//set 方法

}

如果使用FactoryBean的方式实现的话就比较灵活，下例通过逗号的分割的方式一次性为Car的所有属性指定配置值。

import  org.springframework.beans.factory.FactoryBean;

public  class CarFactoryBean implements  FactoryBean<Car> {

	private String carInfo ;

	public  Car getObject()  throws  Exception  {

		Car car = new  Car();

		String[] infos = carInfo.split(",");

		car.setBrand(infos[0]);

		car.setMaxSpeed(Integer.valueOf(infos[1]));

		car.setPrice(double.valueOf(infos[2]));

		return  car;

	}

	public  Class<Car> getObjectType(){

		return Car.class ;

	}

	public Boolean isSingleton(){

		return false ;

	}

	public String getCarInfo(){

		return  this.carInfo;

	}

	//接受逗号分割符设置属性信息

	public void setCarInfo (String carInfo){

		this.carInfo = carInfo;

	}

}

根据上述的CarFactoryBean，在配置文件中使用如下的方式进行配置

<bean d="car"class="com.vipbbo.spring.CarFactoryBean" P:carInfo="大奔,600,1000000"/>

当调用getBean("car")时，Spring通过反射机制发现CarFactoryBean实现了FactoryBean的接口，这时Spring容器就调用接口方法CarFactoryBean的getObject()方法返回。如果希望获取CarFactoryBean的实例，则需要在使用getBean(BeanName)方法时在BeanName前面加上"&"前缀：比如：getBean("&car");

获取Bean

接下来我们继续回到文章一开始讲的bean的加载阶段，当我们显式或隐式调用getBean()时，则会触发加载Bean的阶段，具体实现如下：

看源码(AbstractBeanFactory.java)

@Override

public Object getBean(String name) throws BeansException {

	return doGetBean(name, null, null, false);

}

getBean()方法内部又调用了dogetBean()方法：

看源码(AbstractBeanFactory.java)

protected <T> T doGetBean(

			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, Boolean typeCheckOnly)

			throws BeansException {

	// 获取 beanName，这里是一个转换动作，将 name 转换为 beanName

	String beanName = transformedBeanName(name);

	Object beanInstance;

	/*

			检查缓存中的实例工程是否存在对应的bean实例。

			为何要优先使用这段代码呢？

				因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，Spring创建Bean的原则是在不等Bean创建完就会将

				创建Bean的 objectFactory 提前曝光，即将其加入到缓存中，一旦下一个 Bean 创建时依赖上一个Bean则直接使用 objectFactory，直接

			从缓存中或 singletonFactories 获取 objectFactory

				就算没有循环依赖，只是单纯的依赖注入，如：B依赖A，如果A已经初始化完成，B进行初始化时，需要递归调用getBean()获取去A，这时A已经在

				缓存里了，可以直接在这里获取到。

		 */

	// Eagerly check singleton cache for manually registered singletons.

	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，如果此 Bean 是 FactoryBean 的实现类，如果name前缀为 "&"，则直接返回此实现类的Bean，如果

			  没有前缀，则需要调用此实现类的getObject方法，返回getObject里真实的返回对象。

			 */

		beanInstance = 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.

		// 尝试从 parentBeanFactory 中查找 bean

		BeanFactory parentBeanFactory = getParentBeanFactory();

		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {

			// Not found -> check parent.

			String nameToLookup = originalBeanName(name);

			if (parentBeanFactory instanceof AbstractBeanFactory) {

				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(

											nameToLookup, requiredType, args, typeCheckOnly);

			} else if (args != null) {

				// Delegation to parent with explicit args.

				return (T) parentBeanFactory.getBean(nameToLookup, args);

			} else if (requiredType != null) {

				// No args -> delegate to standard getBean method.

				return parentBeanFactory.getBean(nameToLookup, requiredType);

			} else {

				return (T) parentBeanFactory.getBean(nameToLookup);

			}

		}

		// 如果不是仅仅做类型检查，则这里需要创建bean，并做记录

		if (!typeCheckOnly) {

			markBeanAsCreated(beanName);

		}

		StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")

							.tag("beanName", name);

		try {

			if (requiredType != null) {

				beanCreation.tag("beanType", requiredType::toString);

			}

			// 将存储XML配置文件的GenericBeanDefinition转换成RootBeanDefinition，同时如果存在父Bean合并父Bean的相关属性

			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

			checkMergedBeanDefinition(mbd, beanName, args);

			// Guarantee initialization of beans that the current bean depends on.

			// 如果存在依赖，则需要递归实例化依赖的Bean

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

					try {

						getBean(dep);

					}

					catch (NoSuchBeanDefinitionException ex) {

						throw new BeanCreationException(mbd.getResourceDescription(), beanName,

															"'" + beanName + "' depends on missing bean '" + dep + "'", ex);

					}

				}

			}

			// Create bean instance.

			// 单例模式的Bean

			if (mbd.isSingleton()) {

				// 实例化依赖的Bean后对Bean本身进行实例化

				sharedInstance = getSingleton(beanName, () -> {

					try {

						return createBean(beanName, mbd, args);

					}

					catch (BeansException ex) {

						// Explicitly remove instance from singleton cache: It might have been put there

						// eagerly by the creation process, to allow for circular reference resolution.

						// Also remove any beans that received a temporary reference to the bean.

						destroySingleton(beanName);

						throw ex;

					}

				}

				);

				beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

			}

			// 原型模式 else if (mbd.isPrototype()) {

				// It's a prototype -> create a new instance.

				Object prototypeInstance = null;

				try {

					beforePrototypeCreation(beanName);

					prototypeInstance = createBean(beanName, mbd, args);

				}

				finally {

					afterPrototypeCreation(beanName);

				}

				beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

			}

			// 从指定的 scope 模式下创建 Bean else {

				String scopeName = mbd.getScope();

				if (!StringUtils.hasLength(scopeName)) {

					throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");

				}

				Scope scope = this.scopes.get(scopeName);

				if (scope == null) {

					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");

				}

				try {

					Object scopedInstance = scope.get(beanName, () -> {

						beforePrototypeCreation(beanName);

						try {

							return createBean(beanName, mbd, args);

						}

						finally {

							afterPrototypeCreation(beanName);

						}

					}

					);

					beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

				}

				catch (IllegalStateException ex) {

					throw new ScopeNotActiveException(beanName, scopeName, ex);

				}

			}

		}

		catch (BeansException ex) {

			beanCreation.tag("exception", ex.getClass().toString());

			beanCreation.tag("message", String.valueOf(ex.getMessage()));

			cleanupAfterBeanCreationFailure(beanName);

			throw ex;

		}

		finally {

			beanCreation.end();

		}

	}

	return adaptBeanInstance(name, beanInstance, requiredType);

}

@SuppressWarnings("unchecked")

<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {

	// Check if required type matches the type of the actual bean instance.

	if (requiredType != null && !requiredType.isInstance(bean)) {

		try {

			Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);

			if (convertedBean == null) {

				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

			}

			return (T) convertedBean;

		}

		catch (TypeMismatchException ex) {

			if (logger.isTraceEnabled()) {

				logger.trace("Failed to convert bean '" + name + "' to required type '" +

											ClassUtils.getQualifiedName(requiredType) + "'", ex);

			}

			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

		}

	}

	return (T) bean;

}

dogetBean()方法的源码时相当的长，一共包含了两部分，也可以说是一部分，接下来：进行拆分讲解：

1. 获取BeanName

看源码(AbstractBeanFactory.java)

// 获取 beanName，这里是一个转换动作，将 name 转换为 beanName

String beanName = transformedBeanName(name);

protected String transformedBeanName(String name) {

	return canonicalName(BeanFactoryUtils.transformedBeanName(name));

}

源码分析

这里要注意传递的name，不一定就是beanName，也有可能是aliasName 别名，也有可能是FactoryBean(带有”&“前缀)，因此这里需要调用transformeBeanName()进行一下转换，主要内容如下：

看源码(BeanFactoryUtils.java)

public static String transformedBeanName(String name) {

	// 这个方法主要是去掉FactoryBean的修饰符 &

	Assert.notNull(name, "'name' must not be null");

	if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {

		return name;

	}

	return transformedBeanNameCache.computeIfAbsent(name, beanName -> {

		do {

			beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());

		}

		while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));

		return beanName;

	}

	);

}

对aliasName别名的转换

public String canonicalName(String name) {

	// 这个方法是转换aliasName

	String canonicalName = name;

	// Handle aliasing...

	String resolvedName;

	do {

		resolvedName = this.aliasMap.get(canonicalName);

		if (resolvedName != null) {

			canonicalName = resolvedName;

		}

	}

	while (resolvedName != null);

	return canonicalName;

}

源码分析

上述的处理过程大致可以分为两步：

去除FactoryBean的修饰符，如果name以"&"为前缀，那么会去掉"&"，例如：name="&testService"，去除之后的结果是name=”testService“
取出指定的alias所表示的最终的beanName，主要是一个循环beanName的过程，例如别名A指向名称为B的bean则返回B，若别名A指向别名B，别名B指向名称为C的bean，则返回C。

缓存中获取单例Bean

单例在Spring的同一个容器中只会被创建一次，后续再获取Bean直接从单例缓存中获取即可，当然这里也只是尝试加载，首先尝试先从缓存中加载，然后再次从singletonFactory加载；因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，Spring创建bean的原则是不等bean创建完成就会创建bean的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时需要依赖上个bean，则直接使用ObejectFactory；就算没有循环依赖，只是单纯的依赖注入，如：B依赖A，如果A已经初始化完成，B进行初始化时，需要递归调用getBean()获取A，这时A已经在缓存里面了，直接可以从缓存里面获取到，接下来我们看获取单例bean的方法：

Object sharedInstance = getSingleton(beanName);

看源码(DefaultSingletonBeanRegistry.java)

@Override

@Nullable

public Object getSingleton(String beanName) {

	// 参数true，代表允许早期依赖

	return getSingleton(beanName, true);

}

@Nullable

protected Object getSingleton(String beanName, Boolean allowEarlyReference) {

	// Quick check for existing instance without full singleton lock

	// 检查缓存中是否存在实例，这里就是说上面的单纯的依赖注入，假设B依赖A，如果A已经初始化完成，B进行初始化时，需要递归调用getBean获取A，这时

	// A已经在缓存里面了，直接可以从缓存中获取到。

	Object singletonObject = this.singletonObjects.get(beanName);

	// 如果缓存为空，且单例Bean正在创建中，则锁定全局变量，

	// 为什么要判断单例Bean是否在创建中呢？

	// 		这里就是可以判断是否是循环依赖了。

	//		A依赖B，B也依赖A，A实例化的时候发现依赖B，则递归去实例化B；B又发现依赖A，则递归实例化A。这个时候就会回到原点A的实例化，第一次A的

	//		实例化还没有完成，只不过是把实例化的对象加入到缓存中了，但是状态还是正在创建中。由此回到原点A发现A正在创建中，便可以根据此来判断这

	//		是循环依赖了

	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

		// 尝试从 earlySingletonObjects 里面获取 如果此Bean正在加载，则不对其进行处理

		singletonObject = this.earlySingletonObjects.get(beanName);

		if (singletonObject == null && allowEarlyReference) {

			synchronized (this.singletonObjects) {

				// Consistent creation of early reference within full singleton lock

				// 尝试从singletonObjects里面获取实例

				singletonObject = this.singletonObjects.get(beanName);

				if (singletonObject == null) {

					// 当某些方法需要提前初始化的时候会直接调用 addSingletonFactory 把对应的 ObjectFactory 初始化策略 存储在

					// singletonFactories中。

					singletonObject = this.earlySingletonObjects.get(beanName);

					if (singletonObject == null) {

						ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);

						if (singletonFactory != null) {

							// 使用预先设定的getObject方法

							singletonObject = singletonFactory.getObject();

							this.earlySingletonObjects.put(beanName, singletonObject);

							this.singletonFactories.remove(beanName);

						}

					}

				}

			}

		}

	}

	return singletonObject;

}

源码分析

我们对上述方法进行一个简单的梳理，

首先该方法先从singletonObjects里获取实例；

如果获取不到会从earlySingletonObjects里面获取实例；

如果还是获取不到，再次尝试从singletonFactories里面获取beanName对应的ObjectFactory，并从singletonFactories里面remove掉这个ObjectFactory，而对于后续所有的内存操作都只为了循环依赖检测时候使用，即allowEarlyReference为true时才会使用。

以上代码涉及到了很多个存储bean的不同Map：

singletonObjects：用于保存BeanName和创建Bean实例之间的关系，beanName->bean Instance

singletonFactories：用于保存BeanName和创建Bean的工厂之间的联系，beanName->ObjectFactory

earlySingletonObjects：同样也是用于保存BeanName和创建Bean实例之间的关系，与singletonObjects的不同之处在于：当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getBean方法获取到了，其目的是用来检测循环依赖的引用。

registeredSingletons：用来保存当前所有已经注册的bean。

从bean的实例中获取对象

获取到bean以后就要获取实例对象了，这里用到的时getObjectForBeanInstance方法。getObjectForBeanInstance是一个频繁使用的方法，无论是从缓存中获取bean还是根据不同的scope策略加载Bean；总之，我们得到bean的实例后，要做的第一步就是调用这个方法来检测一下正确性，其实就是检测获得的Bean是不是FactoryBean类型的bean，

如果是那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值。

看源码(AbstractBeanFactory.java)

protected Object getObjectForBeanInstance(

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

	// Don't let calling code try to dereference the factory if the bean isn't a factory.

	// 如果指定的name 是工厂相关的

	if (BeanFactoryUtils.isFactoryDereference(name)) {

		// 如果是 NullBean 则直接返回此Bean

		if (beanInstance instanceof NullBean) {

			return beanInstance;

		}

		// 如果不是FactoryBean 类型，则直接抛出异常

		if (!(beanInstance instanceof FactoryBean)) {

			throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());

		}

		if (mbd != null) {

			mbd.isFactoryBean = true;

		}

		return beanInstance;

	}

	// Now we have the bean instance, which may be a normal bean or a FactoryBean.

	// If it's a FactoryBean, we use it to create a bean instance, unless the

	// caller actually wants a reference to the factory.

	// 如果获取的beanInstance不是FactoryBean类型，说明是普通的Bean，可直接返回

	// 如果获取的beanInstance是FactoryBean 类型，但是是以&开头，也可直接返回，此时返回的是FactoryBean实例

	if (!(beanInstance instanceof FactoryBean)) {

		return beanInstance;

	}

	Object object = null;

	if (mbd != null) {

		mbd.isFactoryBean = true;

	} else {

		object = getCachedObjectForFactoryBean(beanName);

	}

	if (object == null) {

		// Return bean instance from factory.

		FactoryBean<?> factory = (FactoryBean<?>) beanInstance;

		// Caches object obtained from FactoryBean if it is a singleton.

		if (mbd == null && containsBeanDefinition(beanName)) {

			mbd = getMergedLocalBeanDefinition(beanName);

		}

		Boolean synthetic = (mbd != null && mbd.isSynthetic());

		// 到这里说明了获取的beanInstance是FactoryBean类型的，但是没有以&开头，此时就要返回factory内部的getObject里面的对象了。

		// getObjectFromFactoryBean 核心方法

		object = getObjectFromFactoryBean(factory, beanName, !synthetic);

	}

	return object;

}

接下来我们继续看一下里面的核心方法getObjectFromFactoryBean()

看源码(FactoryBeanRegistrySupport.java)

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, Boolean shouldPostProcess) {

	// 满足是单例并且缓存中存在的

	if (factory.isSingleton() && containsSingleton(beanName)) {

		synchronized (getSingletonMutex()) {

			// 从缓存中获取FactoryBean根据BeanName

			Object object = this.factoryBeanObjectCache.get(beanName);

			if (object == null) {

				// 为空，则从FactoryBean中获取对象

				object = doGetObjectFromFactoryBean(factory, beanName);

				// Only post-process and store if not put there already during getObject() call above

				// (e.g. because of circular reference processing triggered by custom getBean calls)

				// 从缓存中获取

				Object alreadyThere = this.factoryBeanObjectCache.get(beanName);

				if (alreadyThere != null) {

					object = alreadyThere;

				} else {

					// 需要后续处理

					if (shouldPostProcess) {

						// 若该 bean 处于创建中，则返回非处理对象，而不是存储它

						if (isSingletonCurrentlyInCreation(beanName)) {

							// Temporarily return non-post-processed object, not storing it yet..

							return object;

						}

						// 前置处理

						beforeSingletonCreation(beanName);

						try {

							// 对从 FactoryBean 获取的对象进行后处理

							// 生成的对象将暴露给bean引用

							object = postProcessObjectFromFactoryBean(object, beanName);

						}

						catch (Throwable ex) {

							throw new BeanCreationException(beanName,

																	"Post-processing of FactoryBean's singleton object failed", ex);

						}

						finally {

							// 后置处理

							afterSingletonCreation(beanName);

						}

					}

					// 缓存

					if (containsSingleton(beanName)) {

						this.factoryBeanObjectCache.put(beanName, object);

					}

				}

			}

			return object;

		}

	}

	// 非单例 else {

		Object object = doGetObjectFromFactoryBean(factory, beanName);

		if (shouldPostProcess) {

			try {

				object = postProcessObjectFromFactoryBean(object, beanName);

			}

			catch (Throwable ex) {

				throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);

			}

		}

		return object;

	}

}

源码分析

getObjectFromFactoryBean()该方法就是创建实例对象中的核心方法之一。我们关注它之中的单个方法即可：beforeSingletonCreation，afterSingletonCreation，postProcessObjectFromFactoryBean，这三个方法十分重要，万分重要！！！！！！！！因为前两个方法记录着bean的加载状态，是检测当前bean是否处于创建中的关键之处，对解决bean循环依赖起着关键的作用。

before方法用于标记当前bean处于创建中，

after则是移除。

其实文章一开始的getSingleton源码分析就已经提到了isSingletonCurrentlyInCreation()是用于检测当前bean是否处于创建之中，

看源码(DefaultSingletonBeanRegistry.java)

public Boolean isSingletonCurrentlyInCreation(String beanName) {

	return this.singletonsCurrentlyInCreation.contains(beanName);

}

beforeSingletonCreation()

上述代码是根据变量singletonsCurrentlyInCreation集合中是否包含了beanName判断，集合的元素则一定是在beforeSingletonCreation()中添加的，如下：

protected void beforeSingletonCreation(String beanName) {

	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {

		throw new BeanCurrentlyInCreationException(beanName);

	}

}

afterSingletonCreation

afterSingletonCreation()为移除，则一定就是对singletonsCurrentlyInCreation集合remove了，如下：

protected void afterSingletonCreation(String beanName) {

	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {

		throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");

	}

}

接下来我们再来看看真正的核心方法 doGetObjectFromFactoryBean

看源码(FactoryBeanRegistrySupport.java)

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {

	Object object;

	try {

		if (System.getSecurityManager() != null) {

			AccessControlContext acc = getAccessControlContext();

			try {

				object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);

			}

			catch (PrivilegedActionException pae) {

				throw pae.getException();

			}

		} else {

			object = factory.getObject();

		}

	}

	catch (FactoryBeanNotInitializedException ex) {

		throw new BeanCurrentlyInCreationException(beanName, ex.toString());

	}

	catch (Throwable ex) {

		throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);

	}

	// Do not accept a null value for a FactoryBean that's not fully

	// initialized yet: Many FactoryBeans just return null then.

	if (object == null) {

		if (isSingletonCurrentlyInCreation(beanName)) {

			throw new BeanCurrentlyInCreationException(

									beanName, "FactoryBean which is currently in creation returned null from getObject");

		}

		object = new NullBean();

	}

	return object;

}

源码分析

在文章开始我们有介绍FactoryBean的调用方法，如果bean声明为FactoryBean类型，则当提取bean的是否提取的不是FactoryBean，而是FactoryBean中对应的getObject方法返回的bean，而doGetObjectRFromFactoryBean正是实现这一功能的。

调用完doGetObjectFromFactoryBean方法后，并没有直接返回，getObjectFromFactoryBean方法中还调用了object = postProcessObjectFromFactoryBean(object, beanName);方法，在子类AbstractAutowireCapableBeanFactory有该方法的具体实现：

看源码(AbstractAutowireCapableBeanFactory.java)

@Override

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {

	return applyBeanPostProcessorsAfterInitialization(object, beanName);

}

@Override

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)

			throws BeansException {

	Object result = existingBean;

	for (BeanPostProcessor processor : getBeanPostProcessors()) {

		Object current = processor.postProcessAfterInitialization(result, beanName);

		if (current == null) {

			return result;

		}

		result = current;

	}

	return result;

}

对于后处理器的使用，目前还没有讲到，后面再重新开篇去说，这里我们只需要了解在Spring获取Bean的规则中有这样一条，尽可能保证所有bean初始化后都会调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理，在实际开发中大可针对此特性设计自己的业务处理。

整理不易，如果对你有所帮助欢迎点赞关注

微信搜索【码上遇见你】获取更多精彩内容

巴特西