一、前言

ObjectFactory 表示一个对象工厂，这提供 T getObject() 返回工厂产生的对象。Spring DOC 有如下描述

定义一个可以返回对象实例的工厂，该对象实例可以是共享或独立的。 该接口封装一个通用的工厂接口，每次调用时都会返回一个新的实例对象（prototype）。 这个接口与 FactoryBean 类似，但后者的实现通常被定义为 BeanFactory 中的 SPI 实例，而这个类的实现通常作为 API 提供给其他 bean (通过注入)。

二、接口定义

  1. @FunctionalInterface
  2. public interface ObjectFactory<T> {
  4.     /**
  5.      * Return an instance (possibly shared or independent)
  6.      * of the object managed by this factory.
  7.      * @return the resulting instance
  8.      * @throws BeansException in case of creation errors
  9.      */
  10.     T getObject() throws BeansException;
  12. }

接口定义非常简单，他拥有如下实现:
objectfactory-implements.png
只关注 spring-beans 包下的实现，也就是前三个，都是通过 lambda表达式实现接口。这三个都非常之重要。

2.1 提早暴露工厂方法以解决循环引用

相关核心代码如下: 

  1. // org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
  2. if (earlySingletonExposure) {
  3.     // 3-2 添加单例工厂（名称-> ObjectFactory，可以通过getObject()获取对象实例，主要生成用于AOP代理）
  4.     addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  5. }
  7. protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  8.     Assert.notNull(singletonFactory, "Singleton factory must not be null");
  9.     synchronized (this.singletonObjects) {
  10.         if (!this.singletonObjects.containsKey(beanName)) {
  11.             this.singletonFactories.put(beanName, singletonFactory);
  12.             this.earlySingletonObjects.remove(beanName);
  13.             this.registeredSingletons.add(beanName);
  14.         }
  15.     }
  16. }
  18. // org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#getEarlyBeanReference
  19. protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
  20.     Object exposedObject = bean;
  21.     // Spring内置只有一个实现类，即AnnotationAwareAspectJAutoProxyCreator（通过注解@EnableAspectJAutoProxy开启）
  22.     // 创建代理对象
  23.     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  24.         for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
  25.             exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
  26.         }
  27.     }
  28.     return exposedObject;
  29. }

关于循环引用，请戳这里。简单说明一下，提早暴露工厂主要与 AOP 代理有关。

2.2 实例化单例

  1. // org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
  2. // #5 通过BeanDefinition真正实例化Bean对象
  3. if (mbd.isSingleton()) {
  4.     sharedInstance = getSingleton(beanName, () -> {
  5.         try {
  6.             // 5-1 创建单例Bean
  7.             return createBean(beanName, mbd, args);
  8.         }
  9.         catch (BeansException ex) {
  10.             // Explicitly remove instance from singleton cache: It might have been put there
  11.             // eagerly by the creation process, to allow for circular reference resolution.
  12.             // Also remove any beans that received a temporary reference to the bean.
  13.             destroySingleton(beanName);
  14.             throw ex;
  15.         }
  16.     });
  17.     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  18. }

通过 createBean 根据 BeanDefinition 实例化单例对象。在这里完成反射创建对象、应用相关后置处理器、Spring生命周期回调等流程后，最终返回一个完整的单例对象。

2.3 其他作用域对象

  1. // org.springframework.beans.factory.support.AbstractBeanFactory#
  2. Object scopedInstance = scope.get(beanName, () -> {
  3.     beforePrototypeCreation(beanName);
  4.     try {
  5.         return createBean(beanName, mbd, args);
  6.     }
  7.     finally {
  8.         afterPrototypeCreation(beanName);
  9.     }
  10. });

除了单例外，其他作用域对象也需要工厂创建合适的对象并返回。

三、总结

ObjectFactory 仅仅是一个普通的对象工厂，提供函数式接口编程。仅此而已。