什么是FactoryBean？
根据FactoryBean源码的注释，我们可以对FactoryBean有如下大概的认识。
FactoryBean是单个对象的工厂，可以做为spring中的bean。
FactoryBean如果作为spring的bean，如果没有显式指定，获取到的bean对象是根据FactoryBean#getObject方法获取的对象。
FactoryBean支持单例和原型，可以根据需要在启动容器时实时或延迟创建对象。
Spring容器只负责管理FactoryBean实例的生命周期，而不负责管理由FactoryBean创建的对象的生命周期。
如何使用FactoryBean？
通常情况下，Spring使用反射通过调用bean的构造器方法实例化并初始化bean，在这种情况下，我们无法直接控制bean的创建。FactoryBean作为一个工厂bean，作用便是自定义bean的创建。使用FactoryBean时，需要我们定义一个类实现FactoryBean作为spring中的bean，当我们根据名称获取bean时获取的是FactoryBean创建的对象。
创建User类及UserFactoryBean类
@Getter @Setter public class User { public User(){ System.out.println("创建User中..."); } private Integer id; private String name; } public class UserFactoryBean implements SmartFactoryBean<User> { public UserFactoryBean() { } @Override public User getObject() throws Exception { return new User(); } @Override public Class<?> getObjectType() { return User.class; } @Override public boolean isSingleton() { return true; } @Override public boolean isEagerInit() { return true; } }
bean定义如下：
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="user" class="com.zuhkp.spring.factory.domain.UserFactoryBean"></bean> </beans>
测试类如下：
public class FactoryBeanDemo { public static void main(String[] args) { System.out.println("准备初始化BeanFactory"); String location = "classpath:/META-INF/beans.xml"; BeanFactory beanFactory = new ClassPathXmlApplicationContext(location); System.out.println("结束初始化BeanFactory"); Object userFactoryBean = beanFactory.getBean("&user"); System.out.println("根据bean名称 &user 获取到的bean实例:" + userFactoryBean); Object user1 = beanFactory.getBean("user"); System.out.println("根据bean名称 user 获取到的bean实例:" + user1); Object user2 = beanFactory.getBean("user"); System.out.println("根据bean名称 user 再次获取到的bean实例:" + user2); Class<?> userFactoryBeanType = beanFactory.getType("&user"); System.out.println("根据bean名称 &user 获取到的bean类型:" + userFactoryBeanType); Class<?> userType = beanFactory.getType("user"); System.out.println("根据bean名称 user 获取到的bean类型:" + userType); } }
打印结果如下：
准备初始化BeanFactory 创建User中... 结束初始化BeanFactory 根据bean名称 &user 获取到的bean实例:com.zuhkp.spring.factory.domain.UserFactoryBean@323b36e0 根据bean名称 user 获取到的bean实例:com.zuhkp.spring.factory.domain.User@44ebcd03 根据bean名称 user 再次获取到的bean实例:com.zuhkp.spring.factory.domain.User@44ebcd03 根据bean名称 &user 获取到的bean类型:class com.zuhkp.spring.factory.domain.UserFactoryBean 根据bean名称 user 获取到的bean类型:class com.zuhkp.spring.factory.domain.User
在xml文件中我们定义了id为user,class为UserFactoryBean的bean。根据打印结果可得出如下结论。
根据bean名称 &user 获取到了UserFactoryBean 的实例和类型，表明FactoryBean可作为Spring的bean，并且bean的名称以 & 开头时获取的是FactoryBean本身。
根据bean名称 user 获取到的是User 的实例和类型，表明如果bean的类型为FactoryBean时，如果获取bean时指定的bean的名称不以 & 开头，获取的bean是
FactoryBean创建的bean的实例和管理的类型。
FactoryBean#isSingleton方法返回true时，每次获取的bean都是同一个。
SmartFactoryBean是FactoryBean的子接口，SmartFactoryBean#isEagerInit方法返回true时，将在容器初始化时对FactoryBean管理的对象实时初始化。
FactoryBean源码浅析
spring版本：5.2.6.RELEASE
public interface FactoryBean<T> { /** * BeanDefinition可以使用AttributeAccessor#setAttribute方法设置的属性的名称，以便可以推断bean的类型 * @since 5.2 */ String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType"; /** * 返回此工厂管理的对象的实例（可能是共享的或独立的）。 * 与BeanFactory一样，这允许同时支持Singleton和Prototype设计模式。 * 如果调用时此FactoryBean尚未完全初始化（例如，因为它涉及循环引用），则抛出相应的FactoryBeanNotInitializedException。 * 从Spring2.0开始，允许FactoryBeans返回空对象。工厂将把它视为要使用的正常值； * 在这种情况下，它不会再抛出FactoryBeanNotInitializedException。 * 现在鼓励FactoryBean实现根据需要抛出FactoryBeanNotInitializedException。 * * @return an instance of the bean (can be {@code null}) * @throws Exception in case of creation errors * @see FactoryBeanNotInitializedException */ @Nullable T getObject() throws Exception; /** * 返回此FactoryBean创建的对象类型，如果事先不知道，则返回null。 * 这允许用户在不实例化对象的情况下检查特定类型的bean，例如在autowiring上。 * 对于正在创建单例对象的实现，此方法应尽量避免创建单例对象；它应该预先估计类型。 * 对于原型，在这里返回一个有意义的类型也是可取的。 * 在完全初始化此FactoryBean之前可以调用此方法。它不能依赖于初始化期间创建的状态；当然，如果可用，它仍然可以使用这种状态。 * 注意：Autowiring只会忽略在这里返回null的factorybean。因此，强烈建议使用FactoryBean的当前状态正确地实现此方法。 * * @return the type of object that this FactoryBean creates, * or {@code null} if not known at the time of the call * @see ListableBeanFactory#getBeansOfType */ @Nullable Class<?> getObjectType(); /** * 这个工厂管理的对象是单例的吗？也就是说，getObject（）是否总是返回相同的对象（可以缓存的引用）？ * <p> * 注意：如果FactoryBean指示保存一个singleton对象，那么从getObject（）返回的对象可能会被拥有的BeanFactory缓存。 * 因此，除非FactoryBean始终公开相同的引用，否则不要返回true。 * <p> * FactoryBean本身的singleton状态通常由拥有它的BeanFactory提供；通常，它必须在那里定义为singleton。 * <p> * 注意：这个返回false的方法不一定表示返回的对象是独立的实例。 * 扩展SmartFactoryBean接口的实现可以通过SmartFactoryBean.isPrototype（）方法。 * 如果isSingleton（）实现返回false，那么不实现此扩展接口的普通FactoryBean实现将始终返回独立实例。 * 默认实现返回true，因为FactoryBean通常管理一个singleton实例。 * * @return whether the exposed object is a singleton * @see #getObject() * @see SmartFactoryBean#isPrototype() */ default boolean isSingleton() { return true; } }
FactoryBean字段
String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
FactoryBean只有一个字段OBJECT_TYPE_ATTRIBUTE，在获取bean的类型时使用。
FactoryBean方法
T getObject() throws Exception;：获取FactoryBean管理的对象实例，每次调用可能返回相同或不同的对象。
Class getObjectType();：获取FactoryBean管理的对象的类型，以便可以不实例化对象就可以获取bean的类型。
default boolean isSingleton()：FactoryBean管理的对象是否为单例，如果返回true，则每次调用getObject()方法返回的都是同一个实例。
SmartFactoryBean源码浅析
SmartFactoryBean是FactoryBean的子接口，对FactoryBean进行了扩展。
public interface SmartFactoryBean<T> extends FactoryBean<T> { /** * 这个工厂管理的对象是原型吗？也就是说，getObject（）是否总是返回一个独立的实例？ * FactoryBean本身的原型状态通常由拥有它的BeanFactory提供；通常，它必须被定义为singleton。 * 此方法应该严格检查独立实例；对于作用域对象或其他类型的非单例、非独立对象，它不应返回true。 * 因此，这不仅仅是isSingleton（）的倒置形式。 默认实现返回false。 * @return whether the exposed object is a prototype * @see #getObject() * @see #isSingleton() */ default boolean isPrototype() { return false; } /** * 这个FactoryBean是否期望立即初始化，也就是说，急切地初始化它自己以及期望它的singleton对象（如果有的话）的急切初始化？ * 标准的FactoryBean不需要急于初始化：它的getObject（）只会在实际访问时被调用，即使是在单例对象的情况下也是如此。 * 从这个方法返回true意味着应该急切地调用getObject（），也应该急切地应用后处理程序。 * 对于单例对象，这可能是有意义的，特别是如果后处理器希望在启动时应用。 默认实现返回false。 * @return whether eager initialization applies * @see org.springframework.beans.factory.config.ConfigurableListableBeanFactory#preInstantiateSingletons() */ default boolean isEagerInit() { return false; } }
default boolean isPrototype()：FactoryBean管理的对象是否为prototype。
default boolean isEagerInit()：容器启动时是否初始化FactoryBean管理的对象。
Spring对FactoryBean的应用
定义的FactoryBean类型的bean为什么获取到的是FactoryBean#getObject()返回的对象？
跟踪BeanFactory#getBean(String)方法，spring获取bean时首先获取到bean实例，bean实例可能为普通的bean，也有可能是FactoryBean类型的bean，然后调用AbstractBeanFactory#getObjectForBeanInstance方法进行进一步处理。AbstractBeanFactory#getObjectForBeanInstance方法源码如下:
protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { //name以&开头 if (BeanFactoryUtils.isFactoryDereference(name)) { if (beanInstance instanceof NullBean) { return beanInstance; } //name以&开头，但是对应的bean实例不是FactoryBean，抛出异常 if (!(beanInstance instanceof FactoryBean)) { throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass()); } if (mbd != null) { mbd.isFactoryBean = true; } return beanInstance; } //name不以&开头，name对应的bean实例不是FactoryBean，直接返回bean实例 if (!(beanInstance instanceof FactoryBean)) { return beanInstance; } //name不以&开头，对应的bean实例是FactoryBean Object object = null; if (mbd != null) { mbd.isFactoryBean = true; } else { //优先从缓存中获取 object = getCachedObjectForFactoryBean(beanName); } if (object == null) { //缓存中不存在，从FactoryBean中获取 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()); object = getObjectFromFactoryBean(factory, beanName, !synthetic); } return object; }
这里发现bean的名称以&开头，并且bean的类型是FactoryBean会直接返回。如果bean的名称不以&开头，并且bean的类型非FactoryBean也会直接返回。否则会调用FactoryBeanRegistrySupport#getObjectFromFactoryBean方法从FactoryBean中获取。这里也验证了为什么bean的名称以&开头获取的是FactoryBean本身。
FactoryBeanRegistrySupport#getObjectFromFactoryBean源码如下：
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { if (factory.isSingleton() && containsSingleton(beanName)) { //FactoryBean获取的对象为单例，并且当前已经包含了单例，才根据FactoryBean获取单例 synchronized (getSingletonMutex()) { Object object = this.factoryBeanObjectCache.get(beanName); if (object == null) { object = doGetObjectFromFactoryBean(factory, beanName); // TODO 什么情况下可以重复获取到？ // 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) { if (isSingletonCurrentlyInCreation(beanName)) { // TODO 什么时候能够执行到该位置？ // Temporarily return non-post-processed object, not storing it yet.. return object; } beforeSingletonCreation(beanName); try { object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", ex); } finally { afterSingletonCreation(beanName); } } // FactoryBean管理的对象是single，并且FactoryBean也是singleton，则缓存 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; } }
如果FactoryBean在spring容器中为singleton，并且FactoryBean管理的对象也为singleton则会缓存FactoryBean管理的对象，获取FactoryBean管理的对象时优先从缓存中获取，否则调用FactoryBeanRegistrySupport#doGetObjectFromFactoryBean方法，这个方法将会调用FactoryBean#getObject获取FactoryBean管理的对象。
定义的FactoryBean类型的bean为什么获取到的是FactoryBean#getObjectType返回的类型？
跟踪BeanFactory#getType(String, boolean)方法，由AbstractBeanFactory进行实现，源码如下：
@Nullable public Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException { String beanName = transformedBeanName(name); // 先从singleton中获取对象类型 // Check manually registered singletons. Object beanInstance = getSingleton(beanName, false); if (beanInstance != null && beanInstance.getClass() != NullBean.class) { if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) { return getTypeForFactoryBean((FactoryBean<?>) beanInstance); } else { return beanInstance.getClass(); } } // singleton和当前BeanFactory中的BeanDefinition不存在，从父BeanFactory中获取 // No singleton instance found -> check bean definition. BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // No bean definition found in this factory -> delegate to parent. return parentBeanFactory.getType(originalBeanName(name)); } RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 优先从装饰的BeanDefinition中获取类型 // Check decorated bean definition, if any: We assume it'll be easier // to determine the decorated bean's type than the proxy's type. BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) { RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd); Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd); if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) { return targetClass; } } Class<?> beanClass = predictBeanType(beanName, mbd); // Check bean class whether we're dealing with a FactoryBean. if (beanClass != null && FactoryBean.class.isAssignableFrom(beanClass)) { if (!BeanFactoryUtils.isFactoryDereference(name)) { //name不以&开头，但是bean的类型为FactoryBean，则从FactoryBean中获取bean的真实类型 // If it's a FactoryBean, we want to look at what it creates, not at the factory class. return getTypeForFactoryBean(beanName, mbd, allowFactoryBeanInit).resolve(); } else { return beanClass; } } else { //name不以&开头则直接返回获取预测的beanClass return (!BeanFactoryUtils.isFactoryDereference(name) ? beanClass : null); } }
AbstractBeanFactory#getType(String, boolean) 方法优先从singleton bean中获取类型，如果singleton bean 为FactoryBean，则调用FactoryBeanRegistrySupport#getTypeForFactoryBean方法，#getTypeForFactoryBean将调用FactoryBean#getObjectType方法获取FactoryBean管理的对象的类型。
当前BeanFactory存在bean定义时还将调用AbstractBeanFactory#getTypeForFactoryBean(String, RootBeanDefinition, boolean)方法，getTypeForFactoryBean方法源码如下：
protected ResolvableType getTypeForFactoryBean(String beanName, RootBeanDefinition mbd, boolean allowInit) { ResolvableType result = getTypeForFactoryBeanFromAttributes(mbd); if (result != ResolvableType.NONE) { return result; } if (allowInit && mbd.isSingleton()) { try { FactoryBean<?> factoryBean = doGetBean(FACTORY_BEAN_PREFIX + beanName, FactoryBean.class, null, true); Class<?> objectType = getTypeForFactoryBean(factoryBean); return (objectType != null) ? ResolvableType.forClass(objectType) : ResolvableType.NONE; } catch (BeanCreationException ex) { if (ex.contains(BeanCurrentlyInCreationException.class)) { logger.trace(LogMessage.format("Bean currently in creation on FactoryBean type check: %s", ex)); } else if (mbd.isLazyInit()) { logger.trace(LogMessage.format("Bean creation exception on lazy FactoryBean type check: %s", ex)); } else { logger.debug( LogMessage.format("Bean creation exception on non-lazy FactoryBean type check: %s", ex)); } onSuppressedException(ex); } } return ResolvableType.NONE; }
AbstractBeanFactory#getTypeForFactoryBean(String, RootBeanDefinition, boolean)方法将优先调用AbstractBeanFactory#getTypeForFactoryBeanFromAttributes方法，如果获取不到，FactoryBean为允许初始化的singleton则调用FactoryBeanRegistrySupport#getTypeForFactoryBean方法。
查看AbstractBeanFactory#getTypeForFactoryBeanFromAttributes方法源码如下：
ResolvableType getTypeForFactoryBeanFromAttributes(AttributeAccessor attributes) { Object attribute = attributes.getAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE); if (attribute instanceof ResolvableType) { return (ResolvableType) attribute; } if (attribute instanceof Class) { return ResolvableType.forClass((Class<?>) attribute); } return ResolvableType.NONE; }
可以看到，在此使用了FactoryBean.OBJECT_TYPE_ATTRIBUTE获取bean的类型。
Spring容器启动初始化FactoryBean流程
Spring容器启动时方法调用链如下：
AbstractApplicationContext#refresh,refresh --> AbstractApplicationContext#finishBeanFactoryInitialization --> DefaultListableBeanFactory#preInstantiateSingletons。
preInstantiateSingletons方法将对singleton bean进行实例化，源码如下。
public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { final FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { getBean(beanName); } } } ...省略部分代码 }
可以看到，如果bean不是抽象类，并且bean是singleton，并且bean不是懒加载，就会对bean进行初始化。如果bean是FactoryBean，并且FactoryBean管理的bean不是懒加载，还将初始化FactoryBean管理的对象。
总结
日常开发中对FactoryBean的使用并不常见，然而了解FacotryBean可以让我们更清晰的了解spring的底层实现及提供的能力。本文首先对FactoryBean进行解读，然后对FactoryBean的使用场景及使用方式进行阐述，最后从源码角度分析Spring如何使用FactoryBean的，从而解答了样例中输出结果的原因。
