Spring技术内幕笔记（五）------IoC容器依赖注入#doGetBean（）

IoC容器依赖注入

在前几篇笔记中，我们已经了解到如何对IoC容器进行初始化，初始化的过程主要是在IoC容器中建立BeanDefinition的相关映射，接下来我们就开始研究，如何利用这些BeanDefinition使IoC容器可以对Bean的依赖关系进行注入的。

getBean()

在通常情况下，依赖注入发生的过程是用户第一次向IoC容器索要Bean时触发的，当然如果在BeanDefinition中控制了lazy-init的话，那么这个Bean就会发生预实例化，但是这个预实例化其实也是依赖注入的过程，在初始化过程中完成。

在AbstractBeanFactory中重载了很多的getBean方法，这些方法要需要的参数不尽相同，最后都会调用doGetBean，接下来我们就分析一下doGetBean都做了些什么

	/**
	 * Return an instance, which may be shared or independent, of the specified bean.
	 * 返回一个指定bean的实例，这个bean可以是独立的也可以是共享的
	 * @param name the name of the bean to retrieve
	 * 需要检索的bean的名称
	 * @param requiredType the required type of the bean to retrieve
	 * 需要检索的bean的类型
	 * @param args arguments to use when creating a bean instance using explicit arguments
	 * 需要通过显示参数创建bean的参数
	 * (only applied when creating a new instance as opposed to retrieving an existing one)
	 * 仅仅在创建新实例的时候使用，而不是在检索现有实例时使用
	 * @param typeCheckOnly whether the instance is obtained for a type check, not for actual use
	 * typeCheckOnly
	 *      true：表示bean被创建
	 *      false：表示bean没有被创建
	 * 暂时不理解这句话的意思，希望在看源码的时候可以解释
	 * @return an instance of the bean
	 * @throws BeansException if the bean could not be created
	 */
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        //返回bean名称，必要的时候会删除工厂dereference前缀，并将别名解析为规范的名称
		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);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			//如果我们已经创建了这个bean则会失败
			//我们可以在循环参考范围内
			//检查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 if (requiredType != null) {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}
            //标记bean正在被创建
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
			    //这里根据bean的名字取得BeanDefinition
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				//获取当前bean的所有依赖bean，这里会触发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 + "'");
						}
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance.
				//这里通过createBean方法创建一个Singleton bean的实例，
				if (mbd.isSingleton()) {
					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.
							//如果发生异常则销毁当前bean
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

                //上面是创建singleton bean的地方，这里就是创建prototype bean的地方
				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);
				}
                
                //根据bean definition中的scope属性来确定创建那种类型的bean
				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, () -> {
							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;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		//对bean的类型进行检查，检查需要的类型参数和实际传参类型是否一致
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isTraceEnabled()) {
					logger.trace("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

通过递归的方式获取当前bean的所有依赖bean的，知道获取到一个没有任何依赖的bean为止。

创建Bean的步骤

1. 获取实际的BeanName，会处理带有&号前缀的Name，并且解析别名
2. 检查单例缓存中是否已经存在有名字是这个beanName的bean，如果存在的话就不需要创建这个bean了
3. 若缓存中没有，则需要检查，在创建这个bean的时候是否存在并发创建，只针对scope为prototype的bean
4. 检查bean是否存在于父类的工厂中，如果存在则由走父类的getBean过程，保证容器中没有同名的bean
5. 标记bean正在被创建。
6. 获取当前bean的所有依赖bean，递归的触发getBean方法，直到一个没有依赖的bean
7. 分单例，多例以及根据scope类型来创建bean
8. 检查需要的类型和生成的bean的类型是否一致
9. 返回创建好的bean。