BeanFactory和FactoryBean

﹏ヽ暗。殇╰゛Y 2023-10-14 17:59 46阅读 0赞

BeanFactory和FactoryBean  
**何为Bean？**

类比的方式 Java  Object 等同于 Spring Bean。Bean就是Spring中管理的对象。所以无论是BeanFactory还是FactoryBean，都是为了操作Spring中的对象。之后在怎么区分两者呢，Java中常讲的命名要规范，那Spring源码命名绝对是典范，BeanFactory—— bean工厂，FactoryBean——工厂bean，两者英译汉的侧重点，一个是工厂，另一个bean而已。

**BeanFactory**  
BeanFactory定义了 IOC 容器的最基本形式，并提供了 IOC 容器应遵守的的最基本的接口，也就是 Spring IOC 所遵守的最底层和最基本的编程规范。在 Spring 代码中， BeanFactory 只是个接口，并不是 IOC 容器的具体实现，但是 Spring 容器给出了很多种实现，如 DefaultListableBeanFactory 、XmlBeanFactory等。  
在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的，同样Factory也是需要接受BeanFactory的管理。

**FactoryBean**  
FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似 、 ApplicationContext 等，都是附加了某种功能的实现。一个Bean如果实现了FactoryBean接口，那么根据该Bean的名称获取到的实际上是getObject()返回的对象，而不是这个Bean自身实例，如果要获取这个Bean自身实例，那么需要在名称前面加上’&'符号。下方简单附一个FactoryBean的使用方式

Component
    public class MyFactoryBean implements FactoryBean {
        
       @Override
       public Object getObject() throws Exception {
        
          return new User();
       }
    
       @Override
       public Class<?> getObjectType() {
        
          return User.class;
       }
    }
    
     System.out.println(context.getBean("myFactroyBean")); //User
     System.out.println(context.getBean("&myFactroyBean")); //MyFactroyBean

上篇文章说每一个bean都一个对应的BeanDefinition，其中定义bean的相关属性，再加上注册器就可以实现Bean的创建，那么为什么还要有一个FactoryBean同样可以用来创建Bean呢？

在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在<bean>中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂Bean的细节，给上层应用带来了便利。
    
       FactoryBean就相当于Spring提供外界的一个暴露点，通过它完整复杂Bean的实例化。

**FactoryBean实现原理**

// org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
          @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        
             //获取bean真正的名称
        final String beanName = transformedBeanName(name);
        Object bean;
    
        // Eagerly check singleton cache for manually registered singletons.
            //从单例对象池拿到bean实例
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
        
          if (logger.isTraceEnabled()) {
        
            if (isSingletonCurrentlyInCreation(beanName)) {
        
              logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
        
              logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
          }
          bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
    // 以下逻辑省略，如有需要自行查看源码
    }

transformedBeanName(name)是为了获取Bean真正的名称，它会去掉name前面的’&'，而getSingleton(beanName)是从父类容器singletonObjects中取的这个Bean的实例。在Spring中还有很多这样的容器，比如DefaultListableBeanFactory中的beanDefinitionMap，它就是的IOC容器真正保存Bean的地方，它是一个CurrentHashMap。类似的还有FactoryBeanRegistrySupport中的factoryBeanObjectCache等。

拿到sharedInstance后，后面的一大堆操作做了单例、多例等判断，最终会走到this.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.
            //判断name是否不为空且以&开头
        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.
            //判断的是beanInstance是否属于FactoryBean或其子类的实例
        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;
      }

上述逻辑关键点 beanInstance instanceof FactoryBean和BeanFactoryUtils.isFactoryDereference(name)。如果beanInstance不属于FactoryBean或其子类的实例，或者name是以&开头就直接返回实例对象beanInstance，否则进入到if分支中。分支中重点

object = getObjectFromFactoryBean(factory, beanName, !synthetic);

**具体逻辑如下**

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

这段逻辑中大概的意思就是目的是从factoryBeanObjectCache中获得FactoryBean，无论是否能拿到if else中逻辑都会执行object = doGetObjectFromFactoryBean(factory, beanName);

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final 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);
        }

关键点

object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);

外解释下 factoryBeanObjectCache 是什么？

/** Cache of singleton objects created by FactoryBeans: FactoryBean name to object. */
      private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);

通过这个定义和源码中注释可以得知 factoryBeanObjectCache中存储的FactoryBean，在getObjectForBeanInstance()中有段逻辑

object = getCachedObjectForFactoryBean(beanName);
    /**
       * Obtain an object to expose from the given FactoryBean, if available
       * in cached form. Quick check for minimal synchronization.
       * @param beanName the name of the bean
       * @return the object obtained from the FactoryBean,
       * or {@code null} if not available
       */
      @Nullable
      protected Object getCachedObjectForFactoryBean(String beanName) {
        
        return this.factoryBeanObjectCache.get(beanName);
      }

如果以&开头就直接返回实例对象beanInstance，beanInstance则是从factoryBeanObjectCache中获取的，由此也知道FactoryBean本身并不存储到单例对象池中，获取本身为需要加&用于区分。

主要介绍BeanFactory和FactoryBean在命名上区分，在Spring中不同的作用，以及FactoryBean的实验原理。FactoryBean在Spring中存在的意义为了解决配置方式装配bean灵活性是受限的问题，通过编码得到一个简单的方案。