Spring源码之BeanFactory(七)

前言:
本文承接上一篇，继续来解读spring的第二个很重要的容器BeanFactory，也就是生产bean的工厂。
一个工厂他需要具备的东西大概有原料，生产线，仓库，本文也将从这三方面来解读BeanFactory

BeanFactory的基础关系图

此图看着略复杂，但从最下面开始看，就一个可以实例化的实现类DefaultListableBeanFactory，所以我们可以从他来入手来解读。
本文主要从BeanFactory的几个实现类来进行解读。
1.BeanFactory的原料:BeanDefinition
对于BeanFactory来说，BeanDefinition(Bean的定义信息)是其生产Bean的根本，本文对BeanFactory的原料只谈BeanDefinition的存储，
关于BeanDefinition是什么已在前面文章解读，BeanDefinition的读取过程也已经在扫描器那一节解读。

/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

此处beanDefinitionMap是一个ConcurrentHashMap类型的Map，key是bean的Name，value是BeanDefinition类型的对象
目前BeanDefinition提供了多种子类对象来适用于不同的Bean。

2.BeanFactory的生产线:也就是从BeanDefinition变成Bean的过程，即Bean的初始化过程。
2.1初始化单例bean的主流程preInstantiateSingletons()

1.copy一份beanDefinitionNames
2.循环初始化Bean
    判断是不是工厂Bean，然后看工厂Bean是否需要马上实例化，需要的话先实例化
    不是工厂Bean，直接调用getBean()
3.循环所有bean，回调实现了SmartInitializingSingleton接口的回调方法

public void preInstantiateSingletons() throws BeansException {
   if (logger.isDebugEnabled()) {
      logger.debug("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()) {
         //判断是不是FactoryBean,FactoryBean需要特殊处理
         //获取这个工厂bean本身需要在beanName前加&,不加的话就是获取的这个工厂bean里面的对象
         if (isFactoryBean(beanName)) {
            //获取到工厂bean本身
            //判断这个工厂bean是否需要马上初始化，还是在使用bean的时候才去初始化
            //isEagerInit为true，需要马上初始化，直接执行getBean
            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();
         }
      }
   }
}

2.2实际创建Bean的子线流程getBean()

public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}
1.判断缓存中是否有单例bean
2.有单例bean，而且args参数有值，则从缓存中获取
3.没有缓存bean
5.检查父容器中是否有该bean的BeanDefinition，有则从父容器中获取bean
6.上面检查都做完后，开始创建bean
7.获取beanDefinition对象
8.检查该bean的依赖bean是否都已经创建，没的话先创建依赖bean
9.开始创建Bean(针对单例，原型及其他scope类型的bean都有涉及)
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

   final String beanName = transformedBeanName(name);
   Object bean;

   // Eagerly check singleton cache for manually registered singletons.
   Object sharedInstance = getSingleton(beanName);
   if (sharedInstance != null && args == null) {
      //打印debug级别日志
      if (logger.isDebugEnabled()) {
         if (isSingletonCurrentlyInCreation(beanName)) {
            //该bean未完全初始化，存在循环引用
            logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
         } else {
            //该bean已完全初始化，正在返回
            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
         }
      }
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }

   else {
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      //如果这个bean实例正在创建而且他是原型的那么就抛出异常
      if (isPrototypeCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
      }

      // Check if bean definition exists in this factory.
      //检查父容器里是否有该bean实例，有的话就不再创建
      BeanFactory parentBeanFactory = getParentBeanFactory();
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
         // Not found -> check parent.
         String nameToLookup = originalBeanName(name);
         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 {
            // No args -> delegate to standard getBean method.
            return parentBeanFactory.getBean(nameToLookup, requiredType);
         }
      }
      //小校验，如果已经创建过，则加入了alreadyCreated集合里
      if (!typeCheckOnly) {
         markBeanAsCreated(beanName);
      }

      //上面一系列校验都通过了，发现都没有创建，此处正式开始创建
      try {
         //获取beanDefinition对象
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         //校验beanDefinition是否为抽象，抽象则抛出异常
         checkMergedBeanDefinition(mbd, beanName, args);

         // Guarantee initialization of beans that the current bean depends on.
         // 保证当前初始化的bean的依赖bean已经初始化，此处涉及依赖注入及循环依赖，后面详细讲
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
            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);
               }
            }
         }

         // Create bean instance.
         //省略这部分代码
}

3.BeanFactory的仓库，对于单例bean来说需要仓库singletonObjects，原型bean的话是每次创建的。

/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
1.singletonObjects是一个ConcurrentHashMap类型的Map，key是bean的Name，value是bean实例
目的就是为了在启动的时候创建号，然后后面每次使用的时候都只取这一个