Spring源码解析(5)之bean实例化过程(上)

        进过前面的分析,接下来就是对面bean加载的过程,其实bean的加载加载过程远比bean的解析要复杂的很多，下面我们对下面的这行代码后面的作用为切入点。

public class MainClass {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
        System.out.println(context.getBean("tulingAspect"));
    }
}

        context.getBean("tulingAspect")；在这行代码中实现了什么功能呢?我们可以快速体验一下Spring中代码是如果实现的。下面这个是我整理原理的一个代码调用流程图，可以先提前看，下面我们会对具体的某个方法的主干作用进行分析。

         i1:>org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)         i2>org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean         i2.1>:org.springframework.beans.factory.support.AbstractBeanFactory#transformedBeanName 转换 beanName         i2.2>:org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton 去缓存 中获取bean         i2.3>:org.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance 对 缓存中的获取的bean进行后续处理         i2.4>:org.springframework.beans.factory.support.AbstractBeanFactory#isPrototypeCurrentlyInCreation 判断原型bean的依赖注入         i2.5>:org.springframework.beans.factory.support.AbstractBeanFactory#getParentBeanFactory 检查父 容器加载bean         i2.6>:org.springframework.beans.factory.support.AbstractBeanFactory#getMergedLocalBeanDefinition 将 bean定义转为RootBeanDifination         i2.7>:检查bean的依赖（bean加载顺序的依赖） i2.8>:org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton根据 scope 的添加来创建bean

         i3>:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean创建 bean的方法         i4>org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean 真 正的创建bean的逻辑         i4.1>:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance 调用构造函数创建对象

        i4.2>:判断是否需要提早暴露对象(mbd.isSingleton() && this.allowCircularReferences && i sSingletonCurrentlyInCreation(beanName));         i4.3>org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactory 暴露对象解决循环依赖         i4.4>:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean 给创建的bean进行赋值         i4.5>:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean对 bean进行初始化         i4.5.1>:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods 调用XXAware接口         i4.5.2>applyBeanPostProcessorsBeforeInitialization 调用bean的后置处理器进行对处理
        i4.5.2>applyBeanPostProcessorsBeforeInitialization 调用bean的后置处理器进行对处理

       i4.5.3>org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeInitMethods 对象的初始化方法         i4.5.3.1>:org.springframework.beans.factory.InitializingBean#afterPropertiesSet 调用 InitializingBean的方法

        i4.5.3.2>:String initMethodName = mbd.getInitMethodName(); 自定义的初始化方法         i5>:org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingleton 把创建好的实 例化好的bean加载缓存中         i6>:org.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance对创建的 bean进行后续的加工

        以上就是getBean大体的调用过程，下面将跟着这些步骤进行源码的学习。

	@Override
	public Object getBean(String name) throws BeansException {
		assertBeanFactoryActive();
		return getBeanFactory().getBean(name);
	}

  这个方法很长，让我们具体来看着他具体是做了那些事情，这里给大家提一点学习源码的建议，看spring源码，看不懂就先跳，有些太过复杂的可以知道这行代码是干嘛的就行，可以先把大体的流程先看完，然后学习源码本身就是一件很枯燥很需要精力的事情，我们需要自己多看几遍然后自己调试几遍。

1. 转换对应的beanName，这里或许很多人不理解，传进来的name不就是beanName么？其实传进来的有可能是别名或者是我们的BeanFactory，所以需要进行一系列的解析，其中解析包括以下内容，(1)去除BeanFactory的修饰符(在我Spring源码分析(1)之常见底层核心注解_jokeMqc的博客-CSDN博客 已经有介绍对应的用法了)(2)去指定的alias获取最终表示的beanName。
2. 尝试去缓存中加载单例，这里就是为了解决循环依赖的关键代码，本节课讲完bean的加载过程会介绍spring是如果解决循环依赖的,要记得我们单例bean在容器中只会被实例化一次，后续在创建bean就直接从单例缓存池中去获取了，这里只是尝试去获取。这里为了解决循环依赖问题，在对象刚刚创建好的时候(还没有进行属性赋值)，就会将创建bean的ObjectFactory提早的暴露到缓存中去，一旦下一个bean创建的时候需要上一个bean那直接就从缓存里面去获取就行了。(后面会着重将这一个)
3. bean的实例化，如果我们从缓存中获取得到bean，我们只是获取得到bean的原始状态，不一定是我们最终需要的bean，需要getObjectForBeanInstance方法中如果bean没有实例化则在这里进行实例化.
4. 对原型依赖的检查，为什么原型对象解决不了循环依赖，这里就说明了，我们的ioc容器并不会对原型对象进行缓存，而是获取一次则创建一次bean，isPrototypeCurrentlyInCreation是检查如果A中有B的属性，B中有A的属性，那么当依赖注入的时候，此时就会有A还没有创建完，然后需要去创建B，继而又要创建A，这个时候就会抛出异常了。
5. 检测parentFactory，其实这里代码的意思很简单，如果当前的bean存在父容器并且当前容器找不到对应的bean定义，那么就去父容器中进行加载。
6. 合并父类属性(下面也会有具体的介绍)
7. 寻找依赖，就是我们在bean标注的depends-on，但是需要注意的一点就是如果A depends-on B，B depends-on A这个就会抛异常的
8. 针对不同的scope进行bean的创建
9. 类型转换，到这里其实整个bean的加载过程已经结束了。

	protected  T doGetBean(
			final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
		
		final String beanName = transformedBeanName(name);
		Object bean;

		
		 // 直接从缓存中去取或从对象工厂缓存去取
		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 + "'");
				}
			}
			
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

// 获取父容器
			BeanFactory parentBeanFactory = getParentBeanFactory();
			// 如果beanDefinitionMap以及所有加载的bean不包含 本次加载的bean则从父容器中去加载
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// 从父容器中递归查询
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
			
			// 这里不是做类型检查，而是创建bean，这里需要标记一下
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// 用来处理bean的加载顺序，比如要在创建instA的情况下要先创建instrB
				
				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);
						}
					}
				}

// 创建bean，单例
				if (mbd.isSingleton()) {
					// 创建单例bean
					sharedInstance = getSingleton(beanName, new ObjectFactory