spring容器bean加载过程解析

入口：AbstractBeanFactory的getBean方法：

	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

doGetBean方法会返回指定bean的实例

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

singletonObjects和singletonsCurrentlyInCreation分别保存单例bean和正在创建中的单例bean的map，通过其保证要创建的bean不存在也不在创建过程中。

如果bean不存在，则先标识该bean在创建中了markBeanAsCreated

根据bean名称和bean定义，获取RootBeanDefinition

查询depensOn的bean，并获取它们（如果没创建，则走同样的创建bean流程）

下面就开始创建需要的bean：

sharedInstance = getSingleton(beanName, new ObjectFactory<Object>()

首先通过各种措施，保障只有当前线程执行bean创建，然后调用getObject()方法：

而getObject方法，最终调用了AbstractAutowireCapableBeanFactory的createBean方法：

首先，解析bean定义：

resolveBeanClass

  获取类加载器

ClassLoader beanClassLoader = getBeanClassLoader();

获取类名字对应的表达式

然后对类加载器和类名字进行校验，校验通过，执行mbd.resolveBeanClass(beanClassLoader)

public Class<?> resolveBeanClass(ClassLoader classLoader) throws ClassNotFoundException {
		String className = getBeanClassName();
		if (className == null) {
			return null;
		}
		Class<?> resolvedClass = ClassUtils.forName(className, classLoader);
		this.beanClass = resolvedClass;
		return resolvedClass;
	}

ClassUtils.forName，拿着类加载器，完成了类的加载。这是spring自己封装了，最后还是调用了Class.forName()方法；

上述方法出来，做如下操作：
mbdToUse.prepareMethodOverrides();
上面这一步先不管，看下面这一步：
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

这里做的操作，就是依次执行

InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation和postProcessAfterInstantiation方法：

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}

可以看到，如果没执行BeforeInstantiation，那么也不会执行AfterInitialization

AnnotationConfigApplicationContext

NoCacheAutoProxyCreator

跳出来，执行真正的创建代码：

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		// Make sure bean class is actually resolved at this point.
		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());
		}

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

		// Need to determine the constructor...
		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.
		return instantiateBean(beanName, mbd);
	}

从代码中可以看到，获取构造器依赖于SmartInstantiationAwareBeanPostProcessor，会执行他的determineCandidateConstructors方法。最终执行的AutowiredAnnotationBeanPostProcessor类的方法：

它会遍历类的方法，找Lookup注解，然后再对父类方法执行一致操作；

通过上述一系列操作，找有没有特殊的构造方法。如果没有，则执用无参的构造方法：

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
		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);
		}
	}

beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);

上面通过默认的构造方法，创建了一个对象。到这里，我们的依赖还没有被自动注入。

BeanWrapper bw = new BeanWrapperImpl(beanInstance);

构造BeanWrpper，然后执行initBeanWrapper方法，然后返回初始化后的BeanWrapper对象给调用方。

可以看到doCreateBean方法中执行了applyMergedBeanDefinitionPostProcessors方法：

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}

执行了所有MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法。

依次是：

CommonAnnotationBeanPostProcessor，它会处理@Resource注解，找到需要@Resouce注入的对象；AutowiredAnnotationBeanPostProcessor，它会处理@Autowired，@Value，@Inject。

上述弄完后，执行populateBean方法：

先遍历InstantiationAwareBeanPostProcessor，找到一个匹配的postProcessAfterInstantiation。我这里倒是没执行什么东西。继续往下走。

查看自动注入模式，我这里是根据Name匹配

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

他会调用doGetBean，触发上面加载bean流程，完善依赖bean的加载。

autowireByName，完全是根据属性名字注入的，没有根据@Resource制定的名字去处理。

后面再遍历InstantiationAwareBeanPostProcessor，执行postProcessPropertyValues方法：

CommonAnnotationBeanPostProcessor

InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
		try {
			metadata.inject(bean, beanName, pvs);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
		}
		return pvs;

inject方法完成了属性的注入。

然后是AutowiredAnnotationBeanPostProcessor，完成对应注解依赖的注入。

之后执行

applyPropertyValues(beanName, mbd, bw, pvs);

这里看着也没做啥

 

回到doCreateBean方法，执行

exposedObject = initializeBean(beanName, exposedObject, mbd);

它里面会执行PostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法：

 

回头缕了一下，发现是mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME搞的鬼，导致我的类属性被覆盖。

 

ComponentScanBeanDefinitionParser