Spring中接口 FactoryBean 作用

简述：

Spring 容器中有两种bean ：

• 普通 Bean: Spring 使用反射机制，利用Class 属性来实例化 Bean，放置到容器中
• 工厂Bean （实现 FactoryBean）: 当 Bean 的实例化过程比较复杂是，如果按照传统的方式（XML），则需要提供大量的配置信息， 采用编码的方式创建更加优雅，用户可以通过实现 org.Springframework.bean.factory.FactoryBean 定制 bean 实例化过程

FactoryBean接口对于Spring框架来说占有重要的地位，Spring 自身就提供了很多FactoryBean的实现。它们隐藏了实例化一些复杂bean的细节，给上层应用带来了便利。

从Spring 3.0 开始， FactoryBean开始支持泛型，即接口声明改为FactoryBean 的形式。

Spring 官方文档中对 FactoryBean 介绍：

官方地址：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-extension-factorybean

You can implement the org.springframework.beans.factory.FactoryBean interface for objects that are themselves factories.

The FactoryBean interface is a point of pluggability into the Spring IoC container’s instantiation logic. If you have complex initialization code that is better expressed in Java as opposed to a (potentially) verbose amount of XML, you can create your own FactoryBean, write the complex initialization inside that class, and then plug your custom FactoryBean into the container.

The FactoryBean interface provides three methods:

• T getObject(): Returns an instance of the object this factory creates. The instance can possibly be shared, depending on whether this factory returns singletons or prototypes.
• boolean isSingleton(): Returns true if this FactoryBean returns singletons or false otherwise. The default implementation of this method returns true.
• Class getObjectType(): Returns the object type returned by the getObject() method or null if the type is not known in advance.

The FactoryBean concept and interface are used in a number of places within the Spring Framework. More than 50 implementations of the FactoryBean interface ship with Spring itself.

When you need to ask a container for an actual FactoryBean instance itself instead of the bean it produces, prefix the bean’s id with the ampersand symbol (&) when calling the getBean() method of the ApplicationContext. So, for a given FactoryBean with an id of myBean, invoking getBean(“myBean”) on the container returns the product of the FactoryBean, whereas invoking getBean(“&myBean”) returns the FactoryBean instance itself.

简述：

1. Spring 提供了 FactoryBean接口 供我们实现，用于创建复杂的 Bean 对象， 避免复杂的XML配置
2. FactoryBean 中提供三个 方法：
   • T getObject() ： 返回该实现真正创建的 Bean， 非 FactoryBean 本身
   • boolean isSingleton() : 决定 getObject() 是单例 还是 原型（多例），默认是单例
   • Class getObjectType() ： 返回 getObject() 对象 Class
3. Spring 框架内部 也有50多个关于 FactoryBean 的实现；
4. 获取对象
   • 当获取 FactoryBean 创建的时对象， 可以使用 getBean(“myBean”);
   • 当获取 FactoryBean 对象时，需使用 getBean(“&myBean”)

实战

MySqlSession类：后续交与 MySqlSessionFactory 初始化

package com.lot.learn.spring.factorybean;

import lombok.Data;

@Data
public class MySqlSession {

    private Long id;

    public MySqlSession(Long id) {
        this.id = id;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

MySqlSessionFactory 实现 FactoryBean， 用于创建 MySqlSession

package com.lot.learn.spring.factorybean;

import lombok.Data;
import org.springframework.beans.factory.FactoryBean;

@Data
public class MySqlSessionFactory implements FactoryBean {

    private Long id;

    private Long sessionId;


    @Override
    public MySqlSession getObject() {
        return new MySqlSession(sessionId);
    }

    @Override
    public Class getObjectType() {
        return MySqlSession.class;
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

spring-factorybean.xml

    
        
            
            
        
    

1
2
3
4
5
6
7
8
9
10
11
12
13

Maven 配置 dependencies：

    
      org.springframework
      spring-context
      5.2.9.RELEASE
    

    
      org.springframework
      spring-jdbc
      5.2.9.RELEASE
    

    
      org.springframework
      spring-test
      5.2.9.RELEASE
    

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

测试类： TestFactoryBean

package factorybean;

import com.lot.learn.spring.factorybean.MySqlSession;
import com.lot.learn.spring.factorybean.MySqlSessionFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:spring-factorybean.xml" })
public class TestFactoryBean {


    @Autowired
    private MySqlSessionFactory userFactory1;

    @Autowired
    private MySqlSession mySqlSession1;

    @Autowired
    private ApplicationContext context;

    @Test
    public void test() {
        System.out.println("factory.getId() = " + userFactory1.getId());
        // 我们并没有配置 MySqlSession 仍可以注入
        System.out.println("mySqlSession.getId() = " + mySqlSession1.getId());

        // by Type
        MySqlSession mySqlSession2 = context.getBean(MySqlSession.class);
        MySqlSessionFactory userFactory2 = context.getBean(MySqlSessionFactory.class);

        // by name
        MySqlSession mySqlSession3 = (MySqlSession) context.getBean("mySqlSession");
        MySqlSessionFactory userFactory3 = (MySqlSessionFactory) context.getBean("&mySqlSession");

		// 以下都是 true
        System.out.println("mySqlSession1 == mySqlSession2 :" + (mySqlSession1 == mySqlSession1));
        System.out.println("userFactory1 == userFactory2 :" + (userFactory1 == userFactory1));

        System.out.println("mySqlSession2 == mySqlSession3 :" + (mySqlSession2 == mySqlSession3));
        System.out.println("userFactory2 == userFactory3 :" + (userFactory2 == userFactory3));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

测试类执行结果：

根据打印结果看， 已经验证上述问题

factory.getId() = 9999
mySqlSession.getId() = 1
mySqlSession1 == mySqlSession2 :true
userFactory1 == userFactory2 :true
mySqlSession2 == mySqlSession3 :true
userFactory2 == userFactory3 :true
1
2
3
4
5
6

代替方案：

现阶段使用 FactoryBean 创建对象的使用习惯越来越少， 有很多其他更方便创建方式：

• @Configuration和@Bean注解配合，也可以用来创建bean，和FactoryBean的作用基本相同。但是@Bean功能更强大一些，可以支持懒加载，设置作用域等。
• @Component 也可

End !!!