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教程