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、

Resource resource = new FileSystemResource("beans.xml");

BeanFactory factory = new XmlBeanFactory(resource);

方式2、

ClassPathResource resource = new ClassPathResource("beans.xml");

BeanFactory factory = new XmlBeanFactory(resource);

方式3、

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 getBean(String name, Class requiredType) throws BeansException;

T getBean(Class 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

* 代理一個類，攔截該類的所有方法，在方法的調用前後進行日誌的輸出

* @author daniel.zhao

*

*/

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

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> /<bean>

<property>

<property>

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 getObject() throws Exception;

Class> getObjectType();

boolean isSingleton();

}

在該接口中還定義了以下3個方法：

TgetObject()：返回由FactoryBean創建的Bean實例，如果isSingleton()返回true，則該實例會放到Spring容器中單實例緩存池中；

booleanisSingleton()：返回由FactoryBean創建的Bean實例的作用域是singleton還是prototype；

ClassgetObjectType()：返回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 {

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

P:carInfo="法拉利,400,2000000"/>

當調用getBean("car")時，Spring通過反射機制發現CarFactoryBean實現了FactoryBean的接口，這時Spring容器就調用接口方法CarFactoryBean#getObject()方法返回。

如果希望獲取CarFactoryBean的實例，則需要在使用getBean(beanName)方法時在beanName前顯示的加上"&"前綴：如getBean("&car");

下面是一個應用FactoryBean的例子

<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> /<bean>

<property>

<bean> /<bean>

<bean> /<bean>

<property>

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)。

所謂技多不壓身，我們所讀過的每一本書，所學過的每一門語言，在未來指不定都能給我們意想不到的回饋呢。其實做為一個開發者，有一個學習的氛圍跟一個交流圈子特別重要這裡我推薦一個Java學習交流群私信小編獲得進群資料，不管你是小白還是大牛歡迎入駐，大家一起交流成長。

閱讀更多 晴天難見陽光 的文章

關鍵字: 分不清 傻傻 方式