SpringBoot源码 - bean的加载（中）

精彩的内容来了，各位看官，继续~

接上一节，AbstractApplicationContext 类中的refresh()方法，有那么一行不起眼的代码：

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

就是它，创建bean最集中的地方，实例化所有非懒加载的单例。

点击这个方法进去，可以看到方法体内又有一行代码：

// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();

真正干活的爷们就是它了。再点进去，可以看到方法实现：

1. getMergedLocalBeanDefinition(beanName) ，将BeanDefinition的定义进行合并
2. if (isFactoryBean(beanName)) {……} ，判断是不是FactoryBean，拿到FactoryBean的实例，判断是否需要提前实例化，需要则通过getBean来实例化

3. getBean(beanName) 普通bean的实例化，点进去，来到doGetBean()，上码：

   protected  T doGetBean(
       String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {
       // 获取真实的beanName,因为有的bean有别名，FactoryBean本身创建的时候，传的是&BeanName
       String beanName = transformedBeanName(name);
       Object beanInstance;
   
       // 从缓存获取单例实例，解决循环依赖和重复创建
       Object sharedInstance = getSingleton(beanName);
       if (sharedInstance != null && args == null) {
           if (logger.isTraceEnabled()) {
               if (isSingletonCurrentlyInCreation(beanName)) {
                   logger.trace("……");
               }
               else {
                   logger.trace("……");
               }
           }
           //解决类似FactoryBean这样特殊的bean处理
           beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
       }
   
       else {
           // 原型模式不需解决循环依赖，因为原型bean不放缓存，不会提前暴露引用
           if (isPrototypeCurrentlyInCreation(beanName)) {
               throw new BeanCurrentlyInCreationException(beanName);
           }
   
           // 如果 beanDefinitionMap未加载有该bean，则从parentBeanFactory查找
           BeanFactory parentBeanFactory = getParentBeanFactory();
           if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
               String nameToLookup = originalBeanName(name);
               if (parentBeanFactory instanceof AbstractBeanFactory) {
                   return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                           nameToLookup, requiredType, args, typeCheckOnly);
               }
               else if (args != null) {
                   return (T) parentBeanFactory.getBean(nameToLookup, args);
               }
               else if (requiredType != null) {
                   return parentBeanFactory.getBean(nameToLookup, requiredType);
               }
               else {
                   return (T) parentBeanFactory.getBean(nameToLookup);
               }
           }
           // 非类型检查的时候，才标记该bean已创建
           if (!typeCheckOnly) {
               markBeanAsCreated(beanName);
           }
   
           StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")                .tag("beanName", name);
           try {
               if (requiredType != null) {
                   beanCreation.tag("beanType", requiredType::toString);
               }
               RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
               checkMergedBeanDefinition(mbd, beanName, args);
   
               // 当前bean依赖的bean的创建。
               String[] dependsOn = mbd.getDependsOn();
               if (dependsOn != null) {
                   for (String dep : dependsOn) {
                       // 不可显式依赖(@DependOn)
                       if (isDependent(beanName, dep)) {
                           throw new BeanCreationException("……");
                       }
                       // 先创建依赖的bean，再创建本身自己
                       registerDependentBean(dep, beanName);
                       try {
                           getBean(dep);
                       }
                       catch (NoSuchBeanDefinitionException ex) {
                           throw new BeanCreationException("……");
                       }
                   }
               }
   
               // 单例bean创建
               if (mbd.isSingleton()) {
                   sharedInstance = getSingleton(beanName, () -> {
                       try {
                           return createBean(beanName, mbd, args);
                       }
                       catch (BeansException ex) {
                           destroySingleton(beanName);
                           throw ex;
                       }
                   });
                   beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
               }
               // 原型bean创建
               else if (mbd.isPrototype()) {
                   Object prototypeInstance = null;
                   try {
                       beforePrototypeCreation(beanName);
                       prototypeInstance = createBean(beanName, mbd, args);
                   }
                   finally {
                       afterPrototypeCreation(beanName);
                   }
                   beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
               }
               // 指定scope上实例化bean
               else {
                   String scopeName = mbd.getScope();
                   if (!StringUtils.hasLength(scopeName)) {
                       throw new IllegalStateException("……");
                   }
                   Scope scope = this.scopes.get(scopeName);
                   if (scope == null) {
                       throw new IllegalStateException("……");
                   }
                   try {
                       Object scopedInstance = scope.get(beanName, () -> {
                           beforePrototypeCreation(beanName);
                           try {
                               return createBean(beanName, mbd, args);
                           }
                           finally {
                               afterPrototypeCreation(beanName);
                           }
                       });
                       beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                   }
                   catch (IllegalStateException ex) {
                       throw new ScopeNotActiveException(beanName, scopeName, ex);
                   }
               }
           }
           catch (BeansException ex) {
               beanCreation.tag("exception", ex.getClass().toString());
               beanCreation.tag("message", String.valueOf(ex.getMessage()));
               cleanupAfterBeanCreationFailure(beanName);
               throw ex;
           }
           finally {
               beanCreation.end();
           }
       }
       // 检查实际类型与所需类型是否符合，不符合则装换
       return adaptBeanInstance(name, beanInstance, requiredType);
   }

   以上代码中，创建bean的地方是:

   createBean(beanName, mbd, args);

   点击该方法进去，还藏有一层：

   doCreateBean(beanName, mbdToUse, args);

   点击该方法进去，就是真正创建bean的地方。下节再讲，喝口酒先~~