js css html

Spring核心之FactoryBean，BeanFactory

2022-09-20  本文已影响0人  上善若泪

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容器给出了很多种实现，比如：

这些实现类从不同的维度对 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 的类体系结构

1.1.4 使用场景

使用场景：

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 区别总结

转载于：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的方法：

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，前者默认从类路径加载配置文件，后者默认从文件系统中装载配置文件。

核心接口包括：

代码示例：

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

上一篇 下一篇

猜你喜欢

热点阅读