8 Spring IOC 之 Bean加载 总结

获取bean的入口方法大家都知道就是org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)，废话不多说，直接上代码

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}



protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
    // 1 此处是将name转换为真实的beanname，主要是对 aliais 和&开头的bean进行处理
    final String beanName = transformedBeanName(name);
    Object bean;

    // 2 从缓存或者工厂方法中获取bean，敲黑板，这里涉及到解决bean的循环依赖问题，其中的3个map很重要，大家要牢记哦
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        //这段是日志，没啥用
        if (logger.isDebugEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        // 3 辅助性检查  子类父类的合并
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // 4 如果是原型模式，且该变正在创建过程中，直接抛出异常（因为spring只能解决单例bean的循环依赖）
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 5 获取父级bean工厂
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 6 如果父bean工厂不为空，且 org.springframework.beans.factory.support.DefaultListableBeanFactory#beanDefinitionMap 中不包括该bean key
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   			//7 获取实际bean name， 主要是处理 掉 alias，注意，此处会把&开头的工厂bean name复原，与上面的不大一样         
            String nameToLookup = originalBeanName(name);
            if (args != null) {
                // 8 如果初始化参数不为空
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // 9 初始化参数为空
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
		// 10 如果不仅仅是做类型检查，进行标记，这里是有逻辑的
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
        	//11 从容器中获取bean对应的 RootBeanDefinition
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            //12 对合并的BeanDefinition进行检查
            checkMergedBeanDefinition(mbd, beanName, args);

            //13 获取bean锁依赖的bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                	//14 判断是否循环依赖，此处有2个比较重要的map，如果循环依赖，抛出异常
                    if (isDependent(beanName, dep)) {
                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    //15注册
                    registerDependentBean(dep, beanName);
                    getBean(dep);
                }
            }

            // 创建bean 单例模式下
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                    @Override
                    public Object getObject() throws BeansException {
                        try {
                        	//16 创建bean
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            //  显示的从单例bean缓存中移除bean实例，具体原因是因为单例bean为了解决循环依赖，可能已经提前创建了
                            destroySingleton(beanName);
                            throw ex;
                        }
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
			// 17 原型模式
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else { //其他模式
                String scopeName = mbd.getScope();
                final 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, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        }
                    });
                    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);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // 检查我们需要的bean的类型是否符合
    if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
        try {
            return getTypeConverter().convertIfNecessary(bean, requiredType);
        }
        catch (TypeMismatchException ex) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to convert bean '" + name + "' to required type '" +
                        ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

代码很长，我们一步一步来分析

• 1 final String beanName = transformedBeanName(name);是为了获取纯粹的beanName，源码如下

protected String transformedBeanName(String name) {
    return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

public static String transformedBeanName(String name) {
    Assert.notNull(name, "'name' must not be null");
    String beanName = name;
    while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
        beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
    }
    return beanName;
}

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

---

• 2 Object sharedInstance = getSingleton(beanName); 主要是为了获取bean实例，分为3步骤
• • this.singletonObjects.get(beanName); 先查看this.singletonObjects是否包含，
• • 如果第一步返回null，且 this.singletonsCurrentlyInCreation 中包含beanName，表示bean在创建ing，则会去 this.earlySingletonObjects 中获取
• • 如果也是null 则会从this.singletonFactories 获取 singletonFactory，不为null，则通过singletonFactory.getObject() 获取singletonObject，同时 earlySingletonObjects 进行put操作，singletonFactories 进行remove操作

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

public boolean isSingletonCurrentlyInCreation(String beanName) {
    return this.singletonsCurrentlyInCreation.contains(beanName);
}

• 4 如果是原型模式，直接抛出异常(spring 无法解决原型模式下的循环依赖)
• 5 获取父级bean工厂

@Override
public BeanFactory getParentBeanFactory() {
    return this.parentBeanFactory;
}

• 6如果父bean工厂不为空，同时满足!containsBeanDefinition(beanName) ，则进入if语句

public boolean containsBeanDefinition(String beanName) {
    Assert.notNull(beanName, "Bean name must not be null");
    return this.beanDefinitionMap.containsKey(beanName);
}

• 7 通过originalBeanName(name) 获取

protected String originalBeanName(String name) {
    String beanName = transformedBeanName(name);
    if (name.startsWith(FACTORY_BEAN_PREFIX)) {
        beanName = FACTORY_BEAN_PREFIX + beanName;
    }
    return beanName;
}

• 8 如果初始化参数不为空 则通过 parentBeanFactory.getBean(nameToLookup, args) 获取bean
• 9 初始化参数为空 则 通过parentBeanFactory.getBean(nameToLookup, requiredType) 获取bean
• 10 如果不仅仅是做类型检查，进行标记，这里是有逻辑的 主要是针对alreadyCreated 这个map进行操作

protected void markBeanAsCreated(String beanName) {
    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.
                clearMergedBeanDefinition(beanName);
                this.alreadyCreated.add(beanName);
            }
        }
    }
}


protected void clearMergedBeanDefinition(String beanName) {
    this.mergedBeanDefinitions.remove(beanName);
}

• 11 从容器中获取bean对应的 RootBeanDefinition
• 12checkMergedBeanDefinition 只是判断下mbd是否是abstract，如果是直接抛出异常

protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, Object[] args) throws BeanDefinitionStoreException {

    if (mbd.isAbstract()) {
        throw new BeanIsAbstractException(beanName);
    }
}

• 13 获取bean锁依赖的bean，通过 mbd.getDependsOn() 
• 14 进行循环依赖判断,这里有2个重要的map
• • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#dependentBeanMap
• • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#dependenciesForBeanMap
• • dependentBeanMap 是 指定的bean与目前已经注册的依赖这个指定bean的bean的集合，其key-value的关系是， key是当前bean， value是依赖该bean的beanName
• • dependenciesForBeanMap 当前bean所依赖的bean的集合

protected boolean isDependent(String beanName, String dependentBeanName) {
    return isDependent(beanName, dependentBeanName, null);
}

private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
    if (alreadySeen != null && alreadySeen.contains(beanName)) {
        return false;
    }
    String canonicalName = canonicalName(beanName);
    Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    if (dependentBeans == null) {
        return false;
    }
    if (dependentBeans.contains(dependentBeanName)) {
        return true;
    }
    for (String transitiveDependency : dependentBeans) {
        if (alreadySeen == null) {
            alreadySeen = new HashSet<String>();
        }
        alreadySeen.add(beanName);
        if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
            return true;
        }
    }
    return false;
}

---

接下来就是开始真正的创建bean的流程了

• 16 单例bean模式下的创建流程createBean 具体参数如下
• • beanName：bean 的名字
• • mbd：已经合并了父类属性的（如果有的话）BeanDefinition
• • args：用于构造函数或者工厂方法创建 bean 实例对象的参数

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;

    //1 首先确保bean已经被解析过了，如果获取的class的属性不为null，则克隆该BeanDefinition(因为该动态解析的 class 无法保存到到共享的 BeanDefinition)
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // 2 检查是否有override方法
    try {
        mbdToUse.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        //3 给 BeanPostProcessors 一个机会用来返回一个代理类而不是真正的类实例 (AOP的口子 哦)
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    } catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
    }
	// 4 创建bean
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}

• 1resolveBeanClass 获取class属性
• 2prepareMethodOverrides 处理override 该操作主要是为了后续判断是否有重载方法的时候做准备，并没有什么实质性的操作

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
		// Check that lookup methods exists.
		MethodOverrides methodOverrides = getMethodOverrides();
		if (!methodOverrides.isEmpty()) {
			Set<MethodOverride> overrides = methodOverrides.getOverrides();
			synchronized (overrides) {
				for (MethodOverride mo : overrides) {
					prepareMethodOverride(mo);
				}
			}
		}
	}

	protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
		int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
		if (count == 0) {
			throw new BeanDefinitionValidationException(
					"Invalid method override: no method with name '" + mo.getMethodName() +
					"' on class [" + getBeanClassName() + "]");
		}
		else if (count == 1) {
			// Mark override as not overloaded, to avoid the overhead of arg type checking.
			mo.setOverloaded(false);
		}
	}

• 3 resolveBeforeInstantiation
• mbd.beforeInstantiationResolved 是否实现前置处理器接口

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

• 4 doCreateBean(beanName, mbdToUse, args) 创建bean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)throws BeanCreationException {

  // 1 BeanWrapper是对Bean的包装，其接口中所定义的功能 包括设置/获取 被包装的对象，获取被包装bean的属性描述器
  BeanWrapper instanceWrapper = null;
  if (mbd.isSingleton()) {
  	  // 2 单例模式下将该beanName从factoryBeanInstanceCache 中移除，因为当前以及在创建流程中了
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  }
  //3 如果beanWrapper == null。 则进行创建
  if (instanceWrapper == null) {
      instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
  // 4 获取包装的实例对象
  final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
  // 5 获取包装的实例对象的class 属性
  Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
  mbd.resolvedTargetType = beanType;

  // 6 如果没有进行后置处理，则进行处理哈
  synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
          try {
              applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
          }
          catch (Throwable ex) {
              throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                      "Post-processing of merged bean definition failed", ex);
          }
          mbd.postProcessed = true;
      }
  }

  // 7 单例模式下，解决循环依赖的关键点
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
          isSingletonCurrentlyInCreation(beanName));
  if (earlySingletonExposure) {
      if (logger.isDebugEnabled()) {
          logger.debug("Eagerly caching bean '" + beanName +
                  "' to allow for resolving potential circular references");
      }
      addSingletonFactory(beanName, new ObjectFactory<Object>() {
          @Override
          public Object getObject() throws BeansException {
              //避免后期的循环依赖
              return getEarlyBeanReference(beanName, mbd, bean);
          }
      });
  }

  // 8 开始初始化bean
  Object exposedObject = bean;
  try {
      populateBean(beanName, mbd, instanceWrapper);
      if (exposedObject != null) {
          exposedObject = initializeBean(beanName, exposedObject, mbd);
      }
  }
  catch (Throwable ex) {
      if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
          throw (BeanCreationException) ex;
      }
      else {
          throw new BeanCreationException(
                  mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
      }
  }

  //9循环依赖处理
  if (earlySingletonExposure) {
      Object earlySingletonReference = getSingleton(beanName, false);
      if (earlySingletonReference != null) {
          if (exposedObject == bean) {
              exposedObject = earlySingletonReference;
          }
          else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
              String[] dependentBeans = getDependentBeans(beanName);
              Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
              for (String dependentBean : dependentBeans) {
                  if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                      actualDependentBeans.add(dependentBean);
                  }
              }
              if (!actualDependentBeans.isEmpty()) {
                  throw new BeanCurrentlyInCreationException(beanName,
                          "Bean with name '" + beanName + "' has been injected into other beans [" +
                          StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                          "] in its raw version as part of a circular reference, but has eventually been " +
                          "wrapped. This means that said other beans do not use the final version of the " +
                          "bean. This is often the result of over-eager type matching - consider using " +
                          "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
              }
          }
      }
  }

  // 注册bean
  try {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
  }
  catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
              mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  }

  return exposedObject;
}

---

属性填充未完待续