Spring之Bean生命周期源码解析

（二）   Bean对象实例化 

   上面程序中前三行对applicationContext.xml解析完成之后并没有生成bean实例，那么bean对象是在哪里实例化的？答案是在第一次获取bean实例的时候，也就是在调用DefaultListableBeanFactory的getBean的时候，注意，这里只是针对BeanFactory而言的并不是针对ApplicationContext的，ApplicationContext在实例化BeanFactory对象后会通过一个循环把所有单例bean实例化。

bean实例的创建调用轨迹如下：

1，AbstractBeanFactory.getBean(String)
2，AbstractBeanFactory.doGetBean(String, Class, Object[], boolean)
3，DefaultSingletonBeanRegistry.getSingleton(String)
4，AbstractAutowireCapableBeanFactory.createBean(String, RootBeanDefinition, Object[])
5，AbstractAutowireCapableBeanFactory.doCreateBean(String, RootBeanDefinition, Object[])
6，AbstractAutowireCapableBeanFactory.createBeanInstance(String, RootBeanDefinition, Object[])
7，AbstractAutowireCapableBeanFactory.instantiateBean(String, RootBeanDefinition)
8，SimpleInstantiationStrategy.instantiate(RootBeanDefinition, String, BeanFactory)
9， AbstractAutowireCapableBeanFactory.populateBean(String, RootBeanDefinition, BeanWrapper)
10，AbstractAutowireCapableBeanFactory.initializeBean(String, Object, RootBeanDefinition)
11，AbstractAutowireCapableBeanFactory.invokeAwareMethods(String, Object)
12，AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(Object, String)
13，AbstractAutowireCapableBeanFactory.invokeInitMethods(String, Object, RootBeanDefinition)
14，AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization(Object, String)

 主要类的类图：

在通过BeanFactory获取bean实例对象的时候，会先去单例集合中找是否已经创建了对应的实例，如果有就直接返回了，这里是第一次获取，所以没有拿到；然后AbastractBeanFactory会根据bean的名称获取对应的BeanDefinition对象，BeanDefinition对象代表了对应类的各种元数据，所以根据BeanDefinition对象就可以判断是否是单例，是否依赖其他对象，如果依赖了其他对象那么先生成其依赖，这里是递归调用，源码如下：

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 {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 从父BeanFactory找
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				} else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

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

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

				// 运行到这里说明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);
						//实例化依赖的bean
						getBean(dep);
					}
				}

				// 如果是单例则开始创建bean实例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory