Spring源码分析（三）（IoC容器的依赖注入）（2）

水深无声 2022-04-14 07:13 222阅读 0赞

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    		//这里取得在BeanDefinition中设置的property值，这些property来自对BeanDefinition的解析
    		//具体的解析过程可以参看载入和解析BeanDefinitoin的分析
    		PropertyValues pvs = mbd.getPropertyValues();
    
    		if (bw == null) {
    			if (!pvs.isEmpty()) {
    				throw new BeanCreationException(
    						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
    			}
    			else {
    				// Skip property population phase for null instance.
    				return;
    			}
    		}
    
    		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
    		// state of the bean before properties are set. This can be used, for example,
    		// to support styles of field injection.
    		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;
    					}
    				}
    			}
    		}
    
    		if (!continueWithPropertyPopulation) {
    			return;
    		}
    		//这里对autowire注入的处理，可以根据Bean的名称或者类型来完成Bean的autowire
    		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;
    		}
    
    		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
    
    		if (hasInstAwareBpps || needsDepCheck) {
    			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    			if (hasInstAwareBpps) {
    				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);
    	}
    
    
    
    	//通过applyPropertyValues了解具体的对属性进行解析然后注入的过程
    	protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    		if (pvs == null || pvs.isEmpty()) {
    			return;
    		}
    
    		if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
    			((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
    		}
    
    		MutablePropertyValues mpvs = null;
    		List<PropertyValue> original;
    
    		if (pvs instanceof MutablePropertyValues) {
    			mpvs = (MutablePropertyValues) pvs;
    			if (mpvs.isConverted()) {
    				// Shortcut: use the pre-converted values as-is.
    				try {
    					bw.setPropertyValues(mpvs);
    					return;
    				}
    				catch (BeansException ex) {
    					throw new BeanCreationException(
    							mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    				}
    			}
    			original = mpvs.getPropertyValueList();
    		}
    		else {
    			original = Arrays.asList(pvs.getPropertyValues());
    		}
    
    		TypeConverter converter = getCustomTypeConverter();
    		if (converter == null) {
    			converter = bw;
    		}
    		//BeanDefinitionValueResolver对BeanDefinition的解析在这个valueResolver中完成
    		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
    
    		// Create a deep copy, resolving any references for values.
    		//这里为解析值创建一个副本，副本中的数据将会被注入到Bean中
    		List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
    		boolean resolveNecessary = false;
    		for (PropertyValue pv : original) {
    			if (pv.isConverted()) {
    				deepCopy.add(pv);
    			}
    			else {
    				String propertyName = pv.getName();
    				Object originalValue = pv.getValue();
    				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
    				Object convertedValue = resolvedValue;
    				boolean convertible = bw.isWritableProperty(propertyName) &&
    						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
    				if (convertible) {
    					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
    				}
    				// Possibly store converted value in merged bean definition,
    				// in order to avoid re-conversion for every created bean instance.
    				if (resolvedValue == originalValue) {
    					if (convertible) {
    						pv.setConvertedValue(convertedValue);
    					}
    					deepCopy.add(pv);
    				}
    				else if (convertible && originalValue instanceof TypedStringValue &&
    						!((TypedStringValue) originalValue).isDynamic() &&
    						!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
    					pv.setConvertedValue(convertedValue);
    					deepCopy.add(pv);
    				}
    				else {
    					resolveNecessary = true;
    					deepCopy.add(new PropertyValue(pv, convertedValue));
    				}
    			}
    		}
    		if (mpvs != null && !resolveNecessary) {
    			mpvs.setConverted();
    		}
    
    		// Set our (possibly massaged) deep copy.
    		//这里是依赖注入发生的地方，会在AbstractNestablePropertyAccessor中完成
    		try {
    			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    		}
    		catch (BeansException ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    		}
    	}

这里通过使用BeanDefinitionValueResolver来对BeanDefinition进行解析，然后注入到property中。具体的对Bean reference进行解析的过程如代码所示:

private Object resolveReference(Object argName, RuntimeBeanReference ref) {
    		try {
    			//从RuntimeBeanReference取得reference的名字，
    			// 这个RuntimeBeanReference是在载入BeanDefinition时根据配置生成
    			String refName = ref.getBeanName();
    			refName = String.valueOf(doEvaluate(refName));
    			//如果ref是在双亲IoC容器中，那就到双亲IoC容器中去获取
    			if (ref.isToParent()) {
    				if (this.beanFactory.getParentBeanFactory() == null) {
    					throw new BeanCreationException(
    							this.beanDefinition.getResourceDescription(), this.beanName,
    							"Can't resolve reference to bean '" + refName +
    							"' in parent factory: no parent factory available");
    				}
    				return this.beanFactory.getParentBeanFactory().getBean(refName);
    			}
    			//在当前IoC容器中获取Bean，这里会触发一个getBean的过程，
    			// 如果依赖注入没有发生，这里会触发相应的依赖注入的发生
    			else {
    				Object bean = this.beanFactory.getBean(refName);
    				this.beanFactory.registerDependentBean(refName, this.beanName);
    				return bean;
    			}
    		}
    		catch (BeansException ex) {
    			throw new BeanCreationException(
    					this.beanDefinition.getResourceDescription(), this.beanName,
    					"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
    		}
    	}

对属性进行最终解析的是resolveValueIfNecessary方法，这个方法包含了所有注入类型的处理：

public Object resolveValueIfNecessary(Object argName, Object value) {
    		// We must check each value to see whether it requires a runtime reference
    		// to another bean to be resolved.
    		//对RuntimeBeanReference进行解析，RuntimeBeanReference
    		// 是在对BeanDefinition进行解析时生成的数据对象
    		//对Bean Reference的解析
    		if (value instanceof RuntimeBeanReference) {
    			RuntimeBeanReference ref = (RuntimeBeanReference) value;
    			return resolveReference(argName, ref);
    		}
    		else if (value instanceof RuntimeBeanNameReference) {
    			String refName = ((RuntimeBeanNameReference) value).getBeanName();
    			refName = String.valueOf(doEvaluate(refName));
    			if (!this.beanFactory.containsBean(refName)) {
    				throw new BeanDefinitionStoreException(
    						"Invalid bean name '" + refName + "' in bean reference for " + argName);
    			}
    			return refName;
    		}
    		else if (value instanceof BeanDefinitionHolder) {
    			// Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
    			BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
    			return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
    		}
    		else if (value instanceof BeanDefinition) {
    			// Resolve plain BeanDefinition, without contained name: use dummy name.
    			BeanDefinition bd = (BeanDefinition) value;
    			String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
    					ObjectUtils.getIdentityHexString(bd);
    			return resolveInnerBean(argName, innerBeanName, bd);
    		}
    		//对ManagedArray进行解析
    		else if (value instanceof ManagedArray) {
    			// May need to resolve contained runtime references.
    			ManagedArray array = (ManagedArray) value;
    			Class<?> elementType = array.resolvedElementType;
    			if (elementType == null) {
    				String elementTypeName = array.getElementTypeName();
    				if (StringUtils.hasText(elementTypeName)) {
    					try {
    						elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
    						array.resolvedElementType = elementType;
    					}
    					catch (Throwable ex) {
    						// Improve the message by showing the context.
    						throw new BeanCreationException(
    								this.beanDefinition.getResourceDescription(), this.beanName,
    								"Error resolving array type for " + argName, ex);
    					}
    				}
    				else {
    					elementType = Object.class;
    				}
    			}
    			return resolveManagedArray(argName, (List<?>) value, elementType);
    		}
    		//对ManagedList进行解析
    		else if (value instanceof ManagedList) {
    			// May need to resolve contained runtime references.
    			return resolveManagedList(argName, (List<?>) value);
    		}
    		//对ManagedSet进行解析
    		else if (value instanceof ManagedSet) {
    			// May need to resolve contained runtime references.
    			return resolveManagedSet(argName, (Set<?>) value);
    		}
    		//对ManagedMap进行解析
    		else if (value instanceof ManagedMap) {
    			// May need to resolve contained runtime references.
    			return resolveManagedMap(argName, (Map<?, ?>) value);
    		}
    		//对ManagedProperties进行解析
    		else if (value instanceof ManagedProperties) {
    			Properties original = (Properties) value;
    			Properties copy = new Properties();
    			for (Map.Entry<Object, Object> propEntry : original.entrySet()) {
    				Object propKey = propEntry.getKey();
    				Object propValue = propEntry.getValue();
    				if (propKey instanceof TypedStringValue) {
    					propKey = evaluate((TypedStringValue) propKey);
    				}
    				if (propValue instanceof TypedStringValue) {
    					propValue = evaluate((TypedStringValue) propValue);
    				}
    				copy.put(propKey, propValue);
    			}
    			return copy;
    		}
    		//对TypedStringValue进行解析
    		else if (value instanceof TypedStringValue) {
    			// Convert value to target type here.
    			TypedStringValue typedStringValue = (TypedStringValue) value;
    			Object valueObject = evaluate(typedStringValue);
    			try {
    				Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
    				if (resolvedTargetType != null) {
    					return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
    				}
    				else {
    					return valueObject;
    				}
    			}
    			catch (Throwable ex) {
    				// Improve the message by showing the context.
    				throw new BeanCreationException(
    						this.beanDefinition.getResourceDescription(), this.beanName,
    						"Error converting typed String value for " + argName, ex);
    			}
    		}
    		else {
    			return evaluate(value);
    		}
    	}
    
    //如：
    	private Object resolveReference(Object argName, RuntimeBeanReference ref) {
    		try {
    			//从RuntimeBeanReference取得reference的名字，
    			// 这个RuntimeBeanReference是在载入BeanDefinition时根据配置生成
    			String refName = ref.getBeanName();
    			refName = String.valueOf(doEvaluate(refName));
    			//如果ref是在双亲IoC容器中，那就到双亲IoC容器中去获取
    			if (ref.isToParent()) {
    				if (this.beanFactory.getParentBeanFactory() == null) {
    					throw new BeanCreationException(
    							this.beanDefinition.getResourceDescription(), this.beanName,
    							"Can't resolve reference to bean '" + refName +
    							"' in parent factory: no parent factory available");
    				}
    				return this.beanFactory.getParentBeanFactory().getBean(refName);
    			}
    			//在当前IoC容器中获取Bean，这里会触发一个getBean的过程，
    			// 如果依赖注入没有发生，这里会触发相应的依赖注入的发生
    			else {
    				Object bean = this.beanFactory.getBean(refName);
    				this.beanFactory.registerDependentBean(refName, this.beanName);
    				return bean;
    			}
    		}
    		catch (BeansException ex) {
    			throw new BeanCreationException(
    					this.beanDefinition.getResourceDescription(), this.beanName,
    					"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
    		}
    	}

在完成这个解析过程后，已经为依赖注入准备好了条件，这是真正把Bean对象设置到它所依赖的另一个Bean的属性中去的地方，其中处理的属性是各种各样的。依赖注入的发生是在BeanWrapper的setPropertyValues 中实现的，具体的完成却是在AbstractNestablePropertyAccessor中实现的，如代码所示：

public void setPropertyValues(PropertyValues pvs) throws BeansException {
    		setPropertyValues(pvs, false, false);
    	}
    
    	public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
    			throws BeansException {
    
    		List<PropertyAccessException> propertyAccessExceptions = null;
    		List<PropertyValue> propertyValues = (pvs instanceof MutablePropertyValues ?
    				((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
    		for (PropertyValue pv : propertyValues) {
    			try {
    				// This method may throw any BeansException, which won't be caught
    				// here, if there is a critical failure such as no matching field.
    				// We can attempt to deal only with less serious exceptions.
    				setPropertyValue(pv);
    			}
    			catch (NotWritablePropertyException ex) {
    				if (!ignoreUnknown) {
    					throw ex;
    				}
    				// Otherwise, just ignore it and continue...
    			}
    			catch (NullValueInNestedPathException ex) {
    				if (!ignoreInvalid) {
    					throw ex;
    				}
    				// Otherwise, just ignore it and continue...
    			}
    			catch (PropertyAccessException ex) {
    				if (propertyAccessExceptions == null) {
    					propertyAccessExceptions = new LinkedList<PropertyAccessException>();
    				}
    				propertyAccessExceptions.add(ex);
    			}
    		}
    
    		// If we encountered individual exceptions, throw the composite exception.
    		if (propertyAccessExceptions != null) {
    			PropertyAccessException[] paeArray =
    					propertyAccessExceptions.toArray(new PropertyAccessException[propertyAccessExceptions.size()]);
    			throw new PropertyBatchUpdateException(paeArray);
    		}
    	}
    
    
    	public void setPropertyValue(PropertyValue pv) throws BeansException {
    		setPropertyValue(pv.getName(), pv.getValue());
    	}
    
    
    
    	public void setPropertyValue(String propertyName, Object value) throws BeansException {
    		AbstractNestablePropertyAccessor nestedPa;
    		try {
    			nestedPa = getPropertyAccessorForPropertyPath(propertyName);
    		}
    		catch (NotReadablePropertyException ex) {
    			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
    					"Nested property in path '" + propertyName + "' does not exist", ex);
    		}
    		PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
    		nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
    	}
    
    
    
    
    	protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
    		if (tokens.keys != null) {
    			processKeyedProperty(tokens, pv);
    		}
    		else {
    			processLocalProperty(tokens, pv);
    		}
    	}
    
    
    	private void processKeyedProperty(PropertyTokenHolder tokens, PropertyValue pv) {
    		//设置token的索引和keys,getPropertyValue取得Bean中对注入对象的引用Array set map并返回
    		Object propValue = getPropertyHoldingValue(tokens);
    		String lastKey = tokens.keys[tokens.keys.length - 1];
    		//这里对Array进行注入
    		if (propValue.getClass().isArray()) {
    			PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
    			Class<?> requiredType = propValue.getClass().getComponentType();
    			int arrayIndex = Integer.parseInt(lastKey);
    			Object oldValue = null;
    			try {
    				if (isExtractOldValueForEditor() && arrayIndex < Array.getLength(propValue)) {
    					oldValue = Array.get(propValue, arrayIndex);
    				}
    				Object convertedValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
    						requiredType, ph.nested(tokens.keys.length));
    				int length = Array.getLength(propValue);
    				if (arrayIndex >= length && arrayIndex < this.autoGrowCollectionLimit) {
    					Class<?> componentType = propValue.getClass().getComponentType();
    					Object newArray = Array.newInstance(componentType, arrayIndex + 1);
    					System.arraycopy(propValue, 0, newArray, 0, length);
    					setPropertyValue(tokens.actualName, newArray);
    					propValue = getPropertyValue(tokens.actualName);
    				}
    				Array.set(propValue, arrayIndex, convertedValue);
    			}
    			catch (IndexOutOfBoundsException ex) {
    				throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
    						"Invalid array index in property path '" + tokens.canonicalName + "'", ex);
    			}
    		}
    		//这里对List进行注入
    		else if (propValue instanceof List) {
    			PropertyHandler ph = getPropertyHandler(tokens.actualName);
    			Class<?> requiredType = ph.getCollectionType(tokens.keys.length);
    			List<Object> list = (List<Object>) propValue;
    			int index = Integer.parseInt(lastKey);
    			Object oldValue = null;
    			if (isExtractOldValueForEditor() && index < list.size()) {
    				oldValue = list.get(index);
    			}
    			Object convertedValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
    					requiredType, ph.nested(tokens.keys.length));
    			int size = list.size();
    			if (index >= size && index < this.autoGrowCollectionLimit) {
    				for (int i = size; i < index; i++) {
    					try {
    						list.add(null);
    					}
    					catch (NullPointerException ex) {
    						throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
    								"Cannot set element with index " + index + " in List of size " +
    								size + ", accessed using property path '" + tokens.canonicalName +
    								"': List does not support filling up gaps with null elements");
    					}
    				}
    				list.add(convertedValue);
    			}
    			else {
    				try {
    					list.set(index, convertedValue);
    				}
    				catch (IndexOutOfBoundsException ex) {
    					throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
    							"Invalid list index in property path '" + tokens.canonicalName + "'", ex);
    				}
    			}
    		}
    		//这里对Map进行注入
    		else if (propValue instanceof Map) {
    			PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
    			Class<?> mapKeyType = ph.getMapKeyType(tokens.keys.length);
    			Class<?> mapValueType = ph.getMapValueType(tokens.keys.length);
    			Map<Object, Object> map = (Map<Object, Object>) propValue;
    			// IMPORTANT: Do not pass full property name in here - property editors
    			// must not kick in for map keys but rather only for map values.
    			TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(mapKeyType);
    			Object convertedMapKey = convertIfNecessary(null, null, lastKey, mapKeyType, typeDescriptor);
    			Object oldValue = null;
    			if (isExtractOldValueForEditor()) {
    				oldValue = map.get(convertedMapKey);
    			}
    			// Pass full property name and old value in here, since we want full
    			// conversion ability for map values.
    			Object convertedMapValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
    					mapValueType, ph.nested(tokens.keys.length));
    			map.put(convertedMapKey, convertedMapValue);
    		}
    
    		else {
    			throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
    					"Property referenced in indexed property path '" + tokens.canonicalName +
    					"' is neither an array nor a List nor a Map; returned value was [" + propValue + "]");
    		}
    	}
    
    
    	private Object getPropertyHoldingValue(PropertyTokenHolder tokens) {
    		// Apply indexes and map keys: fetch value for all keys but the last one.
    		//设置token的索引和keys
    		PropertyTokenHolder getterTokens = new PropertyTokenHolder();
    		getterTokens.canonicalName = tokens.canonicalName;
    		getterTokens.actualName = tokens.actualName;
    		getterTokens.keys = new String[tokens.keys.length - 1];
    		System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);
    
    		Object propValue;
    		//getPropertyValue取得Bean中对注入对象的引用Array set map
    		try {
    			propValue = getPropertyValue(getterTokens);
    		}
    		catch (NotReadablePropertyException ex) {
    			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
    					"Cannot access indexed value in property referenced " +
    					"in indexed property path '" + tokens.canonicalName + "'", ex);
    		}
    
    		if (propValue == null) {
    			// null map value case
    			if (isAutoGrowNestedPaths()) {
    				int lastKeyIndex = tokens.canonicalName.lastIndexOf('[');
    				getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
    				propValue = setDefaultValue(getterTokens);
    			}
    			else {
    				throw new NullValueInNestedPathException(getRootClass(), this.nestedPath + tokens.canonicalName,
    						"Cannot access indexed value in property referenced " +
    						"in indexed property path '" + tokens.canonicalName + "': returned null");
    			}
    		}
    		return propValue;
    	}

这样就完成于对各种Bean属性的依赖注入过程。  
    在Bean的创建和对象依赖注入的过程中，需要依据BeanDefinition中的信息来递归地完成依赖注入。从上面的几个递归过程中可以看到，这些递归都是以getBean为入口的。一个递归是在上下文体系中查找需要的Bean和创建Bean的递归调用，另一个递归是在依赖注入时，通过递归调用容器的getBean方法，得到当前Bean的依赖Bean ，同时也触发对依赖Bean的创建和注入。在对Bean的属性进行依赖注入时，解析的过程也是一个递归的过程。这样，根据依赖关系， 一层一层地完成Bean的创建和注入，直到最后完成当前Bean的创建。有了这个顶层Bean的创建和对它的属性依赖注入的完成，意味着和当前Bean相关的整个依赖链的注入也完成了。  
    总结：**spring在依赖注入时先返回所有依赖列表然后递归创建createBean，里面也分两步，首先根据creatbeanInstance反射或者cglib创建出bean，在通过populateBean注入属性这里还有一个递归(解析)，最后通过BeanWrapperImpl的setPropertyValues方法对属性进行注入，最后依赖链的完成代表这个Bean已经成功生成。**