1 FactoryBean和BeanFactory区别

在 Spring 中，有两个接口：BeanFactory 和 FactoryBean 因为名字相近很容易被混淆。那他们之间有什么区别呢

1.1 BeanFactory

1.1.1 定义

BeanFactory，以Factory结尾，表示它是一个工厂类(接口)， 它负责生产和管理bean的一个工厂
BeanFactory定义了IOC容器的最基本形式，并提供了IOC容器应遵守的的最基本的接口，也就是Spring IOC所遵守的最底层和最基本的编程规范。
在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖

在Spring代码中，BeanFactory只是个接口，并不是IOC容器的具体实现，但是Spring容器给出了很多种实现，比如：

• DefaultListableBeanFactory。
• XmlBeanFactory
• ApplicationContext

这些实现类从不同的维度对 beanFactory 进行了扩展。

1.1.2 beanFactory 源码

package org.springframework.beans.factory;
import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;

public interface BeanFactory {

    factoryBean 的转义标识符。（具体用法后面有介绍）
    String FACTORY_BEAN_PREFIX = "&";
        
    根据 name 从容器中拿对应的 bean
    Object getBean(String name) throws BeansException;
    
    根据 name 和 type 从容器中拿对应的 bean，要对 bean 的类型做校验。
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    
    在容器中能否找到与 name 匹配的 bean 或者 beanDefinition。
    boolean containsBean(String name);
    
    判断 name 对对应的 bean 是不是 单例。
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    判断 name 对应的 bean 与指定的类型是否匹配。
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    
    boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    
    根据 name 获取对应的 bean 的类型。
    @Nullable
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    
    根据 name 获取对应 bean 的 别名。
    String[] getAliases(String name);
}

1.1.3 BeanFactory体系结构

BeanFactory 的类体系结构

• BeanFactory: 接口位于类结构树的顶端， 它最主要的方法就是getBean(StringbeanName)，该方法从容器中返回特定名称的Bean，BeanFactory 的功能通过其他的接口得到不断扩展。
• ListableBeanFactory：该接口定义了访问容器中Bean 基本信息的若干方法，如查看Bean 的个数、获取某一类型Bean 的配置名、查看容器中是否包括某一Bean 等方法；
• HierarchicalBeanFactory：父子级联IoC 容器的接口，子容器可以通过接口方法访问父容器；
• ConfigurableBeanFactory：是一个重要的接口，增强了IoC 容器的可定制性，它定义了设置类装载器、属性编辑器、容器初始化后置处理器等方法；
• AutowireCapableBeanFactory：定义了将容器中的Bean 按某种规则（如按名字匹配、按类型匹配等）进行自动装配的方法；
• SingletonBeanRegistry：定义了允许在运行期间向容器注册单实例Bean 的方法；
• BeanDefinitionRegistry：Spring 配置文件中每一个<bean>节点元素在Spring 容器里都通过一个BeanDefinition对象表示，它描述了Bean的配置信息。而BeanDefinitionRegistry 接口提供了向容器手工注册BeanDefinition 对象的方法

1.1.4 使用场景

使用场景：

• 通过 名字或类型从容器中获取 bean。
• 判断容器中是否包含指定的 bean。
• 判断 bean 是不是单例。

1.2 FactoryBean

一般情况下，Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean，但在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在<bean>中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。

首先 FactoryBean 是一个 bean，但它又不仅仅是个 bean。它是一个可以 创建 或 修饰 其他对象的工厂 bean，这跟设计模式中的工厂模式或者装饰模式很相似，它可以创建除自身以外的其他对象

1.2.1 FactoryBean源码

public interface FactoryBean<T> {   
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";   
    
    从 factory 中获取 bean
    @Nullable
    T getObject() throws Exception;
    从 beanFactory 中获取类型
    
    @Nullable
    Class<?> getObjectType();
    
    判断是单例？
    default boolean isSingleton() {
        return true;
    }    
}

从上面的接口可以看出，FactoryBean 有工厂的味道。也就是说，如果一个 A类实现了 FactoryBean 接口，那么 类A 就变成了 A工厂。根据 A 的名称获得的实际上是工厂调用 getObject() 返回的对象, 而不是 A工厂自己。如果想获得 A工厂自己的实例，需要添加 & 前缀。

1.2.2 用个demo解释下

这是一个简单的 FactoryBean 的使用

package com.example.demo.domian;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

@Component
public class MyFactoryBean implements FactoryBean { 
  // 保存一句话，用来区分不同的对象。  
  private String message;
  // 无参构造器。
  public MyFactoryBean() {
      // 意思是：当前对象是 MyFactoryBean 的对象。
    this.message = "object of myFactoryBeanSelf";
  }
  // 有参构造器。
  public MyFactoryBean(String message) {
    this.message = message;
  }
  // 获取 message。
  public String getMessage() {
    return this.message;
  }

  @Override
  /**
   *  这个方法在执行时创建了新的 MyFactoryBean 类型的对象。
   *  这里继续沿用了 MyFactoryBean 类型，但是可以是别的类型
   *  比如：Person、Car、等等。
   */
  public Object getObject() throws Exception {
      // 意思是：当前对象是 MyFactoryBean 的 getObject() 创建的。
    return new MyFactoryBean("object from getObject() of MyFactoryBean");
  }

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

测试内容很简单，MyFactoryBean 被 @Component 注解了，当启动SpringBoot程序的时候，会为 MyFactoryBean 构建 bean 并且保存到容器中。我们要测试的就是用 类: MyFactoryBean 的 名字: myFactoryBean 去容器中拿 bean，看拿到的结果是什么？

package com.example.demo.domian;


import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = com.example.demo.domian.MyFactoryBean.class)
class MyFactoryBeanTest {
  @Autowired
  private ApplicationContext context;

  @Test
  public void test() {
    // 第一次用 myFactoryBean 去拿。  
    MyFactoryBean myBean1 = (MyFactoryBean) context.getBean("myFactoryBean");
    System.out.println("myBean1 = " + myBean1.getMessage());
    // 第二次用 &myFactoryBean 去拿。  
    MyFactoryBean myBean2 = (MyFactoryBean) context.getBean("&myFactoryBean");
    System.out.println("myBean2 = " + myBean2.getMessage());、
    // 判断两次拿到的对象是不是一样的？    
    System.out.println("myBean1.equals(myBean2) = " + myBean1.equals(myBean2));
  }
}
测试结果：
myBean1 = object from getObject() of MyFactoryBean
myBean2 = object of myFactoryBeanSelf
myBean1.equals(myBean2) = false

结果很明显：
第一次使用 myFactoryBean 去容器中拿，实际上是容器中 MyFactorybean的bean 调用了 getObject()方法，并将结果返回。
第二次使用 &myFactoryBean 去容器中拿，才是真正拿到了 MyFactorybean 的 bean。
两次拿出来的对象当然是不一样的。
而 & 就是用于区分到底拿谁的的前缀。

1.2.3 使用场景

为什么需要 FactoryBean ，它的特殊功能是什么呢？
Spring 中FactoryBean最大的应用场景是用在 AOP 中。我们都知道，AOP 实际上是 Spring 在运行是创建出来的代理对象，这个对象是在运行时才被创建的，而不是在启动时定义的，这与工厂方法模式是一致的。更生动地说，AOP 代理对象通过 java 反射机制在运行时创建代理对象，并根据业务需求将相应的方法编织到代理对象的目标方法中。Spring 中的 ProxyFactoryBean 就是干这事的。
因此，FactoryBean 提供了更灵活的实例化 bean 的方法。通过 FactoryBean 我们可以创建更复杂的 bean

1.3 区别总结

• BeanFactory：IOC 容器，并且提供方法支持外部程序对这些 bean 的访问，在程序启动时 根据传入的参数产生各种类型的 bean，并添加到 IOC容器（实现 BeanFactory 接口的类) 的 singletonObject 属性中。
• FactoryBean： 首先是个 bean，也存放在 BeanFactory 中。它具有工厂方法的功能，在程序运行中 产生指定(一种)类型的 bean，并添加到了 IOC容器中的 factoryBeanObjectCache 属性中。
  所以，这两种方式创建的 bean 都是被 spring 容器管理的
• BeanFactory和FactoryBean都可以用来创建对象，只不过创建的流程和方式不同
  • 当使用BeanFactory的时候，必须要严格的遵守bean的生命周期，经过一系列繁杂的步骤之后可以创建出单例对象，是流水线式的创建过程
  • FactoryBean是用户可以自定义bean对象的创建流程，不需要按照bean的生命周期来创建

转载于：https://blog.csdn.net/yy_diego/article/details/115710104

2 BeanFactory和ApplicationContext区别

BeanFactory已经在上面说过了，下面就不再赘述了

2.1 ApplicationContext

2.1.1 和BeanFactory关系

BeanFactory和ApplicationContext 接口及其子类图

image.png

2.1.2 定义

继承了BeanFactory接口，拥有BeanFactory的全部功能，并且扩展了很多高级特性，每次容器启动时就会创建所有的对象。

创建ApplicationContext的方法：

• 从类路径下加载配置文件:ClassPathXmlApplicationContext("applicationContext.xml");
• 从硬盘绝对路径下加载配置文件: FileSystemXmlApplicationContext(“d:/xxx/yyy/xxx”);

2.1.3 ApplicationContext类体系结构

Bean 工厂（com.springframework.beans.factory.BeanFactory）是Spring框架最核心的接口，它提供了高级IOC的配置机制。
应用上下文（com.springframework.context.ApplicationContext）建立在BeanFactory 基础之上。
几乎所有的应用场合我们都直接使用ApplicationContext 而非底层的BeanFactory

ApplicationContext 由BeanFactory 派生而来，提供了更多面向实际应用的功能。在BeanFactory中，很多功能需要以编程的方式实现，而在ApplicationContext 中则可以通过配置的方式实现。
ApplicationContext 的主要实现类是ClassPathXmlApplicationContext 和FileSystemXmlApplicationContext，前者默认从类路径加载配置文件，后者默认从文件系统中装载配置文件。

核心接口包括：

• ApplicationEventPublisher：让容器拥有发布应用上下文事件的功能，包括容器启动事件、关闭事件等。实现了ApplicationListener事件监听接口的Bean 可以接收到容器事件， 并对事件进行响应处理。在ApplicationContext抽象实现类AbstractApplicationContext中，我们可以发现存在一个ApplicationEventMulticaster，它负责保存所有监听器，以便在容器产生上下文事件时通知这些事件监听者
• MessageSource：为应用提供i18n国际化消息访问的功能；
• ResourcePatternResolver ： 所有ApplicationContext实现类都实现了类似于PathMatchingResourcePatternResolver的功能，可以通过带前缀的Ant 风格的资源文件路径装载Spring 的配置文件。
• LifeCycle：该接口是Spring 2.0 加入的，该接口提供了start()和stop()两个方法，主要用于控制异步处理过程。在具体使用时，该接口同时被 ApplicationContext实现及具体Bean实现，ApplicationContext会将start/stop的信息传递给容器中所有实现了该接口的Bean，以达到管理和控制JMX、任务调度等目的。
• ConfigurableApplicationContext 扩展于ApplicationContext，它新增加了两个主要的方法：refresh()和close()，让ApplicationContext具有启动、刷新和关闭应用上下文的能力。在应用上下文关闭的情况下调用refresh()即可启动应用上下文，在已经启动的状态下，调用refresh()则清除缓存并重新装载配置信息，而调用close()则可关闭应用上下文。这些接口方法为容器的控制管理带来了便利.

代码示例：

ApplicationContext ctx =new ClassPathXmlApplicationContext("com/baobaotao/context/beans.xml");
ApplicationContext ctx =new FileSystemXmlApplicationContext("com/baobaotao/context/beans.xml");
ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"conf/beans1.xml","conf/beans2.xml"});

2.2 结论

早期的电脑性能低，内存小，所以Spring容器的容量不足，不能将所有的对象全部创建好放入容器，所以使用的是BeanFactory，需要某个对象时，再进行创建，随着电脑硬件的发展，内存越来越大，所以Spring框架引入了ApplicationContext，将所有的对象都创建好，放入容器，使用哪个对象，从容器中取得即可。
所以，web开发中,使用applicationContext. 在资源匮乏的环境可以使用BeanFactory

因此，ApplicationContext 的初始化和BeanFactory 有一个重大的区别：BeanFactory在初始化容器时，并未实例化Bean，直到第一次访问某个Bean 时才实例目标Bean；而ApplicationContext则在初始化应用上下文时就实例化所有单实例的Bean

ApplicationContext接口,它由BeanFactory接口派生而来，ApplicationContext包含BeanFactory的所有功能，通常建议比BeanFactory优先

转载于：https://blog.csdn.net/qq_20757489/article/details/88543252