spring的FactoryBean和BeanFactoryw

本文详细介绍了Spring框架中的BeanFactory接口及其核心作用,并深入探讨了FactoryBean接口的实现方式,展示了如何通过FactoryBean来简化复杂Bean的实例化过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >


好文备忘

转自:http://www.meiriyouke.net/?p=64


1、 BeanFactory

    BeanFactory定义了 IOC 容器的最基本形式,并提供了 IOC 容器应遵守的的最基本的接口,也就是Spring IOC 所遵守的最底层和最基本的编程规范。在  Spring 代码中, BeanFactory 只是个接口,并不是 IOC容器的具体实现,但是 Spring 容器给出了很多种实现,如 DefaultListableBeanFactory 、 XmlBeanFactory 、ApplicationContext 等,都是附加了某种功能的实现。

 

以下为BeanFactory接口的定义:

  1. public interface BeanFactory {
  2. String FACTORY_BEAN_PREFIX = "&";
  3.  
  4. Object getBean(String name) throws BeansException;
  5.  
  6. <T> T getBean(String name, Class<T> requiredType) throws BeansException;
  7.  
  8. <T> T getBean(Class<T> requiredType) throws BeansException;
  9.  
  10. Object getBean(String name, Object... args) throws BeansException;
  11.  
  12. boolean containsBean(String name);
  13.  
  14. boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
  15.  
  16. boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
  17.  
  18. boolean isTypeMatch(String name, Class<?> targetType)
  19. throws NoSuchBeanDefinitionException;
  20.  
  21. Class<?> getType(String name) throws NoSuchBeanDefinitionException;
  22.  
  23. String[] getAliases(String name);
  24. }

2、 FactoryBean

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

FactoryBean接口对于 Spring 框架来说占用重要的地位, Spring 自身就提供了 70 多个 FactoryBean 的实现。它们隐藏了实例化一些复杂 Bean 的细节,给上层应用带来了便利。从 Spring 3.0 开始, FactoryBean 开始支持泛型,即接口声明改为 FactoryBean<T> 的形式:

  1. public interface FactoryBean<T> {
  2. T getObject() throws Exception;
  3. Class<?> getObjectType();
  4. boolean isSingleton();
  5. }

在该接口中还定义了以下3 个方法:

 

T getObject():返回由 FactoryBean 创建的 Bean 实例,如果 isSingleton() 返回 true ,则该实例会放到Spring 容器中单实例缓存池中;

boolean isSingleton():返回由 FactoryBean 创建的 Bean 实例的作用域是 singleton 还是 prototype ;

Class<T> getObjectType():返回 FactoryBean 创建的 Bean 类型。

当配置文件中<bean> 的 class 属性配置的实现类是 FactoryBean 时,通过 getBean() 方法返回的不是FactoryBean 本身,而是 FactoryBean#getObject() 方法所返回的对象,相当于 FactoryBean#getObject() 代理了getBean() 方法。

 

例:如果使用传统方式配置下面Car 的 <bean> 时, Car 的每个属性分别对应一个 <property> 元素标签。

 

  1. public class Car {
  2. private int maxSpeed;
  3. private String brand;
  4. private double price;
  5.  
  6. public int getMaxSpeed() {
  7. return this.maxSpeed;
  8. }
  9.  
  10. public void setMaxSpeed(int maxSpeed) {
  11. this.maxSpeed = maxSpeed;
  12. }
  13.  
  14. public String getBrand() {
  15. return this.brand;
  16. }
  17.  
  18. public void setBrand(String brand) {
  19. this.brand = brand;
  20. }
  21.  
  22. public double getPrice() {
  23. return this.price;
  24. }
  25.  
  26. public void setPrice(double price) {
  27. this.price = price;
  28. }
  29. }

如果用FactoryBean 的方式实现就灵活点,下例通过逗号分割符的方式一次性的为 Car 的所有属性指定配置值:

  1. public class CarFactoryBean implements FactoryBean<Car> {
  2. private String carInfo;
  3.  
  4. public Car getObject() throws Exception {
  5. Car car = new Car();
  6. String[] infos = carInfo.split(",");
  7. car.setBrand(infos[0]);
  8. car.setMaxSpeed(Integer.valueOf(infos[1]));
  9. car.setPrice(Double.valueOf(infos[2]));
  10. return car;
  11. }
  12.  
  13. public Class<Car> getObjectType() {
  14. return Car.class;
  15. }
  16.  
  17. public boolean isSingleton() {
  18. return false;
  19. }
  20.  
  21. public String getCarInfo() {
  22. return this.carInfo;
  23. }
  24.  
  25. // 接受逗号分割符设置属性信息
  26. public void setCarInfo(String carInfo) {
  27. this.carInfo = carInfo;
  28. }
  29. }

有了这个CarFactoryBean 后,就可以在配置文件中使用下面这种自定义的配置方式配置 Car Bean 了:

  1. <bean id="car" class="com.baobaotao.factorybean.CarFactoryBean">
  2. <property name="carInfo" value="法拉利 ,400,2000000"/>
  3. </bean>

当调用getBean("car") 时, Spring 通过反射机制发现 CarFactoryBean 实现了 FactoryBean 的接口,这时Spring 容器就调用接口方法 CarFactoryBean#getObject() 方法返回。如果希望获取 CarFactoryBean 的实例,则需要在使用 getBean(beanName) 方法时在 beanName 前显示的加上 "&" 前缀:如 getBean("&car");

 

3、 区别

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


<think>嗯,用户问的是Spring中的FactoryBeanBeanFactory的区别。这两个名字看起来有点像,容易混淆,我得仔细想清楚它们的区别。首先,FactoryBeanBeanFactory都是Spring框架中的重要接口,但它们的用途角色不同。 首先,BeanFactory,听起来像是Spring的IoC容器的基础接口。它负责管理Bean的生命周期,包括创建、配置管理Bean。BeanFactory是Spring的核心容器,ApplicationContext就是它的子接口,功能更强大。所以BeanFactory更像是一个工厂,用来生产管理各种Bean的。 然后是FactoryBean,这个接口名字有点特别,因为它本身也是一个Bean,但它的特殊之处在于它能够生成其他Bean的实例。也就是说,当我们在Spring中配置了一个FactoryBean的时候,实际上获取的是它生产的对象,而不是FactoryBean本身。比如,常见的例子是创建一些复杂的对象,或者需要自定义实例化逻辑的时候,FactoryBean就派上用场了。 接下来,用户可能需要具体的区别点。我需要分点说明它们的定义、用途、获取方式、使用场景常见实现。比如,BeanFactory是容器,用于管理Bean,而FactoryBean是用来创建特定Bean的工具。在获取Bean的时候,BeanFactory直接通过getBean方法得到Bean,而FactoryBean则需要加上&符号来获取FactoryBean本身,否则得到的是它生成的对象。 还需要注意用户可能的疑问点,比如为什么要有FactoryBean,它普通Bean有什么区别。可能需要举例子,比如MyBatis的SqlSessionFactoryBean,它实现了FactoryBean,用来创建SqlSessionFactory,这样配置起来更方便。 另外,要确保语言通俗易懂,避免技术术语过多,但也要准确。比如,解释BeanFactory作为基础容器,而FactoryBean作为特殊Bean生成其他Bean。结构要清晰,分点明确,让用户能够一步步理解两者的不同。 可能用户在使用Spring的时候遇到了配置问题,或者看到这两个接口的名字分不清,所以需要明确它们的区别应用场景。因此,回答时要强调它们各自的职责如何在实际中使用,比如什么时候该用FactoryBean,什么时候直接通过BeanFactory操作。 最后,确保LaTeX格式正确,如果有数学表达式的话,但这个问题可能不需要,不过还是要注意用户提到的系统级指令,比如行内公式用$...$,独立公式用$$...$$,但这里可能用不上。主要用中文回答,结构清晰,分点说明,帮助用户彻底理解两者的区别。</think>### Spring中的FactoryBean与BeanFactory区别解析 #### 1. **定义与核心职责** - **BeanFactory** - **角色**:Spring框架**最基础的IoC容器接口**,定义了容器的核心功能。 - **职责**:负责Bean的**实例化、配置、生命周期管理**。 - **类比**:类似“工厂流水线”,负责生产管理所有Bean对象。 - **FactoryBean** - **角色**:一个**特殊的Bean接口**,用于**动态生成其他Bean实例**。 - **职责**:封装复杂对象的创建逻辑(如第三方库对象)。 - **类比**:类似“定制化工具”,通过工厂模式扩展Bean的创建方式。 --- #### 2. **使用方式对比** | **特性** | **BeanFactory** | **FactoryBean** | |-------------------|----------------------------------|-------------------------------------| | **直接获取对象** | `getBean("beanName")` | `getBean("&factoryBeanName")`获取FactoryBean本身,<br/>`getBean("factoryBeanName")`获取其生产的对象 | | **典型实现** | `DefaultListableBeanFactory` | `SqlSessionFactoryBean` (MyBatis集成) | | **应用场景** | 所有Bean的通用管理 | 需要自定义实例化逻辑的复杂对象 | --- #### 3. **关键差异点** 1. **接口类型** - `BeanFactory`是**容器级接口**,属于Spring基础设施。 - `FactoryBean`是**Bean级接口**,属于用户可扩展的组件。 2. **控制反转方向** - `BeanFactory`是**容器的控制者**,管理所有Bean。 - `FactoryBean`是**被管理的Bean**,同时控制其生产的对象。 3. **代码示例** ```java // 通过BeanFactory获取普通Bean MyService service = beanFactory.getBean("myService"); // 通过FactoryBean获取其生产的对象 SqlSessionFactory sqlSessionFactory = (SqlSessionFactory) beanFactory.getBean("sqlSessionFactory"); // 获取FactoryBean本身 FactoryBean<?> factoryBean = (FactoryBean<?>) beanFactory.getBean("&sqlSessionFactory"); ``` --- #### 4. **典型应用场景** - **BeanFactory的用途** 所有Spring应用的基础,如`ApplicationContext`(BeanFactory的增强版)用于依赖注入、Bean生命周期管理。 - **FactoryBean的常见场景** - 集成第三方框架(如MyBatis的`SqlSessionFactoryBean`) - 创建需复杂初始化的对象(如连接池、代理对象) - 延迟加载或条件化创建Bean --- #### 5. **总结对比表** | **维度** | **BeanFactory** | **FactoryBean** | |-----------------|----------------------------------|-----------------------------------| | 层级 | 容器级接口 | Bean级接口 | | 主要使用者 | Spring框架自身 | 开发者扩展 | | 核心目标 | 管理所有Bean | 生成特定Bean | | 设计模式 | 工厂模式 | 工厂模式 + 代理模式 | | 是否可配置 | 不可直接配置 | 可配置为普通Bean | --- 通过理解两者的定位差异,可以更精准地使用Spring的核心机制:**BeanFactory是“管理工厂”**,而**FactoryBean是“生产工具”**。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值