Spring 源码第 9 篇，深入分析 FactoryBean-低调大师

Spring 源码第 9 篇，深入分析 FactoryBean

2020-08-24 650

松哥原创的 Spring Boot 视频教程已经杀青，感兴趣的小伙伴戳这里-->Spring Boot+Vue+微人事视频教程

小伙伴们在面试的时候，有一个经典的问题：

Spring 中 FactoryBean 和 BeanFactory 有什么区别？

原本是风马牛不相及的两个东西，只是因为单词前后颠倒了一下，就变成了一个高频面试题！

在本系列前面文章中松哥在和大家分析 DefaultListableBeanFactory 容器的时候涉及到了一点点 BeanFactory 的知识，不过在那篇文章中 BeanFactory 毕竟不是主角，以后的文章松哥还会和大家再去探讨 BeanFactory 的功能。

今天我们就先来看看 FactoryBean 是什么？

只要我们分别将 FactoryBean 和 BeanFactory 的功能搞清楚，上面的那道面试题自然不在话下。

阅读本系列前面文章，有助于更好的理解本文：

1.一个 Demo

我们先从一个简单的 Demo 开始。

新建一个 Maven 项目，引入 Spring 依赖，然后创建一个 HelloService，如下：

public class HelloService {
    public String hello() {
        return "hello javaboy";
    }
}

然后再创建一个 HelloService 的工厂类：

public class HelloServiceFactoryBean implements FactoryBean<HelloService> {
    @Override
    public HelloService getObject() throws Exception {
        return new HelloService();
    }

    @Override
    public Class<?> getObjectType() {
        return HelloService.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

我们新建的 HelloServiceFactoryBean 类实现了 FactoryBean 接口，并指定了 HelloService 泛型。

接下来我们在 beans.xml 文件中配置 HelloServiceFactoryBean 实例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="org.javaboy.springdemo03.HelloServiceFactoryBean" id="helloService"/>
</beans>

加载该配置文件：

@Test
void contextLoads() {
    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
    Object helloService = ctx.getBean("helloService");
    System.out.println(helloService.getClass().toString());
}

加载 XML 配置文件，并获取 Bean 实例，然后将 Bean 实例的类型打印出来。

按照我们之前的理解，这里获取到的 Bean 应该是 HelloServiceFactoryBean 的实例，但是实际打印结果如下：

class org.javaboy.springdemo03.HelloService

竟然是 HelloService！

到底怎么回事？我们得从 FactoryBean 接口开始讲起。

2.FactoryBean 接口

FactoryBean 在 Spring 框架中具有重要地位，Spring 框架本身也为此提供了多种不同的实现类：

按理说我们配置一个 Bean，直接在 XML 文件中进行配置即可。但是有的时候一个类的属性非常多，在 XML 中配置起来反而非常不方便，这个时候 Java 代码配置的优势就体现出来了，使用 FactoryBean 就可以通过 Java 代码配置 Bean 的相关属性。

从 Spring3.0 开始，FactoryBean 开始支持泛型，就是大家所看到的 FactoryBean 形式，FactoryBean 接口中一共有三个方法：

public interface FactoryBean<T> {
 @Nullable
 T getObject() throws Exception;
 @Nullable
 Class<?> getObjectType();
 default boolean isSingleton() {
  return true;
 }

}

getObject：该方法返回 FactoryBean 所创建的实例，如果在 XML 配置文件中，我们提供的 class 是一个 FactoryBean 的话，那么当我们调用 getBean 方法去获取实例时，最终获取到的是 getObject 方法的返回值。
getObjectType：返回对象的类型。
isSingleton：getObject 方法所返回的对象是否单例。

所以当我们调用 getBean 方法去获取 Bean 实例的时候，实际上获取到的是 getObject 方法的返回值，那么是不是就没有办法获取 HelloServiceFactoryBean 呢？当然是有的！

@Test
void contextLoads() {
    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
    Object helloService = ctx.getBean("&helloService");
    System.out.println(helloService.getClass().toString());
}

打印结果如下：

class org.javaboy.springdemo03.HelloServiceFactoryBean

小伙伴们可以看到，只需要在 Bean 的名字前面加上一个 & 符号，获取到的就是 HelloServiceFactoryBean 实例了。

3.源码分析

根据 Spring 源码第六弹！松哥和大家聊聊容器的始祖 DefaultListableBeanFactory 一文中的介绍，在 DefaultListableBeanFactory 中还有一个 preInstantiateSingletons 方法可以提前注册 Bean，该方法是在 ConfigurableListableBeanFactory 接口中声明的，DefaultListableBeanFactory 类实现了 ConfigurableListableBeanFactory 接口并实现了接口中的方法：

@Override
public void preInstantiateSingletons() throws BeansException {
 if (logger.isTraceEnabled()) {
  logger.trace("Pre-instantiating singletons in " + this);
 }
 // Iterate over a copy to allow for init methods which in turn register new bean definitions.
 // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
 List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
 // Trigger initialization of all non-lazy singleton beans...
 for (String beanName : beanNames) {
  RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
   if (isFactoryBean(beanName)) {
    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    if (bean instanceof FactoryBean) {
     final FactoryBean<?> factory = (FactoryBean<?>) bean;
     boolean isEagerInit;
     if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
      isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
          ((SmartFactoryBean<?>) factory)::isEagerInit,
        getAccessControlContext());
     }
     else {
      isEagerInit = (factory instanceof SmartFactoryBean &&
        ((SmartFactoryBean<?>) factory).isEagerInit());
     }
     if (isEagerInit) {
      getBean(beanName);
     }
    }
   }
   else {
    getBean(beanName);
   }
  }
 }
 // Trigger post-initialization callback for all applicable beans...
 for (String beanName : beanNames) {
  Object singletonInstance = getSingleton(beanName);
  if (singletonInstance instanceof SmartInitializingSingleton) {
   final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
   if (System.getSecurityManager() != null) {
    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
     smartSingleton.afterSingletonsInstantiated();
     return null;
    }, getAccessControlContext());
   }
   else {
    smartSingleton.afterSingletonsInstantiated();
   }
  }
 }
}

preInstantiateSingletons 方法的整体逻辑比较简单，就是遍历 beanNames，对符合条件的 Bean 进行实例化，而且大家注意，这里所谓的提前初始化其实就是在我们调用 getBean 方法之前，它自己先调用了一下 getBean。

这里有几个比较关键的点。

第一个就是 isFactoryBean 方法的调用，该方法就是根据 beanName 去获取 Bean 实例，进而判断是不是一个 FactoryBean，如果没有 Bean 实例（还没创建出来），则根据 BeanDefinition 去判断是不是一个 FactoryBean。

如果是 FactoryBean，则在 getBean 时自动加上了 FACTORY_BEAN_PREFIX 前缀，这个常量其实就是 &，这样获取到的实例实际上就是 FactoryBean 的实例。获取到 FactoryBean 实例之后，接下来判断是否需要在容器启动阶段，调用 getObject 方法初始化 Bean，如果 isEagerInit 为 true，则去初始化。

按照我们前面的定义，这里获取到的 isEagerInit 属性为 false，即不提前加载 Bean，而是在开发者手动调用 getBean 的方法的时候才去加载。如果希望这里能够提前加载，需要重新定义 HelloServiceFactoryBean，并使之实现 SmartFactoryBean 接口，如下：

public class HelloServiceFactoryBean2 implements SmartFactoryBean<HelloService> {
    @Override
    public HelloService getObject() throws Exception {
        return new HelloService();
    }

    @Override
    public Class<?> getObjectType() {
        return HelloService.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    @Override
    public boolean isEagerInit() {
        return true;
    }
}

实现了 SmartFactoryBean 接口之后，重写 isEagerInit 方法并返回 true，其他方法不变，重新配置 beans.xml 文件，然后启动容器。此时在容器启动时，就会提前调用 getBean 方法完成 Bean 的加载。

接下来我们来看 getBean 方法。

getBean 方法首先调用 AbstractBeanFactory#doGetBean，在该方法中，又会调用到 AbstractBeanFactory#getObjectForBeanInstance 方法：

protected Object getObjectForBeanInstance(
  Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
 // Don't let calling code try to dereference the factory if the bean isn't a factory.
 if (BeanFactoryUtils.isFactoryDereference(name)) {
  if (beanInstance instanceof NullBean) {
   return beanInstance;
  }
  if (!(beanInstance instanceof FactoryBean)) {
   throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
  }
  if (mbd != null) {
   mbd.isFactoryBean = true;
  }
  return beanInstance;
 }
 // Now we have the bean instance, which may be a normal bean or a FactoryBean.
 // If it's a FactoryBean, we use it to create a bean instance, unless the
 // caller actually wants a reference to the factory.
 if (!(beanInstance instanceof FactoryBean)) {
  return beanInstance;
 }
 Object object = null;
 if (mbd != null) {
  mbd.isFactoryBean = true;
 }
 else {
  object = getCachedObjectForFactoryBean(beanName);
 }
 if (object == null) {
  // Return bean instance from factory.
  FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
  // Caches object obtained from FactoryBean if it is a singleton.
  if (mbd == null && containsBeanDefinition(beanName)) {
   mbd = getMergedLocalBeanDefinition(beanName);
  }
  boolean synthetic = (mbd != null && mbd.isSynthetic());
  object = getObjectFromFactoryBean(factory, beanName, !synthetic);
 }
 return object;
}

这段源码很有意思：

BeanFactoryUtils.isFactoryDereference 方法用来判断 name 是不是以 & 开头的，如果是以 & 开头的，表示想要获取的是一个 FactoryBean，那么此时如果 beanInstance 刚好就是一个 FactoryBean，则直接返回。并将 mbd 中的 isFactoryBean 属性设置为 true。

如果 name 不是以 & 开头的，说明用户就是想获取 FactoryBean 所构造的 Bean，那么此时如果 beanInstance 不是 FactoryBean 实例，则直接返回。

如果当前的 beanInstance 是一个 FactoryBean，而用户想获取的只是一个普通 Bean，那么就会进入到接下来的代码中。

首先调用 getCachedObjectForFactoryBean 方法去从缓存中获取 Bean。如果是第一次获取 Bean，这个缓存中是没有的数据的，getObject 方法调用过一次之后，Bean 才有可能被保存到缓存中了。

为什么说有可能呢？Bean 如果是单例的，则会被保存在缓存中，Bean 如果不是单例的，则不会被保存在缓存中，而是每次加载都去创建新的。

如果没能从缓存中加载到 Bean，则最终会调用 getObjectFromFactoryBean 方法去加载 Bean。

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
 if (factory.isSingleton() && containsSingleton(beanName)) {
  synchronized (getSingletonMutex()) {
   Object object = this.factoryBeanObjectCache.get(beanName);
   if (object == null) {
    object = doGetObjectFromFactoryBean(factory, beanName);
    // Only post-process and store if not put there already during getObject() call above
    // (e.g. because of circular reference processing triggered by custom getBean calls)
    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
    if (alreadyThere != null) {
     object = alreadyThere;
    }
    else {
     if (shouldPostProcess) {
      if (isSingletonCurrentlyInCreation(beanName)) {
       // Temporarily return non-post-processed object, not storing it yet..
       return object;
      }
      beforeSingletonCreation(beanName);
      try {
       object = postProcessObjectFromFactoryBean(object, beanName);
      }
      catch (Throwable ex) {
       throw new BeanCreationException(beanName,
         "Post-processing of FactoryBean's singleton object failed", ex);
      }
      finally {
       afterSingletonCreation(beanName);
      }
     }
     if (containsSingleton(beanName)) {
      this.factoryBeanObjectCache.put(beanName, object);
     }
    }
   }
   return object;
  }
 }
 else {
  Object object = doGetObjectFromFactoryBean(factory, beanName);
  if (shouldPostProcess) {
   try {
    object = postProcessObjectFromFactoryBean(object, beanName);
   }
   catch (Throwable ex) {
    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
   }
  }
  return object;
 }
}

在 getObjectFromFactoryBean 方法中，首先通过 isSingleton 和 containsSingleton 两个方法判断 getObject 方法返回值是否是单例的，单例的走一条路，非单例的走另外一条路。

如果是单例的：

先去缓存中再拿一次，看能不能拿到。如果缓存中没有，调用 doGetObjectFromFactoryBean 方法去获取，这是真正的获取方法。获取到之后，进行 Bean 的后置处理，处理完成后，如果 Bean 是单例的，就缓存起来。

如果不是单例的：

不是单例就简单，直接调用 doGetObjectFromFactoryBean 方法获取 Bean 实例，然后进行后置处理就完事，也不用缓存。

接下来我们就来看看 doGetObjectFromFactoryBean 方法：

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
 Object object;
 try {
  if (System.getSecurityManager() != null) {
   AccessControlContext acc = getAccessControlContext();
   try {
    object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
   }
   catch (PrivilegedActionException pae) {
    throw pae.getException();
   }
  }
  else {
   object = factory.getObject();
  }
 }
 catch (FactoryBeanNotInitializedException ex) {
  throw new BeanCurrentlyInCreationException(beanName, ex.toString());
 }
 catch (Throwable ex) {
  throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
 }
 // Do not accept a null value for a FactoryBean that's not fully
 // initialized yet: Many FactoryBeans just return null then.
 if (object == null) {
  if (isSingletonCurrentlyInCreation(beanName)) {
   throw new BeanCurrentlyInCreationException(
     beanName, "FactoryBean which is currently in creation returned null from getObject");
  }
  object = new NullBean();
 }
 return object;
}

做了一些判断之后，最终通过 factory.getObject(); 方法获取我们想要的实例。

这就是整个 FactoryBean 的加载流程。

4.应用

FactoryBean 在 Spring 框架中有非常广泛的应用，即使我们不写上面那段代码，也还是使用了不少的 FactoryBean。

接下来松哥随便举两个例子。

4.1 SqlSessionFactoryBean

这可能是大家接触最多的 FactoryBean，当 MyBatis 整合 Spring 时，我们少不了如下一行配置：

<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="typeAliasesPackage" value="org.javaboy.meeting.model"/>
    <property name="mapperLocations">
        <value>
            classpath*:org/javaboy/meeting/mapper/*.xml
        </value>
    </property>
</bean>

这就是在配置 FactoryBean。当我们单独使用 MyBatis 时候，需要有一个 SqlSessionFactory（公众号江南一点雨后台回复 MyBatis 有 MyBatis 教程），现在整合之后，没有 SqlSessionFactory 了，我们有理由相信是 SqlSessionFactoryBean 的 getObject 方法提供了 SqlSessionFactory，我们来看下其源码：

@Override
public SqlSessionFactory getObject() throws Exception {
  if (this.sqlSessionFactory == null) {
    afterPropertiesSet();
  }
  return this.sqlSessionFactory;
}

确实如此！

4.2 Jackson2ObjectMapperFactoryBean

这也是一个大家使用相对较多的 FactoryBean。

如果项目中使用了 Jackson，同时希望在全局层面做一些配置，一般来说我们可能会用到这个类：

<mvc:annotation-driven conversion-service="conversionService">
    <mvc:message-converters>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="simpleDateFormat" value="yyyy-MM-dd"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

MappingJackson2HttpMessageConverter 类的 objectMapper 属性实际上是需要一个 ObjectMapper 对象，但是我们这里却提供了一个 Jackson2ObjectMapperFactoryBean，这是因为 Jackson2ObjectMapperFactoryBean 的 getObject 方法就是我们需要的 ObjectMapper：

@Override
@Nullable
public ObjectMapper getObject() {
 return this.objectMapper;
}

4.3 FormattingConversionServiceFactoryBean

FormattingConversionServiceFactoryBean 也曾经出现在松哥的 SpringMVC 教程中（公众号江南一点雨后台回复 springmvc 获取教程）。

如果前端传递的参数格式是 key-value 形式，那么日期类型的参数需要服务端提供一个日期类型转换器，像下面这样：

@Component
public class DateConverter implements Converter<String, Date> {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    public Date convert(String source) {
        try {
            return sdf.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
}

然后在 XML 文件中对此进行配置：

<mvc:annotation-driven conversion-service="conversionService"/>
<bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean" id="conversionService">
    <property name="converters">
        <set>
            <ref bean="dateConverter"/>
        </set>
    </property>
</bean>

FormattingConversionServiceFactoryBean 中的 getObject 方法最终返回的是 FormattingConversionService。

类似的例子还有很多，例如 EhCacheManagerFactoryBean、YamlPropertiesFactoryBean 等，松哥就不一一赘述了，感兴趣的小伙伴可以自行查看。

5.小结

好啦，今天就和小伙伴们聊一聊 FactoryBean，讲了它的源码，也讲了它的用法，后面再来和大家聊一聊 BeanFactory，两个都聊完了了，文章一开始提出的面试题就不在话下了。

小伙伴们觉得有收获，记得点个在看鼓励下松哥哦～

274 页 pdf 文档，Spring Boot 教程也有离线版了

喜欢就点个"在看"呗^_^

本文分享自微信公众号 - 江南一点雨（a_javaboy）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

微信关注我们

原文链接：https://my.oschina.net/u/3669799/blog/4525943

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

DaemonSet确保节点运行一个 Pod 的副本

1、简介 DaemonSet 确保全部（或者某些）节点上运行一个 Pod 的副本。当有节点加入集群时，也会为他们新增一个 Pod 。当有节点从集群移除时，这些 Pod 也会被回收。删除 DaemonSet 将会删除它创建的所有 Pod。 DaemonSet 的一些典型用法：在每个节点上运行集群存守护进程。例如 glusterd、ceph 在每个节点上运行日志收集守护进程。例如 fluentd、logstash 在每个节点上运行监控守护进程。例如 Prometheus Node Exporter、Sysdig Agent、collectd、Dynatrace OneAgent、APPDynamics Agent、Datadog agent、New Relic agent、Ganglia gmond、Instana Agent 等一种简单的用法是为每种类型的守护进程在所有的节点上都启动一个 DaemonSet。一个稍微复杂的用法是为同一种守护进程部署多个 DaemonSet；每个具有不同的标志，并且对不同硬件类型具有不同的内存、CPU 要求。 2、创建DaemonSet Googl...

2020-08-24

637

微服务，这三个字正在席卷着目前的互联网软件行业，尤其在近几年云原生迸发后，似乎人人都对微服务有了更广泛的使用和理解，张口就是各种各样的问号，有着强大的好奇心。无独有偶，我有一个朋友鲤鱼在内部微服务的早期（每个业务组起步）就经常遇到下述的对话：张三：为什么要拆现在的代码？鲤鱼：因为！@）&&#@！）&#！&）@！&！的原因。张三：那即将要做的 “微服务” 是按照什么维度去拆分的服务？鲤鱼：常见的一般根据！@#*@！#&！（@&！@）#@ 的方式来拆分。张三：照你这么说好像也不大对，我看每个业务组拆分的维度似乎都不大一样？鲤鱼：嗯，每个业务组还有自己的见解，不会完全相同。张三：。。。所以微服务的拆分维度到底是什么？为什么想拆为什么张三会有这个疑问呢，实际上是因为研发内部希望从原先的大单体，大仓库向微服务体系拆分转换，其原先大单体仓库结构，类 Monorepo：但类 Monorepo 又有不少的问题，像是：单个 Repo 体积过大：导致 Git 无法直接拉取。当你设置完再拉取时，在网速慢时还能去泡杯咖啡，并且...

2020-08-22

498

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。