Spring Framework 组件注册 之 FactoryBean
前言
前两篇文章介绍了如何使用
@Component，@Import注解来向spring容器中注册组件（javaBean），本文将介绍通过FactoryBean接口继续向spring容器中注册组件。可能第一印象是spring中BeanFactory接口，但是这里确实说的是FactoryBean。
推荐阅读
FactoryBean 与 BeanFactory
根据接口名称，我们也可以简单看出两者的区别
- FactoryBean：它是spring中的一个Bean，只不过它是一个特殊的Bean（工厂Bean），我们可以通过它来自定义生产需要的普通JavaBean
- BeanFactory：它是spring的Bean工厂，是spring最为重要的接口之一，spring通过此接口获取，管理容器中的各个Bean
接下来将进入本文正题，如何通过FactoryBean接口向spring容器中注册组件
FactoryBean简单使用
正如前面说的，FactoryBean也是spring中的一个Bean，但是它又是一个特殊的Bean，它的存在是为了生产其他的JavaBean。首先我们看看FactoryBean自身的接口定义
public interface FactoryBean<T> {
/**
* 从Spring容器中获取Bean时会调用此方法，返回一个T对象
*/
@Nullable
T getObject() throws Exception;
/**
* 此工厂Bean返回对象的类型
*/
@Nullable
Class<?> getObjectType();
/**
* 工厂Bean创建的对象是否为单例,
* 如果返回false，说明getObject方法的实例对象不是单例的，
* Spring每次从容器中获取T对象时，都调用getObject方法创建一个对象
*/
default boolean isSingleton() {
//spring 5 接口默认返回true（单例）
return true;
}
}
FactoryBean接口定义简单明了，就是用来获取一个Bean的基本信息，下面我们自己实现该接口，来生产一个javaBean
/**
* 产生 Bike 对象的工厂Bean
*/
@Component
public class BikeFactoryBean implements FactoryBean<Bike> {
public Bike getObject() throws Exception {
System.out.println("......开始创建Bike对象......");
return new Bike();
}
public Class<?> getObjectType() {
return Bike.class;
}
public boolean isSingleton() {
return true;
}
}
自定义的一个JavaBean类
/**
* 待注册的自定义组件
*/
@Data
public class Bike {
private String id = "by FactoryBean";
}
添加spring容器启动的引导类
/**
* spring 容器启动引导类，测试 FactoryBean 功能
*/
@ComponentScan("com.spring.study.ioc.factorybean")
public class TestFactoryBeanBootstrap {
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(TestFactoryBeanBootstrap.class);
//获取工厂Bean本身的Id
String[] beanNames = applicationContext.getBeanNamesForType(BikeFactoryBean.class);
System.out.println("BikeFactoryBean names：" + Arrays.asList(beanNames));
//获取工厂Bean产生的Bean的Id
beanNames = applicationContext.getBeanNamesForType(Bike.class);
System.out.println("Bike bean names：" + Arrays.asList(beanNames));
Object bean = applicationContext.getBean("bikeFactoryBean");
System.out.println(bean);
bean = applicationContext.getBean(Bike.class);
System.out.println(bean);
// 获取工厂Bean 本身的实例对象
bean = applicationContext.getBean(BeanFactory.FACTORY_BEAN_PREFIX + "bikeFactoryBean");
System.out.println(bean);
applicationContext.close();
}
}
启动spring容器，控制台打印结果：
BikeFactoryBean names：[&bikeFactoryBean]
Bike bean names：[bikeFactoryBean]
......开始创建Bike对象......
Bike(id=by FactoryBean)
Bike(id=by FactoryBean)
com.spring.study.ioc.factorybean.BikeFactoryBean@4eb7f003
由结果可以看出
- 虽然代码中只在
BikeFactoryBean类上加了@Component注解，但是从spring容器仍然可以获取到Bike类的信息 - 工厂Bean的Id与实际产生的Bean的Id仅差了一个
&符，也就是说，工厂Bean定义的Id实际为getObject()方法返回Bean的Id，而工厂Bean本身的Id被添加了一个前缀&符 - 工厂Bean的isSingleton()方法返回了true，所以通过spring容器多次获取实际的Bean时，getObject()方法也是执行一次
- 根据工厂Bean的Id可以看出，要想从spring容器中获取工厂Bean本身，则需要在注册的Id前面添加一个
&符，而此前缀在BeanFactory接口中已经定义了FACTORY_BEAN_PREFIX
如果将BikeFactoryBean的isSingleton()方法返回了false
public boolean isSingleton() {
return false;
}
重新启动spring容器，可以看如下结果：
BikeFactoryBean names：[&bikeFactoryBean]
Bike bean names：[bikeFactoryBean]
......开始创建Bike对象......
Bike(id=by FactoryBean)
......开始创建Bike对象......
Bike(id=by FactoryBean)
com.spring.study.ioc.factorybean.BikeFactoryBean@4eb7f003
由结果可以看出，唯一的变化在于从spring容器中多次获取实际Bean时，工厂Bean的getObject()方法被多次进行了调用。这与spring容器中被标识为原型的普通Bean相同，每次从spring中获取Bean时都会被实例化。
FactoryBean 执行过程
要想了解FactoryBean的执行过程，就需要结合Spring容器启动的过程来进行分析。而spring容器的启动过程经过了纷繁复杂的步骤。为了尽可能少的入坑和挖坑，下面仅结合FactoryBean相关的源码进行说明。
在开始入坑之旅之前，结合前面的例子做几点说明，方便后续讲解
前面定义的 BikeFactoryBean 类上面直接添加了@Component注解，这样spring会默认以类名首字母小写(bikeFactoryBean)作为beanName；如果使用@Bean进行注册时，spring默认会以方法名作为beanName，下面继续以“BikeFactoryBean”为例。
- spring容器启动过程中，在执行完所有的
BeanFactoryPostProcessor，BeanPostProcessor以及注册Listener后会执行org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization()方法，此方法会对剩下所有的非Abstract、非LazyInit的单实例Bean进行实例化，以下为部分代码片段。
@Override
public void preInstantiateSingletons() throws BeansException {
...省略代码...
// 1. 拷贝一份副本：spring容器中的所有的Bean名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 2. 遍历每一个beanName，尝试通过getBean()方法进行实例化
// 在getBean()方法内部会先尝试从容器singletonObjects中获取Bean，如果没有才会进行实例化操作
for (String beanName : beanNames) {
// 3. 通过beanName获取Bean定义信息 BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 4. 根据BeanDefinition判断该Bean是否不是抽象的，单例的，非懒加载的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 5. 满足上面的条件后，在根据beanName判断此Bean是否是一个工厂Bean（实现了FactoryBean接口）
if (isFactoryBean(beanName)) {
// 6. 如果是一个工厂Bean，则在此处进行工厂Bean本身的实例化
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
...省略代码...
}
else {
// 如果不是工厂bean，也是调用getBean()方法进行实例化
getBean(beanName);
}
}
}
...省略代码...
}
preInstantiateSingletons()是在finishBeanFactoryInitialization()方法内部调用的
根据上面的代码流程，在第6步时，会对
BikeFactoryBean类本身进行实例化，并且可以看出传递的beanName为初始注册的name前添加了&符前缀即&bikeFactoryBean，用于在genBean()方法内部标识它是一个工厂Bean。但是在跟踪源码后发现，在getBean()方法内部，会先将传入的beanName(&bikeFactoryBean)开头的&符去除，并且最终实例化Bean后，在容器中保存的beanName还是不带&符前缀的名称即bikeFactoryBean
- 根据第一步的结果，spring容器在启动后，工厂Bean会像普通Bean一样在spring容器中会保留一条自身的单实例Bean（spring容器中保存的数据为：<bikeFactoryBean, BikeFactoryBean>），既然spring容器中只保存了BikeFactoryBean本身，那么后续获取
Bike类的beanName和Bean实例时，又是怎么获取到的呢？带着疑问，我们继续看后面的代码。首先，上面的例子中调用了applicationContext.getBeanNamesForType(Bike.class)方法来获取Bike类的beanName。所以继续跟踪此方法看看到底发生了什么。
// getBeanNamesForType()方法内部最终调用了此方法，可断点跟踪至此
private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
// 用来保存符合条件的结果（beanName集合）
List<String> result = new ArrayList<>();
// 与上面的代码相似，遍历spring容器中注册的所有的beanNames
for (String beanName : this.beanDefinitionNames) {
if (!isAlias(beanName)) {
try {
// 根据beanName获取Bean的定义信息 BeanDefinition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 根据BeanDefinition 进行检查
if (!mbd.isAbstract() && (allowEagerInit ||
(mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
!requiresEagerInitForType(mbd.getFactoryBeanName()))) {
// 根据beanName和Bean的定义信息判断是否是工厂Bean
boolean isFactoryBean = isFactoryBean(beanName, mbd);
BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
boolean matchFound =
(allowEagerInit || !isFactoryBean ||
(dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&
(includeNonSingletons ||
(dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&
// 根据Bean的定义信息判断完后，在此方法中判断此beanName对应的Bean实例是否与传入的类型相匹配
isTypeMatch(beanName, type);
// 如果根据beanName获得的是一个工厂Bean，并且与传入的类型不匹配，则满足条件，将beanName添加 & 符前缀
if (!matchFound && isFactoryBean) {
// 对于工厂Bean，接下来尝试匹配工厂Bean实例本身
beanName = FACTORY_BEAN_PREFIX + beanName;
matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
}
// 如果获取的Bean实例与传入的类型匹配，将beanName添加到结果集合中
if (matchFound) {
result.add(beanName);
}
}
}
catch (CannotLoadBeanClassException ex) {
// ...省略代码...
}
catch (BeanDefinitionStoreException ex) {
// ...省略代码...
}
}
}
// ...省略代码...
return StringUtils.toStringArray(result);
}
isTypeMatch()方法中的部分代码
public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
// 对beanName进行处理，将开头的 & 符过滤
String beanName = transformedBeanName(name);
// 从spring容器中获取单实例Bean，由于spring容器启动时已经将单实例Bean进行了实例化，
// 所以此时可以直接在容器中得到Bean实例
Object beanInstance = getSingleton(beanName, false);
if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
// 获取到Bean实例后，判断是否为工厂Bean
if (beanInstance instanceof FactoryBean) {
// 如果是工厂Bean，并且获取的beanName不是以&符开头
if (!BeanFactoryUtils.isFactoryDereference(name)) {
// 将实例强转为 FactoryBean 并调用 FactoryBean接口的getObjectType()方法，
// 获取工厂Bean所生产的实例类型
Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
// 判断工厂Bean生产的实例类型与传入的类型是否匹配
return (type != null && typeToMatch.isAssignableFrom(type));
}
else {
return typeToMatch.isInstance(beanInstance);
}
}
// ...省略代码...
}
// ...省略代码...
}
getTypeForFactoryBean()方法中的代码
protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
try {
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedAction<Class<?>>)
factoryBean::getObjectType, getAccessControlContext());
}
else {
// 直接调用 FactoryBean 接口的 getObjectType()方法，获取生产的类型
return factoryBean.getObjectType();
}
}
catch (Throwable ex) {
// Thrown from the FactoryBean's getObjectType implementation.
logger.info("FactoryBean threw exception from getObjectType, despite the contract saying " +
"that it should return null if the type of its object cannot be determined yet", ex);
return null;
}
}
以上便是getBeanNamesForType()方法经过的部分重要代码
由此可以看出，当我们想要获取
BikeFactoryBean本身的beanName时，doGetBeanNamesForType方法内部将bikeFactoryBean前添加了&符前缀，于是便获取到了&bikeFactoryBean；
当我们想要获取Bike类型的beanName时，spring会通过容器遍历已经注册的所有的beanNames，然后根据beanName及对应的Bean定义信息BeanDefinition进行判断过滤，并且对于所有的工厂Bean，会获取spring容器中已经实例化的Bean对象，调用 FactoryBean 接口的 getObjectType()方法，得到工厂Bean所生产的实例类型，然后与Bike.class相比较，如果匹配，则将此beanName保存到结果集中，最后返回。所以，当我们想要获取Bike类型的beanName时，从spring容器中便可以找到bikeFactoryBean。
- 从spring容器中获取到
beanName后，我们继续获取Bike实例
从前文中引导类的代码可以看出，获取Bike实例有两种方式，跟踪源码可以发现，根据Bike类型获取实例时，spring实际是通过第二步获取到beanName后再最终调用doGetBean方法获取实例对象。下面看看部分源码
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 对传入的beanName进行过滤，去除&符前缀
final String beanName = transformedBeanName(name);
Object bean;
// 从spring容器中获取实例，由于spring容器启动时已经将单实例Bean进行实例化，所以此时可以直接获得
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 + "'");
}
}
// 获取指定的Bean实例，如果是工厂bean，则为Bean实例本身或其创建的对象。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// ...省略代码...
return (T) bean;
}
从上面的代码可以看出，获取Bike实例的具体代码还在getObjectForBeanInstanc()方法内部，我们继续查看
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 判断beanName是否是以&符开头的
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
}
// 根据beanName从spring容器中获取的Bean实例如果不是工厂Bean，或者beanName是以&符开头，就直接返回这个Bean实例
// 当我们获取Bike类型的实例时，beanName为“bikeFactoryBean”，
// beanInstance为“BikeFactoryBean”类型，是一个工厂Bean，所以条件不满足，继续向下走
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
// 根据beanName从缓存中获取Bean实例，第一次来获取Bike实例时为空，
// factoryBeanObjectCache.get(beanName);
// 后续再获取时，便可以在此获得到，然后返回
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// 将获取的工厂Bean强转为 FactoryBean 类型，以便下面调用其getObject()方法获取对象
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// 获取bean定义信息
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
//在此方法内部调用 FactoryBean 接口的 getObject()方法获取对象
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
距离真相还差两步了，坚持就是胜利，我们继续看getObjectFromFactoryBean()的源码
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 此处调用 FactoryBean 的isSingleton()方法，判断是否是一个单列
// 如果是单例的，走if内部，获取到对象后，会保存到factoryBeanObjectCache缓存中，以便后续使用
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
// 检查缓存中是否已经存在
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 调用最后一个方法，执行FactoryBean 的 getObject()方法获取对象
object = doGetObjectFromFactoryBean(factory, beanName);
// 再次检查缓存
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
// ... 省略代码 ...
if (containsSingleton(beanName)) {
// 将获取的对象放入factoryBeanObjectCache缓存中，以便后续使用
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
// 如果不是单例的，每次获取的对象直接返回，不会放入缓存中,所以每次都会调用getObject()方法
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;
}
}
根据上面的流程，终于来到了最后一步
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final 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 {
// 直接调用 FactoryBean 接口的 getObject()方法获取实例对象
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
// ... 省略代码 ...
return object;
}
经过如此多的代码，spring终于帮我们获取到Bike对象实例
通过BikeFactoryBean来获取Bike类的实例时，spring先获取Bike类型对应的beanName（bikeFactoryBean），然后根据beanName获取到工厂Bean实例本身（BikeFactoryBean），最终spring会调用BikeFactoryBean 的 getObject()方法来获取Bike对象实例。并且根据 BikeFactoryBean 实例的 isSingleton() 方法来判断Bike类型的实例是否时单例的，依此来决定要不要将获取的Bike对象放入到缓存中，以便后续使用。
总结
本文主要讲解了如何通过 FactoryBean接口向spring容器中注入组件，通过简单的案例进行模拟，并根据案例对源码的执行过程进行跟踪，分析了FactoryBean接口的执行过程。
另外，在每一次跟踪spring源码时，都会有新的收获。在spring庞大的体系下，只有定位好自己的目标，明确自己的需求，才不会被spring无限的代码所淹没。
学习永远都不是一件简单的事情，可以有迷茫，可以懒惰，但是前进的脚步永远都不能停止。
不积跬步，无以至千里；不积小流，无以成江海；