Spring中BeanFactory和FactoryBean的區別在哪？

其實從名字上就能看出來個一二，BeanFactory 是 Factory 而 FactoryBean 是一個 Bean，我們先來看下總結：

BeanFactory 是 Spring 框架的核心接口之一，用于管理和獲取應用程序中的 Bean 實例。它是一個工廠模式的實現，負責創建、配置和管理 Bean 對象。BeanFactory 是 Spring IoC 容器的基礎，它可以從配置元數據（如 XML 文件）中讀取 Bean 的定義，并在需要時實例化和提供這些 Bean。

FactoryBean 是一個特殊的 Bean，它是一個工廠對象，用于創建和管理其他 Bean 的實例。FactoryBean 接口定義了一種創建 Bean 的方式，它允許開發人員在 Bean 的創建過程中進行更多的自定義操作。通過實現 FactoryBean 接口，開發人員可以創建復雜的 Bean 實例，或者在 Bean 實例化之前進行一些額外的邏輯處理。

區別在于，BeanFactory 是 Spring 框架的核心接口，用于管理和提供 Bean 實例，而 FactoryBean 是一個特殊的 Bean，用于創建和管理其他 Bean 的實例。FactoryBean 在 Bean 的創建過程中提供更多的自定義能力，允許進行額外的邏輯處理。

可能有的小伙伴看的還不是很清楚，我們再來詳細看下。

1. BeanFactory

BeanFactory 看名字就知道這是一個 Bean 工廠，小伙伴們知道，Spring IoC 容器幫我們完成了 Bean 的創建、管理等操作，那么這些操作都離不開 BeanFactory。

我們來簡單看下 BeanFactory 的代碼：

publicinterfaceBeanFactory{
StringFACTORY_BEAN_PREFIX="&";
ObjectgetBean(Stringname)throwsBeansException;
TgetBean(Stringname,ClassrequiredType)throwsBeansException;
ObjectgetBean(Stringname,Object...args)throwsBeansException;
TgetBean(ClassrequiredType)throwsBeansException;
TgetBean(ClassrequiredType,Object...args)throwsBeansException;
ObjectProvidergetBeanProvider(ClassrequiredType);
ObjectProvidergetBeanProvider(ResolvableTyperequiredType);
booleancontainsBean(Stringname);
booleanisSingleton(Stringname)throwsNoSuchBeanDefinitionException;
booleanisPrototype(Stringname)throwsNoSuchBeanDefinitionException;
booleanisTypeMatch(Stringname,ResolvableTypetypeToMatch)throwsNoSuchBeanDefinitionException;
booleanisTypeMatch(Stringname,ClasstypeToMatch)throwsNoSuchBeanDefinitionException;
@Nullable
ClassgetType(Stringname)throwsNoSuchBeanDefinitionException;
@Nullable
ClassgetType(Stringname,booleanallowFactoryBeanInit)throwsNoSuchBeanDefinitionException;
String[]getAliases(Stringname);

}

這些方法基本上都見名知義：

FACTORY_BEAN_PREFIX：這個變量其實是說，如果當前 Bean 不是像 User、Book 這種普通 Bean，而是一個 FactoryBean，就給這個 Bean 名字加一個 & 前綴，這個我在第二小節和小伙伴們演示。

getBean：這個方法就是根據 Bean 的名字、類型等去查詢 Bean。

getBeanProvider：這個方法可以獲取一個 ObjectProvider，ObjectProvider 是 Spring 框架中的一個接口，用于獲取 Bean 對象的實例。它提供了一種延遲加載 Bean 的方式，可以在需要時動態地獲取 Bean 實例（懶加載）。

containsBean：判斷是否包含某個 Bean。

isSingleton：判斷某個 Bean 是否是單例的。

isPrototype：判斷某個 Bean 是否是多例的。

isTypeMatch：判斷某一個 Bean 的類型是否是給定類型。

getType：獲取 Bean 的類型。

getAliases：獲取 Bean 的別名。

可以看到，很多都是大家日常開發中常見常用的方法。

很多小伙伴剛開始接觸 Spring 的時候，都會用到一個對象 ClassPathXmlApplicationContext，這其實就是 BeanFactory 的一個子類。我們來看下 BeanFactory 的繼承圖：

繼承類比較多，我說幾個大家可能比較熟悉的：

ClassPathXmlApplicationContext：這個是 Spring 容器啟動時，從當前類路徑下去加載 XML 配置文件，參數就是 classpath 下 XML 的文件路徑。

FileSystemXmlApplicationContext：這個是 Spring 容器啟動時，從文件系統中去加載 XML 配置文件，參數一個絕對路徑。

AnnotationConfigApplicationContext：這個是如果我們使用 Java 代碼去做 Spring 容器的配置的話，通過這個配置類去加載 Java 配置類。

DefaultListableBeanFactory：這個默認實現了 ListableBeanFactory 和 BeanDefinitionRegistry 接口，是一個比較成熟的 BeanFactory。

好啦，這就是 BeanFactory 的特點，大家明白了吧～

2. FactoryBean

2.1 分析

FactoryBean 其實很多小伙伴可能都見過，只是可能沒去總結歸納。我給小伙伴們舉幾個例子。

在 SSM 項目中，如果我們要配置 MyBatis 到項目中，一般需要配置下面這個 Bean：

classpath*:org/javaboy/shirodemo/mapper/*.xml

我們在配置 Shiro 的時候，一般都要配置如下 Bean：

/index=anon
/doLogin=anon
/hello=user
/**=authc

如果我們前端傳遞的參數是 key-value 格式，并且有一個日期，那么小伙伴們知道，服務端 SpringMVC 默認無法處理這個日期，需要配置一個日期轉換器，一般我們在 Spring 容器中添加如下 Bean：

小伙伴們觀察上面三個 Bean 有一個共同的特點，那就是 Bean 的名字都是 xxxFactoryBean。

為什么要用 xxxFactoryBean 而不直接把需要的 Bean 注入到 Spring 容器中去呢？以 MyBatis 為例：

手動配置過 MyBatis 的小伙伴應該都知道，MyBatis 有兩個重要的類，一個是 SqlSessionFactory，還有一個是 SqlSession，通過 SqlSessionFactory 可以獲取到一個 SqlSession。但是不知道小伙伴們是否還記得配置代碼，手動配置代碼如下：

publicclassSqlSessionFactoryUtils{
privatestaticSqlSessionFactorySQLSESSIONFACTORY=null;
publicstaticSqlSessionFactorygetInstance(){
if(SQLSESSIONFACTORY==null){
try{
SQLSESSIONFACTORY=newSqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
}catch(IOExceptione){
e.printStackTrace();
}
}
returnSQLSESSIONFACTORY;
}
}
publicclassMain{
publicstaticvoidmain(String[]args){
SqlSessionFactoryfactory=SqlSessionFactoryUtils.getInstance();
SqlSessionsqlSession=factory.openSession();
Listlist=sqlSession.selectList("org.javaboy.mybatis01.mapper.UserMapper.getAllUser");
for(Useruser:list){
System.out.println("user="+user);
}
sqlSession.close();
}
}

小伙伴們看到，無論是 SqlSessionFactory 還是 SqlSession，都不是正經 new 出來的，其實這兩個都是接口，顯然不可能 new 出來，前者通過建造者模式去配置各種屬性，最后生成一個 SqlSessionFactory 的實例，后者則通過前者這個工廠去生成，最終拿到的都是這兩個接口的子類的對象。

所以，對于 SqlSessionFactory 和 SqlSession 就沒法在 Spring 容器中直接進行配置，那么對于這樣的 Bean，就可以通過 xxxFactoryBean 來進行配置。

我們來看下 SqlSessionFactoryBean 類，源碼很長，我挑了重要的出來：

publicclassSqlSessionFactoryBeanimplementsFactoryBean,InitializingBean,ApplicationListener{

privateSqlSessionFactorysqlSessionFactory;

@Override
publicSqlSessionFactorygetObject()throwsException{
if(this.sqlSessionFactory==null){
afterPropertiesSet();
}

returnthis.sqlSessionFactory;
}
@Override
publicClassgetObjectType(){
returnthis.sqlSessionFactory==null?SqlSessionFactory.class:this.sqlSessionFactory.getClass();
}
@Override
publicbooleanisSingleton(){
returntrue;
}
}

大家看一下，SqlSessionFactoryBean 需要實現 FactoryBean 接口，并且在實現接口的時候指定泛型是 SqlSessionFactory，也就是 SqlSessionFactoryBean 最終產出的 Bean 是 SqlSessionFactory。實現了 FactoryBean 接口之后，就需要實現接口中的三個方法：

getObject：這個方法返回的對象，就是真正要注冊到 Spring 容器中的對象，在這個方法中，我們就可以按照各種方式對 Bean 進行各種配置了。

getObjectType：這個方法返回注冊到 Spring 容器中的對象類型。

isSingleton：這個方法用來返回注冊到 Spring 容器中的 Bean 是否是單例的。

這就是 FactoryBean 的特點，由于某一個 Bean 的初始化過于復雜，那么就可以通過 FactoryBean 來幫助注冊到 Spring 容器中去。

2.2 實踐

松哥再寫一個簡單的例子給小伙伴們體驗一把 FactoryBean。

假設我有如下類：

publicclassAuthor{

privateStringname;
privateIntegerage;

privateAuthor(){
}

publicstaticAuthorinit(Stringname,Integerage){
Authorauthor=newAuthor();
author.setAge(age);
author.setName(name);
returnauthor;
}
//省略getter/setter/toString
}

這個類的特點就是構造方法是私有的，你沒法從外面去 new，現在我想將這個類的對象注冊到 Spring 容器中，那么我可以提供一個 AuthorFactoryBean：

publicclassAuthorFactoryBeanimplementsFactoryBean{
@Override
publicAuthorgetObject()throwsException{
returnAuthor.init("javaboy",99);
}

@Override
publicClassgetObjectType(){
returnAuthor.class;
}

@Override
publicbooleanisSingleton(){
returntrue;
}
}

然后在 Spring 容器中配置 AuthorFactoryBean 即可：

接下來我們就可以從容器中去獲取 Author 對象了，但是要注意，通過 author 這個名字拿到的是 Author 對象，而不是 AuthorFactoryBean 對象，如果想要獲取到 AuthorFactoryBean 對象，那么要通過 &author 這個名字去獲?。ɑ仡櫟谝恍」澦v內容）。

publicclassMain{
publicstaticvoidmain(String[]args){
ClassPathXmlApplicationContextctx=newClassPathXmlApplicationContext("applicationContext.xml");
Objectauthor=ctx.getBean("author");
ObjectauthorFactoryBean=ctx.getBean("&author");
System.out.println("author.getClass()="+author.getClass());
System.out.println("authorFactoryBean.getClass()="+authorFactoryBean.getClass());
}
}

來看下最終運行結果：

跟我們所想的一致吧～

3. 小結

經過前面的介紹，相信小伙伴們已經能夠區分 BeanFactory 和 FactoryBean 了，再來回顧一下本文開頭的內容：

BeanFactory 是 Spring 框架的核心接口之一，用于管理和獲取應用程序中的 Bean 實例。它是一個工廠模式的實現，負責創建、配置和管理 Bean 對象。BeanFactory 是 Spring IoC 容器的基礎，它可以從配置元數據（如 XML 文件）中讀取 Bean 的定義，并在需要時實例化和提供這些 Bean。

FactoryBean 是一個特殊的 Bean，它是一個工廠對象，用于創建和管理其他 Bean 的實例。FactoryBean 接口定義了一種創建 Bean 的方式，它允許開發人員在 Bean 的創建過程中進行更多的自定義操作。通過實現 FactoryBean 接口，開發人員可以創建復雜的 Bean 實例，或者在 Bean 實例化之前進行一些額外的邏輯處理。

區別在于，BeanFactory 是 Spring 框架的核心接口，用于管理和提供 Bean 實例，而 FactoryBean 是一個特殊的 Bean，用于創建和管理其他 Bean 的實例。FactoryBean 在 Bean 的創建過程中提供更多的自定義能力，允許進行額外的邏輯處理。

審核編輯：劉清