Spring doCreateBean 方法解析

大纲理解

1. 先通过反射创建实例
2. 再给属性赋值
3. 调用相关初始化方法

首先看下doGetBean的方法

   /**
     * 返回一个Bean
	 * 
	 * Return an instance, which may be shared or independent, of the specified 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
	 * (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获取实例是否用于类型检查，而不是实际使用
	 * @return an instance of the bean
	 * @throws BeansException if the bean could not be created
	 */
	@SuppressWarnings("unchecked")
	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) {
   
			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 if (requiredType != null) {
   
					// No args -> delegate to standard getBean method.
					// 委托到标准的getBean方法。
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
   
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}

			if (!typeCheckOnly) {
   
				// 标记为创建Bean
				markBeanAsCreated(beanName);
			}

			try {
   
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				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 {
   
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
   
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance.
				// 创建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.
							destroySingleton(beanName);
							throw ex;
						}
					});
					
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				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 IllegalStateExceptio