BeanFactory和FactoryBean和ObjectFactory

Spring中的BeanFactory和FactoryBean（以及它和ObjectFactory的区别）的区别

问题来源

开始重视这个问题，源自一次阿里巴巴的二面面试题：说说你对 Spring 中 BeanFactory 的理解，它和 FactoryBean 有什么区别呢？

直接区别

直面意思：Bean 工厂、工厂 Bean

BeanFactory，以 Factory 结尾，表示它是一个工厂类 (接口)，用于管理 Bean 的一个工厂。在 Spring 中，BeanFactory 是 IOC 容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

FactoryBean 以 Bean 结尾，表示它是一个 Bean，不同于普通 Bean 的是：它是实现了 FactoryBean 接口的 Bean，根据该 Bean 的 ID 从 BeanFactory 中获取的实际上是 FactoryBean 的 getObject() 返回的对象，而不是 FactoryBean 本身，如果要获取 FactoryBean 对象，请在 id 前面加一个 & 符号来获取。

[TOC]

BeanFacotry

BeanFactory 定义了 IOC 容器的最基本形式，并提供了 IOC 容器应遵守的的最基本的接口，也就是 Spring IOC 所遵守的最底层和最基本的编程规范。

Spring 代码中，BeanFactory 只是个接口，并不是 IOC 容器的具体实现，但是 Spring 容器给出了很多种实现，如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext 等，都是附加了某种功能的实现。

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
public interface BeanFactory {
	
	
	String FACTORY_BEAN_PREFIX = "&";
	
	
	Object getBean(String name) throws BeansException;
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	Object getBean(String name, Object... args) throws BeansException;
	<T> T getBean(Class<T> requiredType) throws BeansException;
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	
	boolean containsBean(String name);

   
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	
	
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	String[] getAliases(String name);

}

在 Spring 中，所有的 Bean 都是由 BeanFactory(也就是 IOC 容器) 来进行管理的。但对 FactoryBean 而言，这个 Bean 不是简单的 Bean，而是一个能生产或者修饰对象生成的工厂 Bean, 它的实现与设计模式中的工厂模式和修饰器模式类似

BeanFacotry 是 spring 中比较原始的 Factory。如 XMLBeanFactory 就是一种典型的 BeanFactory。原始的 BeanFactory 无法支持 spring 的许多插件，如 AOP 功能、Web 应用等。ApplicationContext 接口, 它由 BeanFactory 接口派生而来，

ApplicationContext 包含 BeanFactory 的所有功能，通常建议比 BeanFactory 优先

ApplicationContext 以一种更向面向框架的方式工作以及对上下文进行分层和实现继承，ApplicationContext 包还提供了以下的功能：

  • MessageSource, 提供国际化的消息访问
  • 资源访问，如 URL 和文件
  • 事件传播
  • 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的 web 层;
常见的初始化例子
1
2
Resource resource = new FileSystemResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
1
2
ClassPathResource resource = new ClassPathResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
1
2
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
BeanFactory factory = (BeanFactory) context;

分析了从 BeanFactory 到 ConfigurableListableBeanFactory 接口的概要功能：

  • BeanFactory–>SpringIoC容器顶级接口,定义了对单个bean的获取,对bean的作用域判断,获取bean类型,获取bean别名的功能
  • ListableBeanFactory–>扩展了BeanFactory接口,并提供了对bean的枚举能力
  • HierarchicalBeanFactory–>扩展了BeanFactory接口,并提供了访问父容器的能力
  • AutowireCapableBeanFactory–>扩展了BeanFactory接口,并提供了自动装配能力
  • ConfigurableBeanFactory–>扩展了HierarchicalBeanFactory,并提供了对容器的配置能力
  • ConfigurableListableBeanFactory–>扩展了ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory接口,并提供了忽略依赖,自动装配判断,冻结bean的定义,枚举所有bean名称的功能

FactoryBean

这是个特殊的 Bean 他是个工厂 Bean，可以产生 Bean 的 Bean

一般情况下，Spring 通过反射机制利用 的 class 属性指定实现类实例化 Bean，在某些情况下，实例化 Bean 过程比较复杂，如果按照传统的方式，则需要在 中提供大量的配置信息。

配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring 为此提供了一个 org.springframework.bean.factory.FactoryBean 的工厂类接口，用户可以通过实现该接口定制实例化 Bean 的逻辑。

FactoryBean 接口对于 Spring 框架来说占用重要的地位，Spring 自身就提供了 70 多个 FactoryBean 的实现。

第三方框架要继承进 Spring，往往就是通过实现 FactoryBean 来集成的。比如 MyBatis 的 SqlSessionFactoryBean、RedisRepositoryFactoryBean、EhCacheManagerFactoryBean 等等

当然，我们也可以自己手动来实现一个 FactoryBean，用来代理一个对象。从而可以很方便的在对象前后都做出对应的操作，比如输出一句日志：

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
public class MyFactoryBean implements FactoryBean<Object> {

       private static final Logger logger = LoggerFactory.getLogger(MyFactoryBean.class);
    private Class<?> interfaceClazz; 
    private Object target; 
    private Object proxyObj;

    public MyFactoryBean(Class<?> interfaceClazz, Object target) {
        this.interfaceClazz = interfaceClazz;
        this.target = target;
        this.proxyObj = Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                new Class[]{interfaceClazz}, 
                (proxy, method, args) -> {
                    logger.debug("invoke method......" + method.getName());
                    logger.debug("invoke method before......" + System.currentTimeMillis());
                    Object result = method.invoke(target, args);
                    logger.debug("invoke method after......" + System.currentTimeMillis());

                    return result;
                });
    }

    @Override
    public Object getObject() {
        return proxyObj; 
    }

    @Override
    public Class<?> getObjectType() {
        return proxyObj == null ? Object.class : proxyObj.getClass();
    }

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

有了这个工厂 Bean，我们出去的 Bean 都将是代理 Bean。 main 方法单元测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args) {
        MyFactoryBean factoryBean = new MyFactoryBean(UserService.class, new UserServiceImpl());

        UserService userService = (UserService) factoryBean.getObject();
        System.out.println(userService.sayHello());
    }

    private interface UserService {
        String sayHello();
    }

    private static class UserServiceImpl implements MyFactoryBean.UserService {

        @Override
        public String sayHello() {
            return "hello world";
        }
    }

控制台输出：

1
2
3
4
16:17:05.330 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method......sayHello
16:17:05.334 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method before......1545121025334
16:17:05.334 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method after......1545121025334
hello world

ObjectFactory

通过接口内容来看，两者都是属于工厂模式用来创建对象使用的。 啥都不说，先看个例子吧：

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
@Configuration
public class RootConfig {

    @Bean
    public FactoryBean myFactoryBean() {
        return new MyFactoryBean();
    }

    @Bean
    public ObjectFactory myObjectFactory() {
        return new MyObjectFactory();
    }

    public static class MyFactoryBean implements FactoryBean<Daughter> {

        @Override
        public Daughter getObject() throws Exception {
            return new Daughter();
        }

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

    public static class MyObjectFactory implements ObjectFactory<Son> {

        @Override
        public Son getObject() throws BeansException {
            return new Son();
        }
    }

}


    @Autowired
    private ApplicationContext applicationContext;
    @Autowired
    private RootConfig.MyFactoryBean myFactoryBean;
    @Autowired
    private RootConfig.MyObjectFactory myObjectFactory;
    @Autowired
    private Daughter daughter;
    
    

    @ResponseBody
    @GetMapping("/hello")
    public String helloGet() throws Exception {
        
        System.out.println(applicationContext); 
        System.out.println(applicationContext.getParent()); 

        
        System.out.println(myFactoryBean); 
        
        System.out.println(myObjectFactory.getObject()); 
        System.out.println(daughter); 

        
        System.out.println(myFactoryBean.getObject() == myFactoryBean.getObject()); 
        System.out.println(myObjectFactory.getObject() == myObjectFactory.getObject()); 
        return "hello...Get";
    }

从上面的现象打印值的不同，可以看出FactoryBean和ObjectFactory最直接的区别。上面已经介绍了 FactoryBean，这里简单先介绍下

ObjectFactory：

ObjectFactory 则只是一个普通的对象工厂接口。在查看 AbstractBeanFacotry 的 doGetBean(…) 部分的源码时，可以看到 spring 对 ObjectFactory 的应用之一就是，将创建对象的步骤封装到 ObjectFactory 中 交给自定义的 Scope 来选择是否需要创建对象来灵活的实现 scope

区别： FactoryBean的着重于自定义创建对象过程，由 BeanFactory 通过 FactoryBean 来获取目标对象，而如果是 isSingleton 返回 true 的话，spring 会利用单例缓存来缓存通过 FactoryBean 创建的对象。

而ObjectFactory就是一个普通的工厂对象接口，对于 spring 在 doGetBean 处的使用时，在于创建对象的过程由框架通过 ObjectFactory 定义，而创建的时机交给拓展接口 Scope，除此之外 ObjectFactory 就是一个普通的接口 此外在将给依赖注入列表注册一个 ObjectFactory 类型的对象，在注入过程中会调用objectFactory.getObject()来创建目标对象注入进去。（如beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());）

简单来说就是通过 FactoryBean 你可以控制对象如何创建，而 ObjectFactory 借助 Scope 接口自定义 scope 你可以控制对象的创建时机

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！