这次彻底搞懂IoC容器依赖注入的源码

public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
       // 这些 getBean 接口最终都是通过调用 doGetBean 实现
	return doGetBean(name, requiredType, args, false);
}

// 实际取得 Bean 的地方,即触发依赖注入
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name,
						  final Class<T> requiredType,
						  final Object[] args,
						  boolean typeCheckOnly) {
	// 去掉工厂bean的前缀或者将别名转化为规范名
	final String beanName = transformedBeanName(name);
	Object bean;

    // 检查是否有已注册的bean实例
    // 急切地检查单例模式缓存手动注册的单例
    //先从缓存中取得Bean,处理那些已经被创建过的单例Bean,这种Bean不要重复创建
	Object sharedInstance = getSingleton(beanName);

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

if (sharedInstance != null && args == null) {
    
          ...

          //以取得 FactoryBean 的相关处理及生产结果
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

	// Don't let calling code try to dereference the factory if the bean isn't a factory.
	if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
		throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
	}

	// Now we have the bean instance, which may be a normal bean or a FactoryBean.
	// If it's a FactoryBean, we use it to create a bean instance, unless the
	// caller actually wants a reference to the factory.
	if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
		return beanInstance;
	}

	Object object = null;
	if (mbd == null) {
		object = getCachedObjectForFactoryBean(beanName);
	}
	if (object == null) {
		// Return bean instance from factory.
		FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
		// Caches object obtained from FactoryBean if it is a singleton.
		if (mbd == null && containsBeanDefinition(beanName)) {
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		boolean synthetic = (mbd != null && mbd.isSynthetic());
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

	else {
		// 若早已创建该 bean 实例则会失败进入到此
		// 假设处在引用循环依赖中
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

           // 检查 bean 定义是否存在于该工厂
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// 没有找到,即不存在 -> 检查父类
			String nameToLookup = originalBeanName(name);
			if (args != null) {
				// 有更精确的参数 -> 委托给父类
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else {
				// 无参数 -> 委托给标准的 getBean 方法
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
		}

		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}

		try {
               //根据 Bean 名取得 BeanDefinition  
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);

			
               //递归获得当前 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);
					getBean(dep);
				}
			}
 
               // 创建 singleton bean 的地方
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
					@Override
					public Object getObject() throws BeansException {
						try {
                               // 调用 createBean 创建单例 bean实例
							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);
			}

               // 创建 prototype bean 的地方
			else if (mbd.isPrototype()) {
				// It's a prototype -> create a ne w 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;
		}
	}

	// Check if required type matches the type of the actual bean instance.
       // 这里对创建的Bean进行类型检查,如果没有问题,就返回这个新创建的Bean,这个Bean已经是包含了依赖关系的Bean
	if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
		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;
}

	@Override 
	protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
	    ...
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
        // 判断需要创建的 Bean 是否可被实例化,该类是否可通过类加载器来载入
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		try {
			mbdToUse.prepareMethodOverrides();
		}
	    ...
		try {			
            //给 BeanPostProcessor一个机会返回的是一个Proxy代理而不是目标 bean 的实例
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}
		...
		try {
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			...
			return beanInstance;
		}
		...
	}

protected Object doCreateBean(final String beanName,
							 final RootBeanDefinition mbd,
							 final Object[] args) {
	// 用来持有创建出来的Bean对象 bean实例包装类
	BeanWrapper instanceWrapper = null;
	// 如果是单例,则先把缓存中的同名Bean清除
	if (mbd.isSingleton()) {
	// 从未完成创建的包装Bean缓存中清理并获取相关中的包装Bean实例,因为单例只存一份
	instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	// 这里是创建Bean的地方,由createBeanInstance来完成
	if (instanceWrapper == null) {
		// 根据指定bean使用对应的策略创建新的实例,如:工厂方法,构造器,无参构造器
	instanceWrapper =  createBeanInstance(beanName, mbd, args);
	}
	// 获取被包装的 bean，后续对 bean 的改动相当于对 wrapper 的改动
	final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
	// 获取实例化对象的类型
	Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
	
	// Allow post-processors to modify the merged bean definition.
	// 调用 BeanDefinition 属性合并完成后的 beanPostProcessor 后置处理器
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			mbd.postProcessed = true;
		}
	}
	
	// Eagerly cache singletons to be able to resolve circular references
	// even when triggered by lifecycle interfaces like BeanFactoryAware.
	// 是否需要提前曝光:单例&允许循环依赖&当前bean正在创建中,检测循环依赖
	// 向容器中缓存单例模式的Bean对象,以防循环引用
	// 判断是否是早期引用的bean:
	// 如果是,则允许其提前暴露引用
	// 这里判断的逻辑主要有三个:
	// 1.是否为单例
	// 2.是否允许循环引用
	// 3.是否为在创建中的bean
	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");
	}
	// 为避免后期循环依赖,可以在bean初始化完成前,
	// 将创建实例的ObjectFactory加入工厂(三级缓存)
	// 这是个匿名内部类，为了防止循环引用，尽早持有对象的引用
	addSingletonFactory(beanName, new ObjectFactory<Object>() {
	@Override
	public Object getObject() throws BeansException {
	 // 对bean再次依赖引用,主要应用SMartInstantialiationAware BeanPostProcessor,
	 // AOP就是在这里将advice动态织入bean中,若无则直接返回bean,不做任何处理
	return getEarlyBeanReference(beanName, mbd, bean);
	}
	});
	}
	
	// 这里是对Bean的初始化,依赖注入在此触发
	// 这个exposedObject在初始化处理完后返回,作为依赖注入完成后的Bean
	Object exposedObject = bean;
	try {
	    // 对bean进行填充,将各个属性值注入
	    // 可能存在依赖于其他bean的属性,则会递归初始化依赖bean
		populateBean(beanName, mbd, instanceWrapper);
		if (exposedObject != null) {
			// 调用初始化方法,比如init-method
			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);
	}
	}
	
	if (earlySingletonExposure) {
	Object earlySingletonReference = getSingleton(beanName, false);
	    // earlySingletonReference 只有在检测到有循环依赖的情况下才会非空
	if (earlySingletonReference != null) {
	if (exposedObject == bean) {
	            //如果exposedObject 没有在初始化方法中被改变,也就是没有被增强
	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);
		}
	}
	           //因为bean创建后其所依赖的bean一定是已经创建的,actualDependentBeans非空则表示当前bean创建后其依赖的bean却没有全部创建完,也就是说存在循环依赖
	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.");
	}
	}
	}
	}
	   // Register bean as disposable.
	try {
	                   //根据scope注册bean
	registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
	throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}
	
	return exposedObject;
}

	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
        // 确认需要创建的Bean实例的类可以实例化
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

        //若工厂方法非空,则使用工厂方法策略对Bean进行实例化
		if (mbd.getFactoryMethodName() != null)  {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
                //一个类有多个构造函数,每个构造函数都有不同的参数,所以调用前需要先根据参数锁定构造函数或对应的工厂方法
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
                //如果已经解析过则使用解析好的构造函数方法不需要再次锁定
		if (resolved) {
			if (autowireNecessary) {
                                //构造函数自动注入
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
                               //使用默认构造函数构造
				return instantiateBean(beanName, mbd);
			}
		}

                 // 使用构造函数对Bean进行实例化
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
               //使用默认的构造函数对Bean进行实例化
		return instantiateBean(beanName, mbd);
	}

        //最常见的实例化过程instantiateBean
	protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
                 //使用默认的实例化策略对Bean进行实例化,默认的实例化策略是
       //CglibSubclassingInstantiationStrategy,也就是使用CGLIB实例化Bean 
		try {
			Object beanInstance;
			final BeanFactory parent = this;
			if (System.getSecurityManager() != null) {
				beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
					@Override
					public Object run() {
						return getInstantiationStrategy().instantiate(mbd, beanName, parent);
					}
				}, getAccessControlContext());
			}
			else {
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
			}
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			initBeanWrapper(bw);
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
		}
	}

public class SimpleInstantiationStrategy implements InstantiationStrategy {
    @Override
	public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
		// Don't override the class with CGLIB if no overrides.
		if (bd.getMethodOverrides().isEmpty()) {
            //这里取得指定的构造器或者生成对象的工厂方法来对Bean进行实例化
			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse == null) {
					final Class<?> clazz = bd.getBeanClass();
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						if (System.getSecurityManager() != null) {
							constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
								@Override
								public Constructor<?> run() throws Exception {
									return clazz.getDeclaredConstructor((Class[]) null);
								}
							});
						}
						else {
							constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
						}
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
            //通过BeanUtils进行实例化，这个BeanUtils的实例化通过Constructor来实例化Bean,在BeanUtils中可以看到具体的调用ctor.newInstance(args)
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {		
            // 使用CGLIB来实例化对象
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}
}

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    // 尝试从BeanDefinition中获取PropertyValue的属性集合，还没有值
    PropertyValues pvs = mbd.getPropertyValues();
    
    // 设置上面的PropertyValues的值，默认是getResolvedAutowiredMode方法返回0
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
    	mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // Add property values based on autowire by name if applicable.
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // Add property values based on autowire by type if applicable.
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }
        if (hasInstAwareBpps) {
            // Autowired
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = 
                                                (InstantiationAwareBeanPostProcessor) bp;
                    pvs = ibp.postProcessPropertyValues(//瞅到没，这个方法哦~~~
                                    pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvs == null) {
                        return;
                    }
                }
            }
        }
        if (needsDepCheck) {
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }
    }
    applyPropertyValues(beanName, mbd, bw, pvs);
}