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

2次阅读

共计 7769 个字符，预计需要花费 20 分钟才能阅读完成。

这也是 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 的创立过程中提供更多的自定义能力，容许进行额定的逻辑解决。

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

1. BeanFactory

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 的继承图：

继承类比拟多，我说几个大家可能比拟相熟的：

  1. ClassPathXmlApplicationContext：这个是 Spring 容器启动时，从以后类门路上来加载 XML 配置文件，参数就是 classpath 下 XML 的文件门路。
  2. FileSystemXmlApplicationContext：这个是 Spring 容器启动时，从文件系统中去加载 XML 配置文件，参数一个绝对路径。
  3. AnnotationConfigApplicationContext：这个是如果咱们应用 Java 代码去做 Spring 容器的配置的话，通过这个配置类去加载 Java 配置类。
  4. DefaultListableBeanFactory：这个默认实现了 ListableBeanFactory 和 BeanDefinitionRegistry 接口，是一个比拟成熟的 BeanFactory。

好啦，这就是 BeanFactory 的特点，大家明确了吧～

2. FactoryBean

2.1 剖析

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 容器中去。

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
}

这个类的特点就是构造方法是公有的，你没法从里面去 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());
    }
}

来看下最终运行后果：

跟咱们所想的统一吧～

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 的创立过程中提供更多的自定义能力，容许进行额定的逻辑解决。

正文完
java
发表至： java
2023-07-06
 0
关于java:图解HTTPpdf
Spring-Security-实战干货手把手教你实现JWT-Token
关于java:JAVA基础之文件流输入输出
关于java:微醺到底static还是static-final才会有ConstantValue

站内搜索

-「」