Spring 的 BeanFactory 和 FactoryBean 傻傻分不清？

BeanFacotry是spring中比較原始的Factory。如XMLBeanFactory就是一種典型的BeanFactory。原始的BeanFactory無法支援spring的許多插件，如AOP功能、Web應用等。

ApplicationContext接口，它由BeanFactory接口派生而來。

ApplicationContext包含BeanFactory的所有功能，通常建議比BeanFactory優先。

BeanFactory和FactoryBean的差別

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,它的實作與設計模式中的工廠模式和修飾器模式類似。

1、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的作用，同時還進行更多的擴充。

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架構去實作。

方式1、

Spring 的 BeanFactory 和 FactoryBean 傻傻分不清？

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml", "applicationContext-part2.xml"});  
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名稱的所有别名

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);   
}

2、FactoryBean

一般情況下，Spring通過反射機制利用的class屬性指定實作類執行個體化Bean，在某些情況下，執行個體化Bean過程比較複雜，如果按照傳統的方式，則需要在中提供大量的配置資訊。配置方式的靈活性是受限的，這時采用編碼的方式可能會得到一個簡單的方案。

Spring為此提供了一個org.springframework.bean.factory.FactoryBean的工廠類接口，使用者可以通過實作該接口定制執行個體化Bean的邏輯。bean 為什麼預設單例？推薦看下。關注微信公衆号：Java技術棧，在背景回複：spring，可以擷取我整理的 N 篇 Spring 教程，都是幹貨。

FactoryBean接口對于Spring架構來說占用重要的地位，Spring自身就提供了70多個FactoryBean的實作。它們隐藏了執行個體化一些複雜Bean的細節，給上層應用帶來了便利。

從Spring3.0開始，FactoryBean開始支援泛型，即接口聲明改為FactoryBean 的形式以Bean結尾，表示它是一個Bean，不同于普通Bean的是：它是實作了FactoryBean 接口的Bean，根據該Bean的ID從BeanFactory中擷取的實際上是FactoryBean的getObject()傳回的對象，而不是FactoryBean本身，如果要擷取FactoryBean對象，請在id前面加一個&符号來擷取。

例如自己實作一個FactoryBean，功能：用來代理一個對象，對該對象的所有方法做一個攔截，在調用前後都輸出一行LOG，模仿ProxyFactoryBean的功能。

/**  
 * 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;  
    }  

}

XML-Bean配置如下

<bean id="fbHelloWorldService" class="com.ebao.xxx.MyFactoryBean">  
   <property name="interfaceName" value="com.ebao.xxx.HelloWorldService" />  
   <property name="target" ref="helloWorldService" />  
</bean>

Junit Test class

@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之前加上&。

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 getObjectType()：傳回FactoryBean建立的Bean類型。

當配置檔案中的class屬性配置的實作類是FactoryBean時，通過getBean()方法傳回的不是FactoryBean本身，而是FactoryBean#getObject()方法所傳回的對象，相當于FactoryBean#getObject()代理了getBean()方法。例：如果使用傳統方式配置下面Car的時，Car的每個屬性分别對應一個元素标簽。

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的所有屬性指定配置值：

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了：

<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的例子

<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的實作類

import org.springframework.beans.factory.FactoryBean;   

/**   
 * @author  作者 wangbiao   
 * @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

/**   
 * @author  作者 wangbiao   
 * @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 + "]";   
    }   
}

測試類

import org.springframework.context.support.ClassPathXmlApplicationContext;   

import com.spring.bean.FactoryBeanPojo;   

/**   
 * @author  作者 wangbiao   
 * @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());   
    }   
}

輸出的結果：

十一月 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)。

參考

https://blog.csdn.net/wangbiao007/article/details/53183764 https://blog.csdn.net/qiesheng/article/details/72875315 https://www.cnblogs.com/redcool/p/6413461.html

作者：至尊寶

https://www.cnblogs.com/aspirant/p/9082858.html

推薦去我的部落格閱讀更多：

1.Java JVM、集合、多線程、新特性系列教程

2.Spring MVC、Spring Boot、Spring Cloud 系列教程

3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程

4.Java、後端、架構、阿裡巴巴等大廠最新面試題

生活很美好，明天見～

Spring 的 BeanFactory 和 FactoryBean 傻傻分不清？

繼續閱讀

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

Git學習筆記5 merge沖突時二選一

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

vue-cli簡介（中文翻譯）

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method