关于java:一道经典面试题BeanFactory-和-FactoryBean-有何区别

这也是 Spring 面试时一道经典的面试问题，明天咱们来聊一聊这个话题。

其实从名字上就能看进去个一二，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 的创立过程中提供更多的自定义能力，容许进行额定的逻辑解决。

可能有的小伙伴看的还不是很分明，咱们再来具体看下。

BeanFactory 看名字就晓得这是一个 Bean 工厂，小伙伴们晓得，Spring IoC 容器帮咱们实现了 Bean 的创立、治理等操作，那么这些操作都离不开 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 名字加一个 & 前缀，这个我在第二大节和小伙伴们演示。
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 的特点，大家明确了吧～

FactoryBean 其实很多小伙伴可能都见过，只是可能没去总结演绎。我给小伙伴们举几个例子。

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

如果咱们前端传递的参数是 key-value 格局，并且有一个日期，那么小伙伴们晓得，服务端 SpringMVC 默认无奈解决这个日期，须要配置一个日期转换器，个别咱们在 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，都不是正经 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 须要实现 FactoryBean 接口，并且在实现接口的时候指定泛型是 SqlSessionFactory，也就是 SqlSessionFactoryBean 最终产出的 Bean 是 SqlSessionFactory。实现了 FactoryBean 接口之后，就须要实现接口中的三个办法：

getObject：这个办法返回的对象，就是真正要注册到 Spring 容器中的对象，在这个办法中，咱们就能够依照各种形式对 Bean 进行各种配置了。
getObjectType：这个办法返回注册到 Spring 容器中的对象类型。
isSingleton：这个办法用来返回注册到 Spring 容器中的 Bean 是否是单例的。

这就是 FactoryBean 的特点，因为某一个 Bean 的初始化过于简单，那么就能够通过 FactoryBean 来帮忙注册到 Spring 容器中去。

松哥再写一个简略的例子给小伙伴们体验一把 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
}

这个类的特点就是构造方法是公有的，你没法从里面去 new，当初我想将这个类的对象注册到 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 这个名字去获取（回顾第一大节所讲内容）。

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

来看下最终运行后果：

跟咱们所想的统一吧～

通过后面的介绍，置信小伙伴们曾经可能辨别 BeanFactory 和 FactoryBean 了，再来回顾一下本文结尾的内容：

BeanFactory 是 Spring 框架的外围接口之一，用于治理和获取应用程序中的 Bean 实例。它是一个工厂模式的实现，负责创立、配置和治理 Bean 对象。BeanFactory 是 Spring IoC 容器的根底，它能够从配置元数据（如 XML 文件）中读取 Bean 的定义，并在须要时实例化和提供这些 Bean。
FactoryBean 是一个非凡的 Bean，它是一个工厂对象，用于创立和治理其余 Bean 的实例。FactoryBean 接口定义了一种创立 Bean 的形式，它容许开发人员在 Bean 的创立过程中进行更多的自定义操作。通过实现 FactoryBean 接口，开发人员能够创立简单的 Bean 实例，或者在 Bean 实例化之前进行一些额定的逻辑解决。

关于java:一道经典面试题BeanFactory-和-FactoryBean-有何区别

1. BeanFactory

2. FactoryBean

2.1 剖析

2.2 实际

3. 小结

Just My Socks（注册教程内含优惠码）

关于java:一道经典面试题BeanFactory-和-FactoryBean-有何区别

1. BeanFactory

2. FactoryBean

2.1 剖析

2.2 实际

3. 小结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）