Spring 中 BeanFactory 和 FactoryBean 有何區(qū)別？
這也是 Spring 面試時一道經(jīng)典的面試問題，今天我們來聊一聊這個話題。
其實從名字上就能看出來個一二，BeanFactory 是 Factory 而 FactoryBean 是一個 Bean，我們先來看下總結(jié)：
- BeanFactory 是 Spring 框架的核心接口之一，用于管理和獲取應用程序中的 Bean 實例。它是一個工廠模式的實現(xiàn)，負責創(chuàng)建、配置和管理 Bean 對象。BeanFactory 是 Spring IoC 容器的基礎，它可以從配置元數(shù)據(jù)（如 XML 文件）中讀取 Bean 的定義，并在需要時實例化和提供這些 Bean。
- FactoryBean 是一個特殊的 Bean，它是一個工廠對象，用于創(chuàng)建和管理其他 Bean 的實例。FactoryBean 接口定義了一種創(chuàng)建 Bean 的方式，它允許開發(fā)人員在 Bean 的創(chuàng)建過程中進行更多的自定義操作。通過實現(xiàn) FactoryBean 接口，開發(fā)人員可以創(chuàng)建復雜的 Bean 實例，或者在 Bean 實例化之前進行一些額外的邏輯處理。
區(qū)別在于，BeanFactory 是 Spring 框架的核心接口，用于管理和提供 Bean 實例，而 FactoryBean 是一個特殊的 Bean，用于創(chuàng)建和管理其他 Bean 的實例。FactoryBean 在 Bean 的創(chuàng)建過程中提供更多的自定義能力，允許進行額外的邏輯處理。
可能有的小伙伴看的還不是很清楚，我們再來詳細看下。
1. BeanFactory
BeanFactory 看名字就知道這是一個 Bean 工廠，小伙伴們知道，Spring IoC 容器幫我們完成了 Bean 的創(chuàng)建、管理等操作，那么這些操作都離不開 BeanFactory。
我們來簡單看下 BeanFactory 的代碼：
public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
boolean containsBean(String name);
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
}這些方法基本上都見名知義：
- FACTORY_BEAN_PREFIX：這個變量其實是說，如果當前 Bean 不是像 User、Book 這種普通 Bean，而是一個 FactoryBean，就給這個 Bean 名字加一個 & 前綴，這個我在第二小節(jié)和小伙伴們演示。
- getBean：這個方法就是根據(jù) Bean 的名字、類型等去查詢 Bean。
- getBeanProvider：這個方法可以獲取一個 ObjectProvider，ObjectProvider 是 Spring 框架中的一個接口，用于獲取 Bean 對象的實例。它提供了一種延遲加載 Bean 的方式，可以在需要時動態(tài)地獲取 Bean 實例（懶加載）。
- containsBean：判斷是否包含某個 Bean。
- isSingleton：判斷某個 Bean 是否是單例的。
- isPrototype：判斷某個 Bean 是否是多例的。
- isTypeMatch：判斷某一個 Bean 的類型是否是給定類型。
- getType：獲取 Bean 的類型。
- getAliases：獲取 Bean 的別名。
可以看到，很多都是大家日常開發(fā)中常見常用的方法。
很多小伙伴剛開始接觸 Spring 的時候，都會用到一個對象 ClassPathXmlApplicationContext，這其實就是 BeanFactory 的一個子類。我們來看下 BeanFactory 的繼承圖：
圖片
繼承類比較多，我說幾個大家可能比較熟悉的：
- ClassPathXmlApplicationContext：這個是 Spring 容器啟動時，從當前類路徑下去加載 XML 配置文件，參數(shù)就是 classpath 下 XML 的文件路徑。
- FileSystemXmlApplicationContext：這個是 Spring 容器啟動時，從文件系統(tǒng)中去加載 XML 配置文件，參數(shù)一個絕對路徑。
- AnnotationConfigApplicationContext：這個是如果我們使用 Java 代碼去做 Spring 容器的配置的話，通過這個配置類去加載 Java 配置類。
- DefaultListableBeanFactory：這個默認實現(xiàn)了 ListableBeanFactory 和 BeanDefinitionRegistry 接口，是一個比較成熟的 BeanFactory。
好啦，這就是 BeanFactory 的特點，大家明白了吧～
2. FactoryBean
2.1 分析
FactoryBean 其實很多小伙伴可能都見過，只是可能沒去總結(jié)歸納。我給小伙伴們舉幾個例子。
在 SSM 項目中，如果我們要配置 MyBatis 到項目中，一般需要配置下面這個 Bean：
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="typeAliasesPackage" value="org.javaboy.shirodemo.model"/>
<property name="mapperLocations">
<list>
<value>classpath*:org/javaboy/shirodemo/mapper/*.xml</value>
</list>
</property>
</bean>我們在配置 Shiro 的時候，一般都要配置如下 Bean：
<bean class="org.apache.shiro.spring.web.ShiroFilterFactoryBean" id="shiroFilter">
<property name="securityManager" ref="securityManager"/>
<property name="loginUrl" value="/login"/>
<property name="successUrl" value="/index"/>
<property name="unauthorizedUrl" value="/unauthorizedUrl"/>
<property name="filterChainDefinitions">
<value>
/index=anon
/doLogin=anon
/hello=user
/**=authc
</value>
</property>
</bean>如果我們前端傳遞的參數(shù)是 key-value 格式，并且有一個日期，那么小伙伴們知道，服務端 SpringMVC 默認無法處理這個日期，需要配置一個日期轉(zhuǎn)換器，一般我們在 Spring 容器中添加如下 Bean（對這個不熟悉的小伙伴可以在公眾號【江南一點雨】后臺回復 ssm，有松哥錄制的免費入門視頻）：
<bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean" id="conversionService">
<property name="converters">
<set>
<ref bean="myDateConverter"/>
</set>
</property>
</bean>
<mvc:annotation-driven conversion-service="conversionService"/>小伙伴們觀察上面三個 Bean 有一個共同的特點，那就是 Bean 的名字都是 xxxFactoryBean。
為什么要用 xxxFactoryBean 而不直接把需要的 Bean 注入到 Spring 容器中去呢？以 MyBatis 為例：
手動配置過 MyBatis 的小伙伴應該都知道，MyBatis 有兩個重要的類，一個是 SqlSessionFactory，還有一個是 SqlSession，通過 SqlSessionFactory 可以獲取到一個 SqlSession。但是不知道小伙伴們是否還記得配置代碼，手動配置代碼如下（對這個不熟悉的小伙伴可以在公眾號【江南一點雨】后臺回復 ssm，有松哥錄制的免費入門視頻）：
public class SqlSessionFactoryUtils {
private static SqlSessionFactory SQLSESSIONFACTORY = null;
public static SqlSessionFactory getInstance() {
if (SQLSESSIONFACTORY == null) {
try {
SQLSESSIONFACTORY = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
} catch (IOException e) {
e.printStackTrace();
}
}
return SQLSESSIONFACTORY;
}
}
public class Main {
public static void main(String[] args) {
SqlSessionFactory factory = SqlSessionFactoryUtils.getInstance();
SqlSession sqlSession = factory.openSession();
List<User> list = sqlSession.selectList("org.javaboy.mybatis01.mapper.UserMapper.getAllUser");
for (User user : list) {
System.out.println("user = " + user);
}
sqlSession.close();
}
}小伙伴們看到，無論是 SqlSessionFactory 還是 SqlSession，都不是正經(jīng) new 出來的，其實這兩個都是接口，顯然不可能 new 出來，前者通過建造者模式去配置各種屬性，最后生成一個 SqlSessionFactory 的實例，后者則通過前者這個工廠去生成，最終拿到的都是這兩個接口的子類的對象。
所以，對于 SqlSessionFactory 和 SqlSession 就沒法在 Spring 容器中直接進行配置，那么對于這樣的 Bean，就可以通過 xxxFactoryBean 來進行配置。
我們來看下 SqlSessionFactoryBean 類，源碼很長，我挑了重要的出來：
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
private SqlSessionFactory sqlSessionFactory;
@Override
public SqlSessionFactory getObject() throws Exception {
if (this.sqlSessionFactory == null) {
afterPropertiesSet();
}
return this.sqlSessionFactory;
}
@Override
public Class<? extends SqlSessionFactory> getObjectType() {
return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
}
@Override
public boolean isSingleton() {
return true;
}
}大家看一下，SqlSessionFactoryBean 需要實現(xiàn) FactoryBean 接口，并且在實現(xiàn)接口的時候指定泛型是 SqlSessionFactory，也就是 SqlSessionFactoryBean 最終產(chǎn)出的 Bean 是 SqlSessionFactory。實現(xiàn)了 FactoryBean 接口之后，就需要實現(xiàn)接口中的三個方法：
- getObject：這個方法返回的對象，就是真正要注冊到 Spring 容器中的對象，在這個方法中，我們就可以按照各種方式對 Bean 進行各種配置了。
- getObjectType：這個方法返回注冊到 Spring 容器中的對象類型。
- isSingleton：這個方法用來返回注冊到 Spring 容器中的 Bean 是否是單例的。
這就是 FactoryBean 的特點，由于某一個 Bean 的初始化過于復雜，那么就可以通過 FactoryBean 來幫助注冊到 Spring 容器中去。
2.2 實踐
松哥再寫一個簡單的例子給小伙伴們體驗一把 FactoryBean。
假設我有如下類：
public class Author {
private String name;
private Integer age;
private Author() {
}
public static Author init(String name, Integer age) {
Author author = new Author();
author.setAge(age);
author.setName(name);
return author;
}
//省略 getter/setter/toString
}這個類的特點就是構(gòu)造方法是私有的，你沒法從外面去 new，現(xiàn)在我想將這個類的對象注冊到 Spring 容器中，那么我可以提供一個 AuthorFactoryBean：
public class AuthorFactoryBean implements FactoryBean<Author> {
@Override
public Author getObject() throws Exception {
return Author.init("javaboy", 99);
}
@Override
public Class<?> getObjectType() {
return Author.class;
}
@Override
public boolean isSingleton() {
return true;
}
}然后在 Spring 容器中配置 AuthorFactoryBean 即可：
<bean class="org.javaboy.bean.AuthorFactoryBean" id="author"/>接下來我們就可以從容器中去獲取 Author 對象了，但是要注意，通過 author 這個名字拿到的是 Author 對象，而不是 AuthorFactoryBean 對象，如果想要獲取到 AuthorFactoryBean 對象，那么要通過 &author 這個名字去獲?。ɑ仡櫟谝恍」?jié)所講內(nèi)容）。
public class Main {
public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Object author = ctx.getBean("author");
Object authorFactoryBean = ctx.getBean("&author");
System.out.println("author.getClass() = " + author.getClass());
System.out.println("authorFactoryBean.getClass() = " + authorFactoryBean.getClass());
}
}來看下最終運行結(jié)果：
圖片
跟我們所想的一致吧～
3. 小結(jié)
經(jīng)過前面的介紹，相信小伙伴們已經(jīng)能夠區(qū)分 BeanFactory 和 FactoryBean 了，再來回顧一下本文開頭的內(nèi)容：
- BeanFactory 是 Spring 框架的核心接口之一，用于管理和獲取應用程序中的 Bean 實例。它是一個工廠模式的實現(xiàn)，負責創(chuàng)建、配置和管理 Bean 對象。BeanFactory 是 Spring IoC 容器的基礎，它可以從配置元數(shù)據(jù)（如 XML 文件）中讀取 Bean 的定義，并在需要時實例化和提供這些 Bean。
- FactoryBean 是一個特殊的 Bean，它是一個工廠對象，用于創(chuàng)建和管理其他 Bean 的實例。FactoryBean 接口定義了一種創(chuàng)建 Bean 的方式，它允許開發(fā)人員在 Bean 的創(chuàng)建過程中進行更多的自定義操作。通過實現(xiàn) FactoryBean 接口，開發(fā)人員可以創(chuàng)建復雜的 Bean 實例，或者在 Bean 實例化之前進行一些額外的邏輯處理。
區(qū)別在于，BeanFactory 是 Spring 框架的核心接口，用于管理和提供 Bean 實例，而 FactoryBean 是一個特殊的 Bean，用于創(chuàng)建和管理其他 Bean 的實例。FactoryBean 在 Bean 的創(chuàng)建過程中提供更多的自定義能力，允許進行額外的邏輯處理。
