BeanFactory、FactoryBean和ObjectFactory、ApplicationContext的入门理解

小灰灰 2024-03-31 11:16 53阅读 0赞

## 概述 ##

BeanFactory 和 FactoryBean 从字面意思可以知道：**Bean工厂、工厂Bean**

ObjectFactory

## BeanFactory ##

**以Factory结尾，表示它是一个工厂类(接口)，用于管理Bean的一个工厂**

`在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。`

**`负责配置、创建、管理Bean`**

**BeanFactory 本身只是一个接口**

**BeanFactory作为bean工厂，是spring的基础容器，它可以管理单例bean对象从创建到销毁的整个生命周期。**

### 源码 ###

public interface BeanFactory {
        
        String FACTORY_BEAN_PREFIX = "&";
    
        Object getBean(String var1) throws BeansException;
    
        <T> T getBean(String var1, Class<T> var2) throws BeansException;
    
        Object getBean(String var1, Object... var2) throws BeansException;
    
        <T> T getBean(Class<T> var1) throws BeansException;
    
        <T> T getBean(Class<T> var1, Object... var2) throws BeansException;
    
        <T> ObjectProvider<T> getBeanProvider(Class<T> var1);
    
        <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);
    
        boolean containsBean(String var1);
    
        boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
    
        boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
    
        boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;
    
        boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
    
        @Nullable
        Class<?> getType(String var1) throws NoSuch BeanDefinitionException;
    
        @Nullable
        Class<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;
    
        String[] getAliases(String var1);
    }

### 初始化顺序 ###

1.  创建配置文件
2.  装载配置文件
3.  启动 IoC 容器
4.  获取 Bean 实例（getBean()）

**通过 BeanFactory 启动 IoC 容器时，并不会初始化配置文件当中定义的 Bean，初始化的动作发生在第一次调用某个 Bean 的时候**

## FactoryBean ##

**以Bean结尾，表示它是一个Bean**

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

**它就是一个 Bean，而不是一个工厂**

FactoryBea`可以作为BeanFactory管理的bean对象`，同时BeanFactory对FactoryBean会做出特殊处理。如果FactoryBean被定义为spring的bean，则获取该bean时需要在beanName前面加上&符号，否则获取的bean是FactoryBean创建的对象。

### 源码 ###

public interface FactoryBean<T> {
        
        String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
    
        @Nullable
        T getObject() throws Exception;
    
        @Nullable
        Class<?> getObjectType();
    
        default boolean isSingleton() {
        
            return true;
        }
    }

1.  `getObject用来返回实例化后的对象`。
2.  `getObjectType用来返回对象的类型`。
3.  `isSingleton用来标识对象是否为单例的，这里默认为true，Spring会将实例化后的对象放入BeanFactory容器中`。
4.  `BeanFactory中获取的并不是这个类本身，而是FactoryBean的getBean()返回的对象`，如果要获取FactoryBean对象，请在id前面加一个&符号来获取：**通过转义符&来区分获取FactoryBean产生的对象和FactoryBean对象本身（FactoryBean实现类）**

## ObjectFactory ##

只是作为一个普通的对象工厂，也不作为spring管理的bean使用，BeanFactory不会对ObjectFactory做特殊处理。它主要是用作BeanFactory子类的内部类或者使用lambda表达式封装bean的创建过程。

spring对ObjectFactory的应用之一：将**创建对象的步骤封装到ObjectFactory中** 交给自定义的Scope来**选择是否需要创建对象来灵活的实现scope**

### 源码 ###

@FunctionalInterface
    public interface ObjectFactory<T> {
        
        T getObject() throws BeansException;
    }

`获取单例bean及从自定义作用域中获取bean均使用` ObjectFactory调用createBean方法封装了bean的创建。

### 与BeanFactory区别 ###

1.  **BeanFactory实现了ObjectFactory接口**
2.  **ObjectFactory仅仅关注一个或者一种类型Bean的查找,并且自身不具备依赖查找的能力**.
3.  **BeanFactory则提供单一类型,集合类型和层次性的依赖查找能力**.

[参考来源][Link 1]

### 用途 ###

这用于延迟查找的场景，`当得到 ObjectFactory 对象时，相当于 Bean 没有被创建，只有当 getObject() 方法时，才会触发 Bean 实例化等生命周期`。  
主要`用于暂时性地获取某个 Bean Holder 对象`，如果过早的加载，可能会引起一些意外的情况，**`比如当 Bean A 依赖 Bean B 时，如果过早地初始化 A，那么 B 里面的状态可能是中间状态，这时候使用 A 容易导致一些错误`**

## ApplicationContext ##

**ApplicationContext由BeanFactory派生而来；BeanFactory的许多功能需要编程实现，而在ApplicationContext中则可以通过配置的方式实现**；  
`ApplicationContext因此也称之为Spring上下文`。

可以理解成一个包含所有bean的容器，在单例模式下当有其他地方需要使用某一个bean的时候他就取出来注入到那个地方，所有在不同地方采用@Autowired注入的同一个类型的bean都是同一个bean。

### 源码 ###

import org.springframework.beans.factory.HierarchicalBeanFactory;
    import org.springframework.beans.factory.ListableBeanFactory;
    import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
    import org.springframework.core.env.EnvironmentCapable;
    import org.springframework.core.io.support.ResourcePatternResolver;
    import org.springframework.lang.Nullable;
    
    public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
        
        @Nullable
        String getId();
    
        String getApplicationName();
    
        String getDisplayName();
    
        long getStartupDate();
    
        @Nullable
        ApplicationContext getParent();
    
        AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
    }

### ApplicationContext.getBean ###

在@Configuration类中注入ApplicationContext后使用ApplicationContext.getBean(XXX.class)获取到的bean和@Autowired注入的XXX bean都是同一个。因为他们都是来自于同一个容器。

通过ApplicationContext的getBean方法来获取Spring容器中已初始化的bean。getBean一共有以下四种方法原型：[参考博客][Link 2]

1.  getBean(String name)：`参数name表示IOC容器中已经实例化的bean的id或者name,且无论是id还是name都要求在IOC容器中是唯一的不能重名。那么这种方法就是通过id或name去查找获取bean`
2.  getBean(Class< T > type)：`参数Class<T> type表示要加载的Bean的类型。如果该类型没有继承任何父类(Object类除外)和实现接口的话，那么要求该类型的bean在IOC容器中也必须是唯一的`，**getBean(String name)获得的对象需要类型转换而getBean(Class type)获得的对象无需类型转换。**
3.  getBean(String name, Class type)：`适合当类型不唯一时，再通过id或者name来获取bean`
4.  getBean(String name, Object\[\] args)：`本质还是通过bean的id或者name来获取bean,通过第二个参数Object[] args可以给bean的属性赋值，赋值的方式有两种：构造方法和工厂方法。但是通过这种方式获取的bean必须把scope属性设置为prototype，也就是非单例模式。`

### 与BeanFactory区别 ###

1.  ApplicationContext是BeanFactory的子类，并扩展了功能：`BeanFactory是Spring中比较原始的Factory，它不支持AOP、Web等Spring插件，而ApplicationContext不仅包含了BeanFactory的所有功能，还支持Spring的各种插件，还以一种面向框架的方式工作以及对上下文进行分层和实现继承。`
2.  初始化：`BeanFactory在初始化容器时，并未实例化 Bean`，`ApplicationContext在初始化应用上下文时，会实例化所有单实例的 Bean，所以相对来说，占用空间较大、初始化时间会比 BeanFactory 稍长`
3.  延迟加载：`BeanFactroy只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化`，`ApplicationContext在自身初始化的时候，就会一次性创建了所有的Bean`
4.  手动、自动注册：`BeanFactory需要手动注册，而ApplicationContext则是自动注册`

ApplicationContext扩展了很多其他功能：

1.  AOP
2.  国际化
3.  资源管理
4.  事件
5.  注解
6.  等等
7.  我们开发直接用的肯定是 ApplicationContext 而不是 BeanFactory

## 结论 ##

BeanFactory就是对象工厂，用于实例化和保存对象。

FactoryBean是一个工厂对象，用于实例化创建过程比较复杂的对象。

ObjectFactory是某个特定的工厂，用于在项目启动时，延迟实例化对象，解决循环依赖问题。

`BeanFactory和ObjectFactory`:

1.  **BeanFactory和ObjectFactory都提供依赖查找的能力**
2.  `BeanFactory实现了ObjectFactory接口`
3.  `ObjectFactory仅仅关注一个或者一种类型Bean的查找,并且自身不具备依赖查找的能力`.
4.  `BeanFactory则提供单一类型,集合类型和层次性的依赖查找能力`.

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

ObjectFactory和FactoryBean

1.  在将`给依赖注入列表注册一个ObjectFactory类型的对象，在注入过程中会调用objectFactory.getObject()来创建目标对象注入进去`
2.  是一个普通的工厂对象接口，对于spring在doGetBean处的使用时，在于创建对象的过程由框架通过ObjectFactory定义，而创建的时机交给拓展接口Scope
3.  `通过FactoryBean你可以控制对象如何创建，而ObjectFactory借助Scope接口自定义scope你可以控制对象的创建时机`

[参考来源][Link 3]

[Link 1]: https://juejin.cn/post/6850418113864564744
[Link 2]: https://blog.csdn.net/qq_23927391/article/details/80625578
[Link 3]: https://cloud.tencent.com/developer/article/1497577