一、FactoryBean源码解读

FactoryBean<T> 是 Spring 框架 beans.factory包中的一个接口，从字面意思可以理解为工厂bean，它是干什么的，类名上的泛型又是指什么，有什么作用？

注释看不懂没关系，先看一下它有哪些方法。

public interface FactoryBean<T> {
    // 获取实例
    @Nullable
    T getObject() throws Exception;
    // 获取实例的class类型
    @Nullable
    Class<?> getObjectType();
    // 实例默认为单例
    default boolean isSingleton() {
        return true;
    }
}

方法看完了，还是不知道它能干嘛，继续看它的子类。

子类真多，一个屏幕放不下，找几个看看。

二、FactoryBean的子类

先看两个简单的实现类：

1、AuthenticationManagerFactoryBean类

AuthenticationManagerFactoryBean是spring-boot-starter-security 框架中的一个类，这个类实现了FactoryBean<AuthenticationManager>, BeanFactoryAware 两个接口的功能。

BeanFactoryAware 接口在《Spring框架Aware接口的作用和应用》一文中已经介绍过，它是用于在当前类初始化时获取 BeanFactory 接口以供当前类使用的。

FactoryBean<AuthenticationManager>的泛型位置放置了一个类AuthenticationManager。

AuthenticationManagerFactoryBean实现了FactoryBean接口中3个方法

在getObject() 方法中创建了AuthenticationManager实例并返回。

在该方法的最后一行代码可以看出，AuthenticationManager的实例是交给ProviderManager 对象管理的。

因此，在getObjectType()方法中返回的是ProviderManager对象的class。

在 isSingleton()方法中返回的依旧是单例模式。

从以上代码的分析，我们可以得出一个结论，AuthenticationManagerFactoryBean类是用来创建AuthenticationManager对象实例的工厂bean类。

2、CronTriggerFactoryBean类

CronTriggerFactoryBean是Spring框架定时任务 org.springframework.scheduling.quartz 包中的一个类，这个类实现了FactoryBean<CronTrigger>, BeanNameAware, InitializingBean 3个接口的功能。

BeanNameAware 是用于在当前类初始化时获取当前类的bean名称的。

InitializingBean 接口是用于重写初始化方法的。

FactoryBean<CronTrigger>的泛型位置放置了一个类CronTrigger。 

CronTrigger是定时任务的表达式对象。 

在重写的 afterPropertiesSet() 初始化方法中，new 了一个 CronTriggerImpl对象并返回。

CronTriggerImpl位于定时任务框架 org.quartz中，它是CronTrigger的实现类。

接下来就是FactoryBean三个方法的实现：

getObject() 方法中直接初始化方法中创建的cronTrigger变量。

getObjectType()方法返回的是CronTrigger的class，它是CronTriggerImpl的超类。

isSingleton()方法中返回的是单例模式。

从以上代码的分析，我们也可以得出一个结论，CronTriggerFactoryBean类是用来创建CronTriggerFactory对象实例的工厂bean类。

再来看两个复杂一些的抽象类。

3、AbstractFactoryBean<T>抽象类

AbstractFactoryBean<T>实现了FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean 5个接口。

FactoryBean<T>泛型位置的参数还是泛型。

BeanClassLoaderAware接口是用于在当前类初始化时获取类加载对象ClassLoader的。

BeanFactoryAware接口是用于在当前类初始化时获取BeanFactory的。

InitializingBean 接口是用于重写初始化方法的。

DisposableBean 接口是用于重写销毁方法的。

在初始化方法中，如果是单例则进行实例化：

protected abstract T createInstance() throws Exception;
@Override
@Nullable
public abstract Class<?> getObjectType();
@Override
public final T getObject() throws Exception {
    if (isSingleton()) {
        return (this.initialized ? this.singletonInstance : getEarlySingletonInstance());
    }
    else {
        return createInstance();
    }
}

实例化是个抽象方法，由其子类实现具体实例化逻辑。

getObjectType()也是抽象方法，由其子类实现。

getObject()是个final方法，子类不能更改，如果是单例则返回单例实例，否则每次调用返回一个新的实例。

在AbstractFactoryBean抽象类中，我们最关心的FactoryBean中的2个方法，一个由其子类实现，一个由抽象类实现。不管是子类还是抽象类，目的都是一样的。

4、ListFactoryBean类

ListFactoryBean是AbstractFactoryBean<List<Object>>的子类，通过这个头可以看出它是创建一个List集合的。

在getObjectType()方法中，直接返回List集合的class。

在createInstance()方法中，实现了List集合的实例化逻辑。

还有很多抽象类、实现类，我们就不举例了。

从以上3个类我们可以推断出，FactoryBean就是一个创建和管理bean实例的特殊工厂bean。

FactoryBean的子类很多，但是子接口只有一个，我们也看下。

三、SmartFactoryBean子接口和应用

1、SmartFactoryBean源码解读

SmartFactoryBean接口扩展了FactoryBean接口

public interface SmartFactoryBean<T> extends FactoryBean<T> {

    // 是否为原型，默认false
    default boolean isPrototype() {
        return false;
    }

    // 是否提前初始化，默认false
    default boolean isEagerInit() {
        return false;
    }
}

这个接口增加了两个方法：

isPrototype()方法，判断当前要创建的bean实例是否是原型。

isEagerInit()方法，判断当前要创建的bean实例是否提前实例化。

2、FactoryBean和SmartFactoryBean的应用比较

1）定义一个bean

public class MyBean2{
    
    public MyBean2() {
        System.out.println("1、实例化 MyBean2");
    }
   
    public void fun(){
        System.out.println("2、调用  MyBean2 的 fun 方法");
    }
}

2）把MyBean2对象封装到MyBean2FactoryBean中

@Component
public class MyBean2FactoryBean implements SmartFactoryBean<MyBean2>{
    
    private MyBean2 myBean2;
    
    @Override
    public MyBean2 getObject() throws Exception {
        if(myBean2 == null){
            myBean2 = new MyBean2();
        }
        return myBean2;
    }

    @Override
    public Class<?> getObjectType() {
        return MyBean2.class;
    }
    
    @Override
    public boolean isEagerInit() {
        return true;
    }
}

测试FactoryBean接口时，可以把SmartFactoryBean替换成FactoryBean，并把isEagerInit注释掉。

3）测试代码

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.beans.factory.SmartFactoryBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;
/**
 * SmartFactoryBean接口演示代码,是否提前实例化的验证
 * @author 
 * @Description
 *
 */
public class SpringApp5 {
    
    public static void main(String[] args) {   
        
       AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyBean2FactoryBean.class);
      
       MyBean2FactoryBean myBean2FactoryBean = context.getBean(MyBean2FactoryBean.class);
       try {
           System.out.println("还没有调用呢");
            MyBean2 myBean = myBean2FactoryBean.getObject();
            myBean.fun();
       } catch (Exception e) {
            e.printStackTrace();
       }
       context.close();
   }
}

当我们使用 FactoryBean 的时候，Spring 在实例化 Bean 的时候，实例化的是MyBean2FactoryBean 工厂 Bean，MyBean2则是在工厂 Bean中实例化的。

当把工厂bean更改为FactoryBean的时候，运行结果如下：

Creating shared instance of singleton bean 'myBean2FactoryBean'
还没有调用呢
1、实例化 MyBean2
4、调用  MyBean2 的 fun 方法

当把工厂bean更改为SmartFactoryBean的时候，并设置提前实例化时，运行结果如下：

Creating shared instance of singleton bean 'myBean2FactoryBean'1、实例化 MyBean2还没有调用呢4、调用  MyBean2 的 fun 方法

当我们把 isEagerInit() 返回 true时，实例化提前了，没有使用就被实例化了。

最后总结

FactoryBean<T>是一个特殊的bean，用于创建和管理自定义 Bean 实例的工厂bean，其中类名中的泛型就是要创建Bean的类名，如果子类是一个抽象类，那么具体的创建实例过程会延伸到其子类。

FactoryBean<T>定义了一种创建 Bean 的方式，允许在 Bean 的创建过程中进行更多的自定义操作。通过实现 FactoryBean 接口，我们可以创建复杂的 Bean 实例，或者在 Bean 实例化之前进行一些额外的逻辑处理，比如重写初始化方法的InitializingBean等等。

在看源码时，如果看到某个类名是：XxxxFactoryBean，我们就能在瞬间知道这个类是创建Xxxx实例的工厂bean。如果还带有泛型XxxxFactoryBean<T>，就说明这是一个抽象类，具体的创建实例的过程在其子类中。