BeanFactory 和FactoryBean的区别

时间  2020-01-18
标签 beanfactory factorybean 区别 繁體版
原文   原文链接

BeanFacotry是spring中比较原始的Factory。如XMLBeanFactory就是一种典型的BeanFactory。原始的BeanFactory没法支持spring的许多插件，如AOP功能、Web应用等。
ApplicationContext接口,它由BeanFactory接口派生而来，ApplicationContext包含BeanFactory的全部功能，一般建议比BeanFactory优先
BeanFactory和FactoryBean的区别web

BeanFactory是接口，提供了OC容器最基本的形式，给具体的IOC容器的实现提供了规范，
  FactoryBean也是接口，为IOC容器中Bean的实现提供了更加灵活的方式，FactoryBean在IOC容器的基础上给Bean的实现加上了一个简单工厂模式和装饰模式(若是想了解装饰模式参考：修饰者模式(装饰者模式，Decoration) 咱们能够在getObject()方法中灵活配置。其实在Spring源码中有不少FactoryBean的实现类.

区别：BeanFactory是个Factory，也就是IOC容器或对象工厂，FactoryBean是个Bean。在Spring中，全部的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式相似
一、 BeanFactory
　　BeanFactory，以Factory结尾，表示它是一个工厂类(接口)， 它负责生产和管理bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及创建这些对象间的依赖。BeanFactory只是个接口，并非IOC容器的具体实现，可是Spring容器给出了不少种实现，如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等，其中XmlBeanFactory就是经常使用的一个，该实现将以XML方式描述组成应用的对象及对象间的依赖关系。XmlBeanFactory类将持有此XML配置元数据，并用它来构建一个彻底可配置的系统或应用。
都是附加了某种功能的实现。 它为其余具体的IOC容器提供了最基本的规范，例如DefaultListableBeanFactory,XmlBeanFactory,ApplicationContext 等具体的容器都是实现了BeanFactory，再在其基础之上附加了其余的功能。
BeanFactory和ApplicationContext就是spring框架的两个IOC容器，如今通常使用ApplicationnContext，其不但包含了BeanFactory的做用，同时还进行更多的扩展。 spring

BeanFacotry是spring中比较原始的Factory。如XMLBeanFactory就是一种典型的BeanFactory。
原始的BeanFactory没法支持spring的许多插件，如AOP功能、Web应用等。ApplicationContext接口,它由BeanFactory接口派生而来，
ApplicationContext包含BeanFactory的全部功能，一般建议比BeanFactory优先
ApplicationContext以一种更向面向框架的方式工做以及对上下文进行分层和实现继承，ApplicationContext包还提供了如下的功能：
• MessageSource, 提供国际化的消息访问
• 资源访问，如URL和文件
• 事件传播
• 载入多个（有继承关系）上下文 ，使得每个上下文都专一于一个特定的层次，好比应用的web层;
在不使用spring框架以前，咱们的service层中要使用dao层的对象，不得不在service层中new一个对象。存在的问题：层与层之间的依赖。
service层要用dao层对象须要配置到xml配置文件中，至于对象是怎么建立的，关系是怎么组合的都交给了spring框架去实现。
[Java] 纯文本查看 复制代码
?设计模式

1 Resource resource = new FileSystemResource("beans.xml");
2 BeanFactory factory = new XmlBeanFactory(resource);
[Java] 纯文本查看 复制代码
?缓存

1 ClassPathResource resource = new ClassPathResource("beans.xml");
2 BeanFactory factory = new XmlBeanFactory(resource);
[Java] 纯文本查看 复制代码
?app

1 ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
3 BeanFactory factory = (BeanFactory) context;框架

基本就是这些了，接着使用getBean(String beanName)方法就能够取得bean的实例；BeanFactory提供的方法及其简单，仅提供了六种方法供客户调用：
　　boolean containsBean(String beanName) 判断工厂中是否包含给定名称的bean定义，如有则返回true
　　Object getBean(String) 返回给定名称注册的bean实例。根据bean的配置状况，若是是singleton模式将返回一个共享实例，不然将返回一个新建的实例，若是没有找到指定bean,该方法可能会抛出异常
　　Object getBean(String, Class) 返回以给定名称注册的bean实例，并转换为给定class类型
　　Class getType(String name) 返回给定名称的bean的Class,若是没有找到指定的bean实例，则排除NoSuchBeanDefinitionException异常
　　boolean isSingleton(String) 判断给定名称的bean定义是否为单例模式
　　String[] getAliases(String name) 返回给定bean名称的全部别名
[Java] 纯文本查看 复制代码
?ide

package org.springframework.beans.factory;
import org.springframework.beans.BeansException;
public interface BeanFactory {测试

String FACTORY_BEAN_PREFIX = "&";  
Object getBean(String name) throws BeansException;  
<T> T getBean(String name, Class<T> requiredType) throws BeansException;  
<T> T getBean(Class<T> requiredType) throws BeansException;  
Object getBean(String name, Object... args) throws BeansException;  
boolean containsBean(String name);  
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;  
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;  
boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;  
Class<?> getType(String name) throws NoSuchBeanDefinitionException;  
String[] getAliases(String name);

}ui

二、FactoryBean
通常状况下，Spring经过反射机制利用<bean>的class属性指定实现类实例化Bean，在某些状况下，实例化Bean过程比较复杂，若是按照传统的方式，则须要在<bean>中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会获得一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户能够经过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来讲占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂Bean的细节，给上层应用带来了便利。从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改成FactoryBean<T>的形式
以Bean结尾，表示它是一个Bean，不一样于普通Bean的是：它是实现了FactoryBean<T>接口的Bean，根据该Bean的ID从BeanFactory中获取的其实是FactoryBean的getObject()返回的对象，而不是FactoryBean自己，若是要获取FactoryBean对象，请在id前面加一个&符号来获取。
　　例如本身实现一个FactoryBean，功能：用来代理一个对象，对该对象的全部方法作一个拦截，在调用先后都输出一行LOG，模仿ProxyFactoryBean的功能。
[Java] 纯文本查看 复制代码
?this

/**

  • my factory bean<p>
  • 代理一个类，拦截该类的全部方法，在方法的调用先后进行日志的输出
  • @author daniel.zhao

*
*/
public class MyFactoryBean implements FactoryBean<Object>, InitializingBean, DisposableBean {

private static final Logger logger = LoggerFactory.getLogger(MyFactoryBean.class);    
private String interfaceName;    
private Object target;    
private Object proxyObj;    
@Override
public void destroy() throws Exception {
    logger.debug("destroy......");
}
@Override
public void afterPropertiesSet() throws Exception {
    proxyObj = Proxy.newProxyInstance(
            this.getClass().getClassLoader(), 
            new Class[] { Class.forName(interfaceName) }, 
            new InvocationHandler() {                    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            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;            }            
    });
    logger.debug("afterPropertiesSet......");
}

@Override
public Object getObject() throws Exception {
    logger.debug("getObject......");
    return proxyObj;
}

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

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

public String getInterfaceName() {
    return interfaceName;
}

public void setInterfaceName(String interfaceName) {
    this.interfaceName = interfaceName;
}

public Object getTarget() {
    return target;
}

public void setTarget(Object target) {
    this.target = target;
}

public Object getProxyObj() {
    return proxyObj;
}

public void setProxyObj(Object proxyObj) {
    this.proxyObj = proxyObj;
}[/align][align=left]XML-Bean配置以下

}
[XML] 纯文本查看 复制代码

1 <bean id="fbHelloWorldService" class="com.ebao.xxx.MyFactoryBean">
2 <property name="interfaceName" value="com.ebao.xxx.HelloWorldService" />
3 <property name="target" ref="helloWorldService" />
4 </bean>
Junit Test class
[Java] 纯文本查看 复制代码
?

@RunWith(JUnit4ClassRunner.class)
@ContextConfiguration(classes = { MyFactoryBeanConfig.class })
public class MyFactoryBeanTest {

@Autowired
private ApplicationContext context;    
/**
 * 测试验证FactoryBean原理，代理一个servcie在调用其方法的先后，打印日志亦可做其余处理
 * 从ApplicationContext中获取自定义的FactoryBean
 * context.getBean(String beanName) ---> 最终获取到的Object是FactoryBean.getObejct(), 
 * 使用Proxy.newInstance生成service的代理类
 */
@Test
public void testFactoryBean() {
    HelloWorldService helloWorldService = (HelloWorldService) context.getBean("fbHelloWorldService");
    helloWorldService.getBeanName();
    helloWorldService.sayHello();
}

}
FactoryBean是一个接口，当在IOC容器中的Bean实现了FactoryBean后，经过getBean(String BeanName)获取到的Bean对象并非FactoryBean的实现类对象，而是这个实现类中的getObject()方法返回的对象。要想获取FactoryBean的实现类，就要getBean(&BeanName)，在BeanName以前加上&。
Java代码
[Java] 纯文本查看 复制代码

package org.springframework.beans.factory;
public interface FactoryBean<T> {

T getObject() throws Exception;  
Class<?> getObjectType();  
boolean isSingleton();

}
在该接口中还定义了如下3个方法：

TgetObject()：返回由FactoryBean建立的Bean实例，若是isSingleton()返回true，则该实例会放到Spring容器中单实例缓存池中；
booleanisSingleton()：返回由FactoryBean建立的Bean实例的做用域是singleton仍是prototype；
Class<T>getObjectType()：返回FactoryBean建立的Bean类型。
当配置文件中<bean>的class属性配置的实现类是FactoryBean时，经过getBean()方法返回的不是FactoryBean自己，而是FactoryBean#getObject()方法所返回的对象，至关于FactoryBean#getObject()代理了getBean()方法。
例：若是使用传统方式配置下面Car的<bean>时，Car的每一个属性分别对应一个<property>元素标签。
[Java] 纯文本查看 复制代码
?

package com.baobaotao.factorybean;

public   class  Car  {  
    private   int maxSpeed ;  
    private  String brand ;  
    private   double price ;  
    public   int  getMaxSpeed ()   {  
        return   this . maxSpeed ;  
    }  
    public   void  setMaxSpeed ( int  maxSpeed )   {  
        this . maxSpeed  = maxSpeed;  
    }  
    public  String getBrand ()   {  
        return   this . brand ;  
    }  
    public   void  setBrand ( String brand )   {  
        this . brand  = brand;  
    }  
    public   double  getPrice ()   {  
        return   this . price ;  
    }  
    public   void  setPrice ( double  price )   {  
        this . price  = price;  
   }

}
若是用FactoryBean的方式实现就灵活点，下例经过逗号分割符的方式一次性的为Car的全部属性指定配置值：
[Java] 纯文本查看 复制代码
?

package com.baobaotao.factorybean;
import org.springframework.beans.factory.FactoryBean;
public class CarFactoryBean implements FactoryBean<Car> {

private  String carInfo ;  
public  Car getObject ()   throws  Exception  {  
    Car car =  new  Car () ;  
    String []  infos =  carInfo .split ( "," ) ;  
    car.setBrand ( infos [ 0 ]) ;  
    car.setMaxSpeed ( Integer. valueOf ( infos [ 1 ])) ;  
    car.setPrice ( Double. valueOf ( infos [ 2 ])) ;  
    return  car;  
}  
public  Class<Car> getObjectType ()   {  
    return  Car. class ;  
}  
public   boolean  isSingleton ()   {  
    return   false ;  
}  
public  String getCarInfo ()   {  
    return   this . carInfo ;  
}  

// 接受逗号分割符设置属性信息  
public   void  setCarInfo ( String carInfo )   {  
    this . carInfo  = carInfo;  
}

}
有了这个CarFactoryBean后，就能够在配置文件中使用下面这种自定义的配置方式配置CarBean了：
[XML] 纯文本查看 复制代码
?
1
2
<bean d="car"class="com.baobaotao.factorybean.CarFactoryBean"
P:carInfo="法拉利,400,2000000"/>
当调用getBean("car")时，Spring经过反射机制发现CarFactoryBean实现了FactoryBean的接口，这时Spring容器就调用接口方法CarFactoryBean#getObject()方法返回。若是但愿获取CarFactoryBean的实例，则须要在使用getBean(beanName)方法时在beanName前显示的加上"&"前缀：如getBean("&car");
下面是一个应用FactoryBean的例子
[XML] 纯文本查看 复制代码
?

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xmlns:context="http://www.springframework.org/schema/context" 
         xmlns:aop="http://www.springframework.org/schema/aop" 
         xmlns:tx="http://www.springframework.org/schema/tx" 
         xsi:schemaLocation="http://www.springframework.org/schema/beans  
                 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
                 http://www.springframework.org/schema/context  
                 http://www.springframework.org/schema/context/spring-context-3.0.xsd  
                 http://www.springframework.org/schema/aop  
                 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
                 http://www.springframework.org/schema/tx  
                 http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

<bean id="student" class="com.spring.bean.Student">
<property name="name" value="zhangsan" />
</bean>

<bean id="school" class="com.spring.bean.School">
</bean>

<bean id="factoryBeanPojo" class="com.spring.bean.FactoryBeanPojo">

<property name="type" value="student" />

</bean>
</beans>
FactoryBean的实现类 ：
[Java] 纯文本查看 复制代码
?

import org.springframework.beans.factory.FactoryBean;

/**

  • @author 做者 wangbiao
  • @date 建立时间：2016年11月14日 上午11:19:31
  • @parameter
  • @return

*/
public class FactoryBeanPojo implements FactoryBean{

private String type;  

@Override 
public Object getObject() throws Exception {  
    if("student".equals(type)){  
        return new Student();             
    }else{  
        return new School();  
    }  
       
}  

@Override 
public Class getObjectType() {  
    return School.class;  
}  

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

public String getType() {  
    return type;  
}  

public void setType(String type) {  
    this.type = type;  
}

}
普通的bean：
[Java] 纯文本查看 复制代码
?

/**

  • @author 做者 wangbiao
  • @date 建立时间：2016年11月14日 上午11:13:18
  • @parameter
  • @return

*/
public class School {

private String schoolName;  
private String address;  
private int studentNumber;  
public String getSchoolName() {  
    return schoolName;  
}  
public void setSchoolName(String schoolName) {  
    this.schoolName = schoolName;  
}  
public String getAddress() {  
    return address;  
}  
public void setAddress(String address) {  
    this.address = address;  
}  
public int getStudentNumber() {  
    return studentNumber;  
}  
public void setStudentNumber(int studentNumber) {  
    this.studentNumber = studentNumber;  
}  
@Override 
public String toString() {  
    return "School [schoolName=" + schoolName + ", address=" + address  
            + ", studentNumber=" + studentNumber + "]";  
}

}
测试类 ：
[Java] 纯文本查看 复制代码
?

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.spring.bean.FactoryBeanPojo;

/**

  • @author 做者 wangbiao
  • @date 建立时间：2016年11月14日 上午11:11:35
  • @parameter
  • @return

*/
public class FactoryBeanTest {

public static void main(String[] args){  
    String url = "com/spring/config/BeanConfig.xml";  
    ClassPathXmlApplicationContext cpxa = new ClassPathXmlApplicationContext(url);  
    Object school=  cpxa.getBean("factoryBeanPojo");  
    FactoryBeanPojo factoryBeanPojo= (FactoryBeanPojo) cpxa.getBean("&factoryBeanPojo");  
    System.out.println(school.getClass().getName());  
    System.out.println(factoryBeanPojo.getClass().getName());  
}

}
输出的结果：
[HTML] 纯文本查看 复制代码
?

十一月 16, 2016 10:28:24 上午 org.springframework.context.support.AbstractApplicationContext prepareRefresh INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1e8ee5c0: startup date [Wed Nov 16 10:28:24 CST 2016]; root of context hierarchy 十一月 16, 2016 10:28:24 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions INFO: Loading XML bean definitions from class path resource [com/spring/config/BeanConfig.xml] 十一月 16, 2016 10:28:24 上午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@35b793ee: defining beans [student,school,factoryBeanPojo]; root of factory hierarchy com.spring.bean.Student com.spring.bean.FactoryBeanPojo从结果上能够看到当从IOC容器中获取FactoryBeanPojo对象的时候，用getBean(String BeanName)获取的确是Student对象，能够看到在FactoryBeanPojo中的type属性设置为student的时候，会在getObject()方法中返回Student对象。因此说从IOC容器获取实现了FactoryBean的实现类时，返回的倒是实现类中的getObject方法返回的对象，要想获取FactoryBean的实现类，得在getBean(String BeanName)中的BeanName以前加上&,写成getBean(String &BeanName)。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程