通过实现 FactoryBean 接口注入 Bean

原文：如何使用 Spring 的 FactoryBean 接口

参考：ChatGPT

在 Spring 容器中有两类的 Bean，一类是普通的 Bean，一类是工厂 Bean。这两种 Bean 都是被 Spring 的容器进行管理的。

FactoryBean是 Spring 提供的一个接口，用于定义自定义的工厂 Bean。使用FactoryBean能够在 Spring 中更灵活、便捷地创建和管理一些有着复杂构造逻辑的类对象。

如何使用

首先我们看一下FactoryBean接口：

public interface FactoryBean<T> {

	T getObject() throws Exception;

	Class<?> getObjectType();

	boolean isSingleton();

}

这三个方法的作用分别是：

• getObject：返回工厂创建的对象实例。

• getObjectType：返回工厂生产的对象的类型。

• isSingleton：表示被工厂创建的实例是否是单例。

  • 返回 true，getObject总是返回同一个共享的实例，该对象会被BeanFactory缓存起来。
  • 返回 false，getObject返回独立的实例，一般情况下返回 true 即可。

现在让我们开始使用，创建一个UserFactory用来创建实例User：

@Data
public class User {
    private String name;
    private Integer age;
}

UserFactory工厂类：

// 自定义工厂类实现 FactoryBean 接口
public class UserFactory implements FactoryBean<User> {
    private String name;
    private Integer age;
    
    @Override
    public User getObject() throws Exception {
        // 在这里进行自定义的对象创建逻辑
        return new User(name,age);
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }

    @Override
    public boolean isSingleton() {
        // 这里指定创建的对象是否为单例
        return true;
    }
}

添加配置类将UserFactory加入到容器中：

@Configuration
public class FactoryBeanAppConfig {

    @Bean
    public UserFactory userFactory(){
        UserFactory userFactory = new UserFactory();
        userFactory.setAge(10);
        userFactory.setName("Grace");
        return userFactory;
    }

}

接下来我们就能通过UserFactory工厂类进行创建User了：

@SpringBootTest
public class BeanFactoryTest {

    @Autowired
    private User user;

    @Test
    public void testBeanFactory(){
        assertEquals(new Integer(10),user.getAge());
        assertEquals("Grace",user.getName());
    }
}

此时我们 Debug 也能看到其我们自动注入的User类就是通过UserFactory创建的实例：

加载顺序

有时候我们需要在getObject方法执行之前执行一些动作，例如资源配置检查之类，此时我们可以使用@PostConstruct注解在方法上，那么此方法就会在执行getObject()方法执行之前先执行。

我们在UserFactory工厂类中增加@PostConstruct注解的方法，并且增加打印日志。

@Data
public class UserFactory implements FactoryBean<User> {
    private String name;
    private Integer age;

    @Override
    public User getObject() throws Exception {
        System.out.println("getObject Begin");
        return new User(name,age);
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    @PostConstruct
    public void Initialize(){
        System.out.println("Initialize Begin");
    }
}

此时我们运行就会发现执行顺序：

Initialize Begin
getObject Begin

AbstractFactoryBean 类

Spring 为我们提供了一个抽象类AbstractFactoryBean为我们简化了操作。我们直接继承此类就能更加方便地创建单例或者非单例的实体类了。接下来我们就演示一下如何创建单例和非单例的类。首先先创建两个工厂，一个工厂SingleUserFactory负责创建单例，一个工厂NonSingleUserFactory负责创建非单例。

SingleUserFactory类：

@Data
public class SingleUserFactory extends AbstractFactoryBean<User> {

    private String name;
    private Integer age;

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }

    @Override
    protected User createInstance() throws Exception {
        return new User(name,age);
    }
}

NonSingleUserFactory类：

@Data
public class NonSingleUserFactory extends AbstractFactoryBean<User> {

    private String name;
    private Integer age;
	
    // 设置为非单例模式
    public NonSingleUserFactory(){
        setSingleton(false);
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }

    @Override
    protected User createInstance() throws Exception {
        return new User(name,age);
    }
}

并且在配置类中配置这两个工厂 Bean：

    @Bean(name = "singleUser")
    public SingleUserFactory getSingle(){
        SingleUserFactory singleUserFactory = new SingleUserFactory();
        singleUserFactory.setAge(12);
        singleUserFactory.setName("Single");
        return singleUserFactory;
    }

    @Bean(name = "nonSingleUser")
    public NonSingleUserFactory getNonSingle(){
        NonSingleUserFactory nonSingleUserFactory = new NonSingleUserFactory();
        nonSingleUserFactory.setAge(12);
        nonSingleUserFactory.setName("NonSingle");
        return nonSingleUserFactory;
    }

在测试类中测试如下：

public class SingleBeanFactoryTest extends BaseTest{
    @Resource(name = "singleUser")
    private User user1;
    @Resource(name = "singleUser")
    private User user2;
    @Resource(name = "nonSingleUser")
    private User user3;
    @Resource(name = "nonSingleUser")
    private User user4;

    @Test
    public void testSingleBean(){
        System.out.println(user1 == user2);
        System.out.println(user3 != user4);
    }
}

true
true

从结果中我们可以看到SingleUserFactory工厂类创建的都是单例的对象，而NonSingleUserFactory创建的都是非单例的对象。如果需要创建单例那么可以不设置singleton的值，因为他是默认为true的。

扩展：Spring 拓展接口之 FactoryBean，我们来看看其源码实现、Spring 中 BeanFactory 与 FactoryBean 的区别