SpringIoC依赖注入的过程（三）

SpringIoC依赖注入的过程（三）

    上文说到doCreateBean的applyMergedBeanDefinitionPostProcessors方法找到了所有的声明了Autowired标注和Resource标注的字段和方法，以及声明了PostConstruct和PreDestroy标注的方法。到此为止，bean的依赖关系都已经解析到BeanDefinition中，接下来就是利用这些依赖关系进行注入。继续看doCreateBean方法的剩余部分

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");
			}
			addSingletonFactory(beanName, new ObjectFactory() {
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

    这部分代码是什么意思呢？可以看到有一个变量名字叫做allowCircularReferences，可以猜出这里就是处理循环引用的。比如Service1引用了Service2，而Service2也引用了Service1。如果现在正在创建Service1，发现它依赖了Service2，在向Service1注入Service2的过程中肯定要先去创建Service2。这时候发现又要创建Service1，当然不能再创建一个Service1了，而是先将未初始化好的Service1引用先注入到Service2中。然后初始化Service2后再回过来注入到Service1中。关于循环引用的依赖注入过程也许后续会专门的详细解读，今天简单带过，先把主体的流程说通。下面说SpringIoC的重头戏， populateBean方法，依赖注入就发生在这里。还是分段说吧，免得代码太长

		boolean continueWithPropertyPopulation = true;

		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

    上面是要讲的populateBean方法中的第一段代码，它调用所有的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation的方法。 InstantiationAwareBeanPostProcessor的实现类有下面这些

                            
     postProcessAfterInstantiation是在bean被实例化以后留出的扩展方法，但实际上并没有用到，上面那些类都是直接返回了true，依赖注入不是发生在这里。我们继续往下看

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

   这里是一处依赖注入发生的地方，如果当前的bean是AUTOWIRE_BY_NAME或者AUTOWIRE_BY_TYPE的主动注入模式，则会触发相应的注入方法。先看一下autowireByName

	protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			if (containsBean(propertyName)) {
				Object bean = getBean(propertyName);
				pvs.add(propertyName, bean);
				registerDependentBean(propertyName, beanName);
				if (logger.isDebugEnabled()) {
					logger.debug("Added autowiring by name from bean name '" + beanName +
							"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
							"' by name: no matching bean found");
				}
			}
		}
	}

   很好理解，先找到需要注入的依赖的bean的名字，然后递归调用getBean。getBean执行完后就会返回依赖的bean的实例，放入到PropertyValues中。再看看autowireByType是怎么做的

	protected void autowireByType(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}

		Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			try {
				PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
				// Don't try autowiring by type for type Object: never makes sense,
				// even if it technically is a unsatisfied, non-simple property.
				if (!Object.class.equals(pd.getPropertyType())) {
					MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
					// Do not allow eager init for type matching in case of a prioritized post-processor.
					boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
					DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
					Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
					if (autowiredArgument != null) {
						pvs.add(propertyName, autowiredArgument);
					}
					for (String autowiredBeanName : autowiredBeanNames) {
						registerDependentBean(autowiredBeanName, beanName);
						if (logger.isDebugEnabled()) {
							logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
									propertyName + "' to bean named '" + autowiredBeanName + "'");
						}
					}
					autowiredBeanNames.clear();
				}
			}
			catch (BeansException ex) {
				throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
			}
		}
	}

   根据类型自动注入的过程稍复杂一些，总体的过程是这样的。通过resolveDependency方法最终调用DefaultListableBeanFactory中的doResolveDependency方法，然后得到需要注入的bean的实例，同样先放到 PropertyValues中。不早了，先到这里，剩下的后面继续。