Spring源码浅析之bean实例的创建过程

Posted 2021-08-24 狐言不胡言

@TOC
在之前的文章内容中，简单介绍了bean定义的加载过程，下面这篇的主要内容就是bean实例的创建过程。

bean实例的创建方式

ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
context.getBean("beanDemo");

首先看到上面的代码，使用了getBean方法，那么创建bean的入口是不是在getBean里面呢？

通过之前的内容，可以知道，单例bean可以提前实例化，因为能够提高使用时的效率。原型bean，即多例bean则是在getBean的时候进行实例化的。而且单例bean和原型bean的实例化过程是没有区别的，都是通过getBean方法，在启动时提前实例化也是使用的getBean方法。

bean实例创建以及配置的方式如下：

• 构造方法的方式

通过构造函数创建实例有两种方式，一种是无参构造函数，一种是有参构造函数

下面是无参构造函数的配置方式：

public class ConstructorBean {

    public ConstructorBean() {
        System.out.println("无参构造函数......");
    }
}

<bean id="constructorBean" class="edu.demo.spring.instantiate.ConstructorBean" />

下面是有参构造函数的配置方式：

public class ConstructorBean {

    public ConstructorBean(String name, int age) {
        System.out.println("带参构造函数......");
        System.out.println(name + "_" + age);
    }
}

<bean id="constructorBean" class="edu.demo.spring.instantiate.ConstructorBean">
   <constructor-arg index="0" value="翠花" />
   <constructor-arg index="1" value="18" />
</bean>

输出结果如下：

• 静态工厂方法

  public class InstantiateFactory {
  
  public static String getStaticFactoryMethod() {
     return "静态工厂方法创建bean......";
  }
  }

  <bean id="boyService" class="edu.demo.spring.instantiate.InstantiateFactory"
    factory-method="getStaticFactoryMethod" >
   <!--<property name="" ref=""></property>-->
  </bean>

• 非静态工厂方法

  public class InstantiateFactory {
  
  public String getMemberFactoryMethod(String name) {
    return "非静态工厂方法创建bean......";
  }
  }

  
  <bean id="instantiateFactory" class="edu.demo.spring.instantiate.InstantiateFactory" />

<bean id="grilService" factory-bean="instantiateFactory"
factory-method="getMemberFactoryMethod" >
<!--<constructor-arg index="0" value="你好" />-->
</bean>

- 指定工厂方法

需要继承FactoryBean接口：
```java
public class BoyFactoryBean implements FactoryBean<Boy> {

   @Override
   public Boy getObject() throws Exception {
      return new Lad("niulang");
   }

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

<bean name="boyService2" class="edu.demo.spring.instantiate.BoyFactoryBean">
</bean>

如果要获取BoyFactoryBean自身，需要加上"&"前缀，否则返回的是getObject中的bean，这是由FactoryBean创建的bean实例

Object lsfb2 = context.getBean("boyService2");
System.out.println(lsfb2);
Object lsfb4 = context.getBean("&boyService2");
System.out.println(lsfb4);
BoyFactoryBean lsfb = (BoyFactoryBean) context.getBean("&boyService2");
System.out.println(lsfb);
System.out.println(lsfb.getObject());

分别输出如下：

实例化bean的流程

从AbstractApplicationContext类中的refresh()方法看起，这里有个步骤，是提前实例化一些单例bean：

//完成bean工厂的初始化，初始化所有非懒加载的单例bean
finishBeanFactoryInitialization(beanFactory);

点进去查看具体的实现：

/**
 * Finish the initialization of this context\'s bean factory,
 * initializing all remaining singleton beans.
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // Initialize conversion service for this context.
   //实例化类型转换服务
   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
      beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
   }

   // Register a default embedded value resolver if no bean post-processor
   // (such as a PropertyPlaceholderConfigurer bean) registered any before:
   // at this point, primarily for resolution in annotation attribute values.
   //确保beanFacotory持有嵌入值的解析器
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
   // 提前实例化LoadTimeWeaverAware beans
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

   // Stop using the temporary ClassLoader for type matching.
   beanFactory.setTempClassLoader(null);

   // Allow for caching all bean definition metadata, not expecting further changes.
   // 冻结配置，要进行实例化了，bean定义信息就不能进行更改了
   beanFactory.freezeConfiguration();

   // Instantiate all remaining (non-lazy-init) singletons.
   // 实例化单例bean
   beanFactory.preInstantiateSingletons();
}

然后会进入preInstantiateSingletons方法：

    /** 按照注册顺序存放的bean定义名称集合 */
    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

  // 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.
   //获取到所有的bean定义名称
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

根据上面的代码可以看到，这个方法刚一进来，就获取所有的bean定义名称，这个bean定义的list使用了volatile关键字进行修饰，关于volatile不清楚的可以看下之前线程方面的文章。

// Trigger initialization of all non-lazy singleton beans...
//触发所有非懒加载单例bean的初始化
for (String beanName : beanNames) {
   //获取合并之后的bean定义信息
   RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
   //如果bean定义不是抽象的，并且是单例的，不是懒加载的，就继续执行
   if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
      //如果是工厂bean就继续执行，否则直接执行getBean方法
      if (isFactoryBean(beanName)) {
         //获取bean，这里的bean是一个工厂bean
         Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
         if (bean instanceof FactoryBean) {
            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());
            }
            //如果这个bean急需实例化，就调用getBean方法
            if (isEagerInit) {
               getBean(beanName);
            }
         }
      }
      else {
         //获取普通bean
         getBean(beanName);
      }
   }
}

FactoryBean是什么，上面已经有了简单的使用，FactoryBean虽然也是一个bean，但是它是一个可以生产bean的bean。如果直接使用getBean获取的是它生产的bean，所以需要使用getBean(& + beanName)才能获取这个工厂bean。

doGetBean方法介绍

protected <T> T doGetBean(
      String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
      throws BeansException {}

这里传过来了四个参数，第一个参数name就是bean定义的名称，requiredType是bean所需要的类型，args是显式传过来的参数，typeCheckOnly是否类型检查。

args指的就是下面代码中的参数：

ConstructorBean constructorBean = (ConstructorBean) context.getBean("constructorBean", new Object[]{1,2,3});

使用刚刚上面的示例，然后debug到doGetBean方法可以看到：

进入方法的第一步就执行了transformedBeanName方法：

String beanName = transformedBeanName(name);
Object bean;

这个transformedBeanName方法就是获取到标准的bean定义名称，什么是标准的bean定义名称呢？因为在配置bean定义的时候，可以给这个bean定义一些别名。

当使用getBean("别名")也是可以获取到这个bean定义的。主要的原因就是底层使用了aliasMap，这个aliasMap的key值就是别名，value值就是真正的bean定义名称。

/** Map from alias to canonical name. */
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);

/**
 * Return the bean name, stripping out the factory dereference prefix if necessary,
 * and resolving aliases to canonical names.
 * @param name the user-specified name
 * @return the transformed bean name
 */
protected String transformedBeanName(String name) {
   return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

这里又调用了BeanFactoryUtils.transformedBeanName和canonicalName两个方法：

/**
 * 返回bean名称，必要时去掉工厂解引用前缀
 * @param name the name of the bean
 * @return the transformed name
 * @see BeanFactory#FACTORY_BEAN_PREFIX
 */
public static String transformedBeanName(String name) {
   Assert.notNull(name, "\'name\' must not be null");
   //如果bean名称不包含&前缀，就直接返回
   if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
      return name;
   }
   //去除bean名称的解引用前缀，也就是&前缀
   return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
      do {
         beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
      }
      while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
      return beanName;
   });
}

/**
 * 这个方法的作用，就是获取到真正的bean名称
 * @param name the user-specified name
 * @return the transformed name
 */
public String canonicalName(String name) {
   String canonicalName = name;
   // Handle aliasing...
   String resolvedName;
   do {
      resolvedName = this.aliasMap.get(canonicalName);
      if (resolvedName != null) {
         canonicalName = resolvedName;
      }
   }
   while (resolvedName != null);
   return canonicalName;
}

canonicalName里面使用了do...while循环来获取真正的bean名称，下面来个小例子看一下：

<bean id="constructorBean" name="bean1,bean2,bean3,bean4" class="edu.demo.spring.instantiate.ConstructorBean">
   <constructor-arg index="0" value="翠花" />
   <constructor-arg index="1" value="18" />
</bean>

<alias name="bean2" alias="a"/>

ConstructorBean constructorBean = (ConstructorBean) context.getBean("a");

上面给constructorBean配置了4个别名bean1,bean2,bean3,bean4，而且给别名bean2又配置了一个别名a，也就是别名的别名。

debug后可以看到，这里传过来的就是别名bean2的别名a：

下面的图中，展示了bean定义别名的aliasMap：

现在清楚这里为啥使用do...while循环来获取标准的bean名称了吗，就是因为bean定义的别名，也可以有别名。当resolvedName为空，也就是说没有别名了，就会跳出循环，获取到真正的bean名称了。

接下来使用if...else分成了两个部分，先来看下第一部分：

// Eagerly check singleton cache for manually registered singletons.
//从缓存中获取已经实例化的单例bean
Object sharedInstance = getSingleton(beanName);
//如果bean实例存在且显式传过来的参数是空的就执行下面的代码
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是不是FactoryBean，如果是FactoryBean，那么就要从FactoryBean中创建一个实例
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

下面先看下getSingleton这个方法

/** 单例bean的缓存 */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/** 单例工厂的缓存 */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** 预加载的单例bean的缓存 */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   //首先从单例bean的缓存中获取bean实例
   Object singletonObject = this.singletonObjects.get(beanName);
   //如果没有获取到并且这个bean正在创建中就执行下面的内容
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      //加锁
      synchronized (this.singletonObjects) {
         //从预加载的单例bean的缓存中获取bean实例
         singletonObject = this.earlySingletonObjects.get(beanName);、
         //如果还是没有获取到，而且是需要创建早期的引用的
         if (singletonObject == null && allowEarlyReference) {
            //从beanName中获取单例工厂
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            //如果工厂不为空
            if (singletonFactory != null) {
               //获取bean
               singletonObject = singletonFactory.getObject();
               //放入预加载的单例bean的缓存中
               this.earlySingletonObjects.put(beanName, singletonObject);
               //把bean从singletonFactories中移除，
               //因为已经在上面加入到earlySingletonObjects了，所以singletonFactories就不需要了
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

如果上面的方式没有获取到bean实例，那么就走下面的else方法：

// Fail if we\'re already creating this bean instance:
// We\'re assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
   throw new BeanCurrentlyInCreationException(beanName);
}

首先这里，是判断原型bean是否已经在构建中了，来检测循环依赖的，比如创建bean1的时候需要依赖bean2，而创建bean2的过程中又依赖bean1，那么这样就会抛出异常。

下面的代码，就是判断父工厂的：

// Check if bean definition exists in this factory.
//首先，获取父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果父工厂不为空，并且本地又不包含这个bean定义，那就从父工厂中获取
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   // Not found -> check parent.
   //这一步就是还原原来的bean名称，因为有factoryBean的存在，
   //上面把它的前缀去掉，这里要加回来
   String nameToLookup = originalBeanName(name);
   //下面就是通过父类去创建bean实例
   if (parentBeanFactory instanceof AbstractBeanFactory) {
      return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
            nameToLookup, requiredType, args, typeCheckOnly);
   }
   else if (args != null) {
      // Delegation to parent with explicit args.
      return (T) parentBeanFactory.getBean(nameToLookup, args);
   }
   else if (requiredType != null) {
      // No args -> delegate to standard getBean method.
      return parentBeanFactory.getBean(nameToLookup, requiredType);
   }
   else {
      return (T) parentBeanFactory.getBean(nameToLookup);
   }
}

从上面的代码可以看到，parentBeanFactory.getBean，这里又使用了getBean方法，可见也是递归调用。

if (!typeCheckOnly) {
   markBeanAsCreated(beanName);
}

上面的代码，是判断，如果这里不仅仅是做类型检查，那这里就记录一下，记录该bean已经被创建了。下面是markBeanAsCreated方法：

/** Map from bean name to merged RootBeanDefinition. */
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);

/** Names of beans that have already been created at least once. */
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));

protected void markBeanAsCreated(String beanName) {
   //首先，判断已经创建的bean集合中是否包含该bean
   if (!this.alreadyCreated.contains(beanName)) {
      //加锁
      synchronized (this.mergedBeanDefinitions) {
         //再次判断，双重检锁
         if (!this.alreadyCreated.contains(beanName)) {
            // Let the bean definition get re-merged now that we\'re actually creating
            // the bean... just in case some of its metadata changed in the meantime.
            //这里，是把合并的bean定义清除掉，让bean定义重新合并，
            //为了防止这个bean定义发生了变化
            clearMergedBeanDefinition(beanName);
            //把beanName加入到已经创建的集合中
            this.alreadyCreated.add(beanName);
         }
      }
   }
}

然后再次进入下面的代码：

RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);

// Guarantee initialization of beans that the current bean depends on.
//获取依赖的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
   //循环遍历依赖的bean
   for (String dep : dependsOn) {
      //判断是不是循环依赖，是的话就抛出异常
      if (isDependent(beanName, dep)) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Circular depends-on relationship between \'" + beanName + "\' and \'" + dep + "\'");
      }
      //注册依赖的bean
      registerDependentBean(dep, beanName);
      try {
         //获取到依赖的bean
         getBean(dep);
      }
      catch (NoSuchBeanDefinitionException ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "\'" + beanName + "\' depends on missing bean \'" + dep + "\'", ex);
      }
   }
}

这里先是获取合并后的bean定义，然后检测该bean是否是抽象的，如果是的话，就会抛出异常，这个判断在checkMergedBeanDefinition方法内。

然后是看这个bean是否依赖了其他bean，如果有依赖，就把依赖的bean注册到一个依赖的map中，然后调用getBean方法，先把依赖的bean实例化。

最后，如果上面都判断结束，还是没有获取到bean实例的话，就执行下面的代码来创建bean实例：

// Create bean instance.
// Scope的处理：单例、原型、其他
//判断是否单例
if (mbd.isSingleton()) {
   //获取单例bean，如果获取不到就进行创建，然后缓存到单例bean的集合中
   sharedInstance = getSingleton(beanName, () -> {
      try {
         return createBean(beanName, mbd, args);
      }
      catch (BeansException ex) {
         // Explicitly remove instance from singleton cache: It might have been put there
         // eagerly by the creation process, to allow for circular reference resolution.
         // Also remove any beans that received a temporary reference to the bean.
         destroySingleton(beanName);
         throw ex;
      }
   });
   //进行工厂bean的处理
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//原型bean的处理
else if (mbd.isPrototype()) {
   // It\'s a prototype -> create a new instance.
   Object prototypeInstance = null;
   try {
      //多例bean的循环依赖检查，并且做记录
      beforePrototypeCreation(beanName);
      //创建bean
      prototypeInstance = createBean(beanName, mbd, args);
   }
   finally {
     //释放循环依赖检查的记录
      afterPrototypeCreation(beanName);
   }
   //进行工厂bean的处理
   bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//其他范围bean的处理
else {
   String scopeName = mbd.getScope();
   if (!StringUtils.hasLength(scopeName)) {
      throw new IllegalStateException("No scope name defined for bean ´" + beanName + "\'");
   }
   Scope scope = this.scopes.get(scopeName);
   if (scope == null) {
      throw new IllegalStateException("No Scope registered for scope name \'" + scopeName + "\'");
   }
   try {
      Object scopedInstance = scope.get(beanName, () -> {
        //循环依赖检查，并且做记录
         beforePrototypeCreation(beanName);
         try {
            //创建bean
            return createBean(beanName, mbd, args);
         }
         finally {
            //释放循环依赖检查的记录
            afterPrototypeCreation(beanName);
         }
      });
      //进行工厂bean的处理
      bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
   }
   catch (IllegalStateException ex) {
      throw new BeanCreationException(beanName,
            "Scope \'" + scopeName + "\' is not active for the current thread; consider " +
            "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
            ex);
   }
}

上面的创建，分成了三个部分，分别是单例、多例和其他范围的bean，大致的处理过程是一样的，都调用了createBean方法进行创建。

getSingleton方法

下面来看下单例bean的getSingleton方法：

/**
 * Return the (raw) singleton object registered under the given name,
 * creating and registering a new one if none registered yet.
 * @param beanName the name of the bean
 * @param singletonFactory the ObjectFactory to lazily create the singleton
 * with, if necessary
 * @return the registered singleton object
 */
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {}

这个方法用来获取单例bean，而且会调用创建bean的方法。

synchronized (this.singletonObjects) {
   Object singletonObject = this.singletonObjects.get(beanName);
}

首先进行了加锁，然后从singletonObjects中获取单例bean，singletonObjects上面已经说过，里面存放了已经实例化的单例bean集合，这里先从singletonObjects获取，如果获取不到，再进行创建。

/** Flag that indicates whether we\'re currently within destroySingletons. */
private boolean singletonsCurrentlyInDestruction = false;

/** Collection of suppressed Exceptions, available for associating related causes. */
@Nullable
private Set<Exception> suppressedExceptions;

//如果获取不到该单例bean，那么就进行创建
if (singletonObject == null) {
    //判断该单例bean是否正在销毁，是的话就抛异常
    if (this.singletonsCurrentlyInDestruction) {
       throw new BeanCreationNotAllowedException(beanName,
             "Singleton bean creation not allowed while singletons of this factory are in destruction " +
             "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
    }
    if (logger.isDebugEnabled()) {
       logger.debug("Creating shared instance of singleton bean \'" + beanName + "\'");
    }
    //单例bean创建之前的处理，也是进行记录
    beforeSingletonCreation(beanName);
    //是否新创建的单例bean
    boolean newSingleton = false;
    //记录在创建过程中产生的异常，可能是的，这个我猜的，哈哈
    boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
    if (recordSuppressedExceptions) {
       this.suppressedExceptions = new LinkedHashSet<>();
    }
}

然后看下beforeSingletonCreation这个方法

/** Names of beans that are currently in creation. */
private final Set<String> singletonsCurrentlyInCreation =
      Collections.newSetFromMap(new ConcurrentHashMap<>(16));

/** Names of beans currently excluded from in creation checks. */
private final Set<String> inCreationCheckExclusions =
      Collections.newSetFromMap(new ConcurrentHashMap<>(16));

protected void beforeSingletonCreation(String beanName) {
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
   }
}

进行了判断和添加，inCreationCheckExclusions是排除的bean名称集合，也就是说这个bean不会被创建。singletonsCurrentlyInCreation记录当前正在创建的bean名称。

下面就是进行创建的代码：

try {
   //singletonFactory就是执行上面的创建bean代码
   singletonObject = singletonFactory.getObject();
   //创建完成后，标志为新的单例bean
   newSingleton = true;
}

然后下面的代码就是进行一些缓存：

finally {
   if (recordSuppressedExceptions) {
      this.suppressedExceptions = null;
   }
   //移除记录
   afterSingletonCreation(beanName);
}
//如果是新的单例bean，就进行一些缓存
if (newSingleton) {
   addSingleton(beanName, singletonObject);
}

看下afterSingletonCreation方法，就是把当前的bean从正在创建的集合中移除掉

protected void afterSingletonCreation(String beanName) {
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
      throw new IllegalStateException("Singleton \'" + beanName + "\' isn\'t currently in creation");
   }
}

然后下面就是缓存的方法了：

protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      this.singletonObjects.put(beanName, singletonObject);
      this.singletonFactories.remove(beanName);
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

这个方法就比较简单了，把已经实例化的单例bean加入到singletonObjects集合，因为已经实例化了，所以从singletonFactories和earlySingletonObjects中移除了，而且还加入到了registeredSingletons集合中。

原型bean

下面来看下原型bean的处理：

/** Names of beans that are currently in creation. */
private final ThreadLocal<Object> prototypesCurrentlyInCreation =
      new NamedThreadLocal<>("Prototype beans currently in creation");

protected void beforePrototypeCreation(String beanName) {
   Object curVal = this.prototypesCurrentlyInCreation.get();
   if (curVal == null) {
      this.prototypesCurrentlyInCreation.set(beanName);
   }
   else if (curVal instanceof String) {
      Set<String> beanNameSet = new HashSet<>(2);
      beanNameSet.add((String) curVal);
      beanNameSet.add(beanName);
      this.prototypesCurrentlyInCreation.set(beanNameSet);
   }
   else {
      Set<String> beanNameSet = (Set<String>) curVal;
      beanNameSet.add(beanName);
   }
}

protected void afterPrototypeCreation(String beanName) {
   Object curVal = this.prototypesCurrentlyInCreation.get();
   if (curVal instanceof String) {
      this.prototypesCurrentlyInCreation.remove();
   }
   else if (curVal instanceof Set) {
      Set<String> beanNameSet = (Set<String>) curVal;
      beanNameSet.remove(beanName);
      if (beanNameSet.isEmpty()) {
         this.prototypesCurrentlyInCreation.remove();
      }
   }
}

从上面的源码，可以看到，prototypesCurrentlyInCreation使用到了ThreadLocal，可以避免线程重复创建bean，afterPrototypeCreation是把这个标志给移除掉。而scope和原型bean这块的处理是一样的。

getObjectForBeanInstance方法

最后呢，还有一个方法没有看，下面就来看下getObjectForBeanInstance这个方法吧。

protected Object getObjectForBeanInstance(
      Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {}

这里传来了四个参数，beanInstance是bean实例，name是原始的bean名称，也就是可能包含&前缀，beanName是标准的bean名称，mbd是合并之后的bean定义信息。

/** Package-visible field for caching if the bean is a factory bean. */
@Nullable
volatile Boolean isFactoryBean;

//判断是不是工厂bean
if (BeanFactoryUtils.isFactoryDereference(name)) {
   //如果是NullBean，直接返回
   if (beanInstance instanceof NullBean) {
      return beanInstance;
   }
   //如果不是FactoryBean类型，直接抛出异常
   //是工厂bean，但是不是FactoryBean类型
   if (!(beanInstance instanceof FactoryBean)) {
      throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
   }
   //设置isFactoryBean标志，标志该bean是工厂bean
   if (mbd != null) {
      mbd.isFactoryBean = true;
   }
   //返回bean实例
   return beanInstance;
}

判断是不是工厂bean的方法，比较简单，判断是不是以&开头的：

public static boolean isFactoryDereference(@Nullable String name) {
   return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
}

如果当前bean实例不是FactoryBean类型，直接返回

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

如果上面都没有获取到bean实例，则执行下面的代码：

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

Object object = null;
if (mbd != null) {
   mbd.isFactoryBean = true;
}
else {
   //从缓存中获取bean
   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.
   //如果bean定义为空，且beanDefinitionMap中包含该bean名称，则获取合并后的bean定义
   if (mbd == null && containsBeanDefinition(beanName)) {
      mbd = getMergedLocalBeanDefinition(beanName);
   }
   //是否是用户自定义的bean
   boolean synthetic = (mbd != null && mbd.isSynthetic());
   //从FactoryBean中获取bean
   object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;

getCachedObjectForFactoryBean方法比较简单，直接从缓存的map中获取即可：

@Nullable
protected Object getCachedObjectForFactoryBean(String beanName) {
   return this.factoryBeanObjectCache.get(beanName);
}

再然后就是getObjectFromFactoryBean，从FactoryBean中来获取对象：

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess)

这里传过来三个参数，factory就是上面传过来的factoryBean，beanName就是配置里面定义的bean名称，shouldPostProcess的意思是：是否允许bean进行后置处理。

if (factory.isSingleton() && containsSingleton(beanName)) {
  synchronized (getSingletonMutex()) {
   }
}

首先上来就是判断，这个factory是不是单例的，单例bean的集合中是否包含这个bean名称，如果都满足就执行下面的代码。

/** 由FactoryBean创建的单例对象的缓存:对象的FactoryBean名称 */
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);

//首先从缓存中获取
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)
   //再次从缓存中获取，由于循环引用可能导致这个bean已经在缓存中了
   Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
   //获取到了就直接赋值
   if (alreadyThere != null) {
      object = alreadyThere;
   }
   else {
      if (shouldPostProcess) {
          //当前bean正在创建直接返回，暂时不做后置处理
         if (isSingletonCurrentlyInCreation(beanName)) {
            // Temporarily return non-post-processed object, not storing it yet..
            return object;
         }
         //循环依赖检查，做记录
         beforeSingletonCreation(beanName);
         try {
            //对这个bean做后置处理
            object = postProcessObjectFromFactoryBean(object, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(beanName,
                  "Post-processing of FactoryBean\'s singleton object failed", ex);
         }
         finally {
            //循环依赖检查，移除
            afterSingletonCreation(beanName);
         }
      }
      //当前bean是否在单例bean的集合中，如果是的就缓存
      if (containsSingleton(beanName)) {
         this.factoryBeanObjectCache.put(beanName, object);
      }
   }
}
//返回bean实例
return object;

再然后就是else里面的处理，代码量较少，if里面已经有相同的代码了。

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;

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 {
         //这里，直接调用了getObject方法
         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;
}

这部分的代码，就是从factoryBean中获取到getObject里面的bean实例。

创建实例流程图

下面，根据上面的源码内容，做一个简单的流程图，方便进行总结和查看：

到此，getBean相关的内容已经介绍完毕了，下面就是真正创建bean实例的过程了。文章旨在记录学习内容和分享，如有不足还请见谅，文章中若有错误的地方，还望大佬不吝赐教，及时指正，共同学习，共同进步，互勉！