這也是 Spring 面試時(shí)一道經(jīng)典的面試問題，今天我們來聊一聊這個(gè)話題。

其實(shí)從名字上就能看出來個(gè)一二，BeanFactory 是 Factory 而 FactoryBean 是一個(gè) Bean，我們先來看下總結(jié)：

• BeanFactory 是 Spring 框架的核心接口之一，用于管理和獲取應(yīng)用程序中的 Bean 實(shí)例。它是一個(gè)工廠模式的實(shí)現(xiàn)，負(fù)責(zé)創(chuàng)建、配置和管理 Bean 對(duì)象。BeanFactory 是 Spring IoC 容器的基礎(chǔ)，它可以從配置元數(shù)據(jù)（如 XML 文件）中讀取 Bean 的定義，并在需要時(shí)實(shí)例化和提供這些 Bean。
• FactoryBean 是一個(gè)特殊的 Bean，它是一個(gè)工廠對(duì)象，用于創(chuàng)建和管理其他 Bean 的實(shí)例。FactoryBean 接口定義了一種創(chuàng)建 Bean 的方式，它允許開發(fā)人員在 Bean 的創(chuàng)建過程中進(jìn)行更多的自定義操作。通過實(shí)現(xiàn) FactoryBean 接口，開發(fā)人員可以創(chuàng)建復(fù)雜的 Bean 實(shí)例，或者在 Bean 實(shí)例化之前進(jìn)行一些額外的邏輯處理。

區(qū)別在于，BeanFactory 是 Spring 框架的核心接口，用于管理和提供 Bean 實(shí)例，而 FactoryBean 是一個(gè)特殊的 Bean，用于創(chuàng)建和管理其他 Bean 的實(shí)例。FactoryBean 在 Bean 的創(chuàng)建過程中提供更多的自定義能力，允許進(jìn)行額外的邏輯處理。

可能有的小伙伴看的還不是很清楚，我們?cè)賮碓敿?xì)看下。

1. BeanFactory

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

我們來簡(jiǎn)單看下 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：這個(gè)變量其實(shí)是說，如果當(dāng)前 Bean 不是像 User、Book 這種普通 Bean，而是一個(gè) FactoryBean，就給這個(gè) Bean 名字加一個(gè) & 前綴，這個(gè)我在第二小節(jié)和小伙伴們演示。
• getBean：這個(gè)方法就是根據(jù) Bean 的名字、類型等去查詢 Bean。
• getBeanProvider：這個(gè)方法可以獲取一個(gè) ObjectProvider，ObjectProvider 是 Spring 框架中的一個(gè)接口，用于獲取 Bean 對(duì)象的實(shí)例。它提供了一種延遲加載 Bean 的方式，可以在需要時(shí)動(dòng)態(tài)地獲取 Bean 實(shí)例（懶加載）。
• containsBean：判斷是否包含某個(gè) Bean。
• isSingleton：判斷某個(gè) Bean 是否是單例的。
• isPrototype：判斷某個(gè) Bean 是否是多例的。
• isTypeMatch：判斷某一個(gè) Bean 的類型是否是給定類型。
• getType：獲取 Bean 的類型。
• getAliases：獲取 Bean 的別名。

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

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

圖片

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

1. ClassPathXmlApplicationContext：這個(gè)是 Spring 容器啟動(dòng)時(shí)，從當(dāng)前類路徑下去加載 XML 配置文件，參數(shù)就是 classpath 下 XML 的文件路徑。
2. FileSystemXmlApplicationContext：這個(gè)是 Spring 容器啟動(dòng)時(shí)，從文件系統(tǒng)中去加載 XML 配置文件，參數(shù)一個(gè)絕對(duì)路徑。
3. AnnotationConfigApplicationContext：這個(gè)是如果我們使用 Java 代碼去做 Spring 容器的配置的話，通過這個(gè)配置類去加載 Java 配置類。
4. DefaultListableBeanFactory：這個(gè)默認(rèn)實(shí)現(xiàn)了 ListableBeanFactory 和 BeanDefinitionRegistry 接口，是一個(gè)比較成熟的 BeanFactory。

好啦，這就是 BeanFactory 的特點(diǎn)，大家明白了吧～

2. FactoryBean

2.1 分析

FactoryBean 其實(shí)很多小伙伴可能都見過，只是可能沒去總結(jié)歸納。我給小伙伴們舉幾個(gè)例子。

在 SSM 項(xiàng)目中，如果我們要配置 MyBatis 到項(xiàng)目中，一般需要配置下面這個(gè) 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>

我們?cè)谂渲?Shiro 的時(shí)候，一般都要配置如下 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 格式，并且有一個(gè)日期，那么小伙伴們知道，服務(wù)端 SpringMVC 默認(rèn)無法處理這個(gè)日期，需要配置一個(gè)日期轉(zhuǎn)換器，一般我們?cè)?Spring 容器中添加如下 Bean（對(duì)這個(gè)不熟悉的小伙伴可以在公眾號(hào)【江南一點(diǎn)雨】后臺(tái)回復(fù) ssm，有松哥錄制的免費(fèi)入門視頻）：

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

小伙伴們觀察上面三個(gè) Bean 有一個(gè)共同的特點(diǎn)，那就是 Bean 的名字都是 xxxFactoryBean。

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

手動(dòng)配置過 MyBatis 的小伙伴應(yīng)該都知道，MyBatis 有兩個(gè)重要的類，一個(gè)是 SqlSessionFactory，還有一個(gè)是 SqlSession，通過 SqlSessionFactory 可以獲取到一個(gè) SqlSession。但是不知道小伙伴們是否還記得配置代碼，手動(dòng)配置代碼如下（對(duì)這個(gè)不熟悉的小伙伴可以在公眾號(hào)【江南一點(diǎn)雨】后臺(tái)回復(fù) ssm，有松哥錄制的免費(fèi)入門視頻）：

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 出來的，其實(shí)這兩個(gè)都是接口，顯然不可能 new 出來，前者通過建造者模式去配置各種屬性，最后生成一個(gè) SqlSessionFactory 的實(shí)例，后者則通過前者這個(gè)工廠去生成，最終拿到的都是這兩個(gè)接口的子類的對(duì)象。

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

我們來看下 SqlSessionFactoryBean 類，源碼很長(zhǎng)，我挑了重要的出來：

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 需要實(shí)現(xiàn) FactoryBean 接口，并且在實(shí)現(xiàn)接口的時(shí)候指定泛型是 SqlSessionFactory，也就是 SqlSessionFactoryBean 最終產(chǎn)出的 Bean 是 SqlSessionFactory。實(shí)現(xiàn)了 FactoryBean 接口之后，就需要實(shí)現(xiàn)接口中的三個(gè)方法：

• getObject：這個(gè)方法返回的對(duì)象，就是真正要注冊(cè)到 Spring 容器中的對(duì)象，在這個(gè)方法中，我們就可以按照各種方式對(duì) Bean 進(jìn)行各種配置了。
• getObjectType：這個(gè)方法返回注冊(cè)到 Spring 容器中的對(duì)象類型。
• isSingleton：這個(gè)方法用來返回注冊(cè)到 Spring 容器中的 Bean 是否是單例的。

這就是 FactoryBean 的特點(diǎn)，由于某一個(gè) Bean 的初始化過于復(fù)雜，那么就可以通過 FactoryBean 來幫助注冊(cè)到 Spring 容器中去。

2.2 實(shí)踐

松哥再寫一個(gè)簡(jiǎn)單的例子給小伙伴們體驗(yàn)一把 FactoryBean。

假設(shè)我有如下類：

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è)類的特點(diǎn)就是構(gòu)造方法是私有的，你沒法從外面去 new，現(xiàn)在我想將這個(gè)類的對(duì)象注冊(cè)到 Spring 容器中，那么我可以提供一個(gè) 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 對(duì)象了，但是要注意，通過 author 這個(gè)名字拿到的是 Author 對(duì)象，而不是 AuthorFactoryBean 對(duì)象，如果想要獲取到 AuthorFactoryBean 對(duì)象，那么要通過 &author 這個(gè)名字去獲取（回顧第一小節(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());
    }
}

來看下最終運(yùn)行結(jié)果：

圖片

跟我們所想的一致吧～

3. 小結(jié)

經(jīng)過前面的介紹，相信小伙伴們已經(jīng)能夠區(qū)分 BeanFactory 和 FactoryBean 了，再來回顧一下本文開頭的內(nèi)容：

• BeanFactory 是 Spring 框架的核心接口之一，用于管理和獲取應(yīng)用程序中的 Bean 實(shí)例。它是一個(gè)工廠模式的實(shí)現(xiàn)，負(fù)責(zé)創(chuàng)建、配置和管理 Bean 對(duì)象。BeanFactory 是 Spring IoC 容器的基礎(chǔ)，它可以從配置元數(shù)據(jù)（如 XML 文件）中讀取 Bean 的定義，并在需要時(shí)實(shí)例化和提供這些 Bean。
• FactoryBean 是一個(gè)特殊的 Bean，它是一個(gè)工廠對(duì)象，用于創(chuàng)建和管理其他 Bean 的實(shí)例。FactoryBean 接口定義了一種創(chuàng)建 Bean 的方式，它允許開發(fā)人員在 Bean 的創(chuàng)建過程中進(jìn)行更多的自定義操作。通過實(shí)現(xiàn) FactoryBean 接口，開發(fā)人員可以創(chuàng)建復(fù)雜的 Bean 實(shí)例，或者在 Bean 實(shí)例化之前進(jìn)行一些額外的邏輯處理。

區(qū)別在于，BeanFactory 是 Spring 框架的核心接口，用于管理和提供 Bean 實(shí)例，而 FactoryBean 是一個(gè)特殊的 Bean，用于創(chuàng)建和管理其他 Bean 的實(shí)例。FactoryBean 在 Bean 的創(chuàng)建過程中提供更多的自定義能力，允許進(jìn)行額外的邏輯處理。