Spring拓展接口之FactoryBean，我们来看看其源码实现

前言

　　开心一刻

　　　那年去相亲，地点在饭店里，威特先上了两杯水，男方绅士的喝了一口，咧嘴咋舌轻放桌面，手抚额头闭眼一脸陶醉，白水硬是喝出了82年拉菲的感觉。如此有生活情调的幽默男人，果断拿下，相处后却发现他比较木讷，问他为什么那天喝水那么有趣，他仰头道：鬼知道那杯水怎么那么烫啊！

是什么

　　FactoryBean的源码比较简单，大家可以细读下其注释，我做了简单的如下翻译

1/**
2 * 实现此接口的bean不能用作普通bean。此bean暴露的对象是通过getObject()创建的对象，而不是它自身
3 */
4public interface FactoryBean<T> {
5
6    /**
7     * 返回此工厂管理的对象的实例（可能是共享的或独立的，取决于isSingleton()的返回值）
8     */
9    @Nullable
10    T getObject() throws Exception;
11
12    /**
13     * 返回此FactoryBean创建的对象类型,
14     */
15    @Nullable
16    Class<?> getObjectType();
17
18    /**
19     * 该工厂管理的对象是否为单例?
20     * 如果是(return true),getObject()总是返回同一个共享的实例，该对象会被BeanFactory缓存起来
21     * 如果是(return false),getObject()返回独立的实例
22     * 一般情况下返回true
23     */
24    default boolean isSingleton() {
25        return true;
26    }
27
28}

　　说的简单点，FactoryBean是BeanFactory支持的、用来暴露bean实例的接口

有什么用

　　先带大家回忆下，目前我们配置bean主要有哪几种方式？

　　1、基于XML的配置方式

　　　　在xml文件中配置，例如

1<?xml version="1.0" encoding="UTF-8"?>
2<beans xmlns="http://www.springframework.org/schema/beans"
3    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4    xsi:schemaLocation="http://www.springframework.org/schema/beans
5    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">
6    
7    <bean id="user" class="com.lee.factorybean.User">
8        <property name="name" value="zhangsan"/>
9    </bean>    
10</beans>

　　　　spring的发布的第一版就支持，这个大家都知道

　　2、基于注解的配置方式

　　　　spring2.5开始支持，例如：@Compoment、@Repository、@Controller、@Service等，平时我们用的挺多的

　　3、基于Java类的配置方式

　　　　spring3.0开始支持，也是目前spring推荐的方式，@Configuration结合@Bean，springboot中用的非常多

　　一般情况下，Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的xml方式，则需要在<bean>中提供大量的配置信息。xml配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。那么编码方式又有哪些了？spring3.0之后，编码的方式有基于注解、基于Java类以及基于FactoryBean，那么在spring2.5之前了，如何用xml方式配置实例化过程比较复杂的Bean？可以采用xml结合FactoryBean来实现，xml中配置FactoryBean，FactoryBean创建我们需要的、实例化过程比较复杂的Bean，示例核心代码如下，从spring容器获取name为user的bean实例，获取到的是User类型的Bean

　　xml配置

1<?xml version="1.0" encoding="UTF-8"?>
2<beans xmlns="http://www.springframework.org/schema/beans"
3    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4    xsi:schemaLocation="http://www.springframework.org/schema/beans
5    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">
6    
7    <bean id="user" class="com.lee.factorybean.config.UserFactoryBean" />
8</beans>

　　UserFactoryBean

1package com.lee.factorybean.config;
2
3import com.lee.factorybean.entity.User;
4import org.springframework.beans.factory.FactoryBean;
5
6public class UserFactoryBean implements FactoryBean<User> {
7
8    @Override
9    public User getObject() throws Exception {
10        // 假设User的实例化过程比较复杂，在此处进行User的实例化
11        return new User();
12    }
13
14    @Override
15    public Class<?> getObjectType() {
16        return User.class;
17    }
18
19    @Override
20    public boolean isSingleton() {
21        return true;
22    }
23}

　　spring2.5之前，只能通过xml的配置方式将Bean注册到spring管理，但是xml的配置方式又不够灵活，配置实例化过程比较复杂的Bean比较麻烦，所有结合FactoryBean，既能采用编码的方式构建实例化过程比较复杂的Bean，也能将Bean交由Spring管理；spring2.5之后，特别是spring3.0之后，注册实例化过程比较复杂的Bean到spring容器的方式就比较多了（可采用的编码方式比较多），FactoryBean的方式也一直被spring支持。

　　说的再简单点，通过FactoryBean可以创建实例化过程比较复杂的Bean，至于我们以何种方式将FactoryBean的实例注册到Spring容器，在不同的spring版本，可以采用不同的方式

怎么用

　　我们通过一个简单的示例来看看FactoryBean到底是怎么用的

　　应用示例

　　　　示例地址：spring-boot-FactoryBean

　　　　UserFactoryBean

1package com.lee.factorybean.config;
2
3import com.lee.factorybean.entity.User;
4import org.springframework.beans.factory.FactoryBean;
5import org.springframework.stereotype.Component;
6
7@Component("user")          // beanName = user
8public class UserFactoryBean implements FactoryBean<User> {
9
10    @Override
11    public User getObject() throws Exception {
12        // 假设User的实例化过程比较复杂，在此处进行User的实例化
13        return new User();
14    }
15
16    @Override
17    public Class<?> getObjectType() {
18        return User.class;
19    }
20
21    @Override
22    public boolean isSingleton() {
23        return true;
24    }
25}

View Code

　　　　User

1package com.lee.factorybean.entity;
2
3public class User {
4    private Integer id;
5    private String name;
6    private Integer age;
7
8    public Integer getId() {
9        return id;
10    }
11
12    public void setId(Integer id) {
13        this.id = id;
14    }
15
16    public String getName() {
17        return name;
18    }
19
20    public void setName(String name) {
21        this.name = name;
22    }
23
24    public Integer getAge() {
25        return age;
26    }
27
28    public void setAge(Integer age) {
29        this.age = age;
30    }
31}

View Code

　　　　FactoryBeanTest

1package com.lee.factorybean.test;
2
3import com.lee.factorybean.FactoryBeanApplication;
4import org.junit.Test;
5import org.junit.runner.RunWith;
6import org.springframework.beans.factory.BeanFactory;
7import org.springframework.beans.factory.annotation.Autowired;
8import org.springframework.boot.test.context.SpringBootTest;
9import org.springframework.test.context.junit4.SpringRunner;
10
11@RunWith(SpringRunner.class)
12@SpringBootTest
13public class FactoryBeanTest {
14
15    @Autowired
16    private BeanFactory beanFactory;
17
18    @Test
19    public void test() {
20        Object user = beanFactory.getBean("user");
21        System.out.println(user.getClass().getName());
22    }
23
24}

View Code

　　　　我们运行测试用例，发现输出的结果是：com.lee.factorybean.entity.User，而不是：com.lee.factorybean.config.UserFactoryBean

　　spring中的FactoryBean实现

　　　　Spring自身就提供了很多FactoryBean的实现（spring版本不一样，实现数量不一样），springboot2.0.3（对应spring5.0.7）中FactoryBean实现有如下

　　　　除了我们自定义的UserFactoryBean，有60个是springboot中的实现，其中有50多个是spring中的实现；有兴趣的可以细看下，注意springboot版本，如果直接用的spring，则注意spring的版本

　　实际工作中，我们自己实现FactoryBean的场景非常少，反正我工作中是用的非常少，印象中有，但感觉是很久之前的事了；Spring中有很多FactoryBean的实现，也有很多第三方的实现，比如MyBatis的MapperFactoryBean、druid的JdbcStatManagerFactoryBean、shiro的ShiroFilterFactoryBean等等。用不用FactoryBean，全看我们个人，但我们一定得知道FactoryBean，当我们碰到FactoryBean的实现时（读源码很容易碰到），我们一眼就能明白其意图，当我们需要构建实例化过程比较复杂的Bean时，FactoryBean也是一种可选的方案

为什么

　　具体问题应该是这样的：上述示例中，为什么从spring容器获取的name为user的实例，其类型是User，而不是UserFactoryBean；抽象的问题：根据FactoryBean实例的name获取的为什么不是FactoryBean实例，而是FactoryBean实例的getObject()返回的对象？ 

　　源码探究

　　　　我们就以beanFactory.getBean("user");为断点入口

1@Test
2public void test() {
3        // 断点入口
4    Object user = beanFactory.getBean("user");
5    System.out.println(user.getClass().getName());
6} 

　　　　一开始从spring容器获取名为user的bean，类型确实是：UserFactoryBean，但是后面又经过getObjectForBeanInstance来真正获取我们需要的对象

1bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
2
3/**
4 * 获取实例对象
5 * 可能是beanInstance自身，也可能是beanInstance创建的对象(如果beanInstance是FactoryBean类型)
6 */
7protected Object getObjectForBeanInstance(
8        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
9
10    // name以工厂引用(&)开头，可以跟下isFactoryDereference方法
11    if (BeanFactoryUtils.isFactoryDereference(name)) {
12        if (beanInstance instanceof NullBean) {
13            return beanInstance;
14        }
15        // 如果name以&开头，而beanInstance不是FactoryBean类型，则抛异常（我们没按spring规则来使用）
16        if (!(beanInstance instanceof FactoryBean)) {
17            throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
18        }
19    }
20
21    // 如果beanInstance不是FactoryBean类型，则直接返回beanInstance
22    // 或者name以&开头，也直接返回beanInstance，说明我们就想获取FactoryBean实例
23    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
24        return beanInstance;
25    }
26
27    Object object = null;
28    if (mbd == null) {
29        object = getCachedObjectForFactoryBean(beanName);
30    }
31    if (object == null) {
32        // 此时beanInstance是FactoryBean类型，而name又不是以&开头; 这是我们示例工程的情况，也是最普通、用的最多的情况
33        // 将beanInstance强转成FactoryBean类型
34        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
35        // 从缓存中获取我们需要的实例对象
36        if (mbd == null && containsBeanDefinition(beanName)) {
37            mbd = getMergedLocalBeanDefinition(beanName);
38        }
39        boolean synthetic = (mbd != null && mbd.isSynthetic());
40        // 调用FactoryBean的getObject方法创建我们需要的实例对象；大家自行跟下getObjectFromFactoryBean
41        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
42    }
43    return object;
44}

View Code

　　　　根据name从spring容器获取实例，如果该实例不是FactoryBean类型，则直接返回该实例，这也是我们平时用的最多的、最普通的情况；如果该实例是FactoryBean类型，而name又是以&开头，也直接返回该实例，说明我们想要的就是FactoryBean实例；如果name不是以&开头，而该实例又是FactoryBean类型，则会调用该实例的getObject()来创建我们需要的目标实例

　　如何获取FactoryBean实例

　　　　这个答案在上面已经有了，通过在name前加&即可，如下

1@Test
2public void test() {
3    Object user = beanFactory.getBean("&user");
4    System.out.println(user.getClass().getName());
5}

　　　　输出结果如下

com.lee.factorybean.config.UserFactoryBean

总结

　　1、FactoryBean是BeanFactory支持的、用来暴露bean实例的接口，可以实现此接口来完成实例化过程比较复杂的bean的创建；

　　2、通过beanName从spring容器获取bean实例时，一开始获取的是beanName直接关联的bean实例，后续spring容器会根据此bean实例返回我们需要的对象实例；如果bean实例不是FactoryBean类型，则直接返回bean实例，如果bean实例是FactoryBean类型，而beanName又是以&开头，直接返回bean实例，如果bean实例是FactoryBean类型，而beanName不是以&开头，则返回bean实例的getObject()方法获取的对象实例（一般getObject中就是我们需要的实例对象的创建过程）；

　　3、对于创建过程比较复杂的对象的创建，目前spring其实有很多实现方式了，而FactoryBean只是其中一种，也许我们不会采用此种方式来实现实例对象的创建，但我们需要能够看懂此种方式，知道有这种实现方式；很多第三方都沿用了此种方式，我们去追源码的时候，很容易就能碰到；

　　4、相比普通bean的创建，FactoryBean的方式会在spring容器中多存在一个FactoryBean的实例，若想获取FactoryBean实例对象，只需要在FactoryBean的beanName加&即可；