Spring Bean的实例化之属性注入源码剖析过程

前言

喜欢我的文章的话就给个好评吧,你的肯定是我坚持写作最大的动力,来吧兄弟们,给我一点动力

这一章节我们来讨论创建Bean过程中的属性注入,在Spring的IOC容器启动过程中,会把定义的Bean封装成BeanDefinition注册到一个ConcurrentHashMap中,Bean注册完成后,就会对单利的且lazy-init=false 的Bean进行实例化。创建Bean的代码在 AbstractAutowireCapableBeanFactory#doCreateBean 中,当Bean创建成功之后,会调用AbstractAutowireCapableBeanFactory#populateBean 方法进行属性注入。本篇文章主要就是分析该方法是如何实现Bean的属性注入的。

这里先上一个属性注入的流程图,待会儿可以根据这个图来看代码

属性注入:AbstractAutowireCapableBeanFactory#populateBean

AbstractAutowireCapableBeanFactory#populateBean 方法的主要功能就是属性填充,源码如下

//使用 bean 定义中的属性值填充给定 BeanWrapper 中的 bean 实例。
	@SuppressWarnings("deprecation")  // for postProcessPropertyValues
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			//判断是否有property属性
			if (mbd.hasPropertyValues()) {
				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.
		//让 InstantiationAwareBeanPostProcessors 也在属性注入之前改变Bean的状态
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}
		//从 RootBeanDefinition 获取所有的PropertyValues
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		//根据名字获取根据type注入
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			//如果适用,根据名称添加基于自动装配的属性值。
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			//如果适用,根据类型添加基于自动装配的属性值
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
		//后置处理器是否已经注册,初始化好了
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		//是否要检查依赖,默认false
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			//获取后置处理器
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				//如果是Bean实例化后置处理器
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					//
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						//对需要依赖检查的属性进行后置处理
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			//依赖注入入口,讲属性应用到Bean中
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

方法中的重要代码

  • autowireByName : 根据属性名进行注入
  • autowireByType:根据类型注入Bean
  • InstantiationAwareBeanPostProcessor.postProcessPropertyValues :该方法是在工厂将给定的属性值应用于给定的 bean 之前对给定的属性值进行处理,比如:RequiredAnnotationBeanPostProcessor类中对属性的验证。
  • applyPropertyValues:属性的填充
AbstractAutowireCapableBeanFactory#autowireByName

autowireByName是根据名字注入,源码如下

protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
		//寻找BeanWrapper中需要依赖的属性
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			if (containsBean(propertyName)) {
				//递归实例化的Bean
				Object bean = getBean(propertyName);
				pvs.add(propertyName, bean);
				//注册依赖的Bean,加入 dependentBeanMap 中
				registerDependentBean(propertyName, beanName);
				if (logger.isTraceEnabled()) {
					logger.trace("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,递归初始化,然后加入 pvs中

//定义“按类型自动装配”(按类型的 bean 属性)行为的抽象方法
	protected void autowireByType(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
		//类型转换器
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}

		Set autowiredBeanNames = new LinkedHashSet(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 != pd.getPropertyType()) {
					//获取对象的set方法
					MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
					// Do not allow eager init for type matching in case of a prioritized post-processor.

					boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
					//依赖描述
					DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
					//【重要】得到依赖的属性的值,存储到 autowiredBeanNames 集合中
					//提供了对集合如:@Autowired private Listas; 支持,根据类型走到所有的Bean注入其中
					Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
					if (autowiredArgument != null) {
						//添加到pvs
						pvs.add(propertyName, autowiredArgument);
					}
					for (String autowiredBeanName : autowiredBeanNames) {
						//注入依赖的Bean
						registerDependentBean(autowiredBeanName, beanName);
						if (logger.isTraceEnabled()) {
							logger.trace("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);
			}
		}
	}

看到这,我们大概清楚了,其实在populateBean 方法中会先从RootBeanDefinition 中获取 Bean的属性(PropertyValues),同时也会根据RootBeanDefinition的autowireMode自动注入模式来根据name或者type寻主Bean的依赖的属性。

根据类型注入和根据名字注入都是先从BeanWrapper 中找到Bean的依赖的属性,然后根据属性类型找到匹配的Bean,实现依赖注入。还提供了对集合如:@Autowired private Listas; 集合注入的支持。

属性寻找好之后都会封装成 PropertyValues,然后传给applyPropertyValues应用到Bean身上。

AbstractAutowireCapableBeanFactory#applyPropertyValues

我们可以认为前面的代码是在为当前Bean寻找依赖的的属性,封装到 PropertyValues中,在applyPropertyValues中才是把属性应用到当前Bean。

//处理对象之间的引用,使用深拷贝
	protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		if (pvs.isEmpty()) {
			return;
		}

		if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
			((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
		}

		MutablePropertyValues mpvs = null;
		List original;

		if (pvs instanceof MutablePropertyValues) {
			mpvs = (MutablePropertyValues) pvs;
			//判断mpvs中的值是否已经转成了对应的类型,已经转了就可以直接设置值到 BeanWrapper了
			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 {
			//如果类型不是MutablePropertyValues , 就使用原生属性获取方法
			original = Arrays.asList(pvs.getPropertyValues());
		}
		//获取用户自定义的型转换器
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}
		//解析器:用于 bean 工厂实现的 Helper 类,将 bean 定义对象中包含的值,解析为应用于目标 bean 实例的实际值。
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

		// Create a deep copy, resolving any references for values.
		//存放类型转换过的属性,把Bean的属性解析值新建拷贝,把拷贝的数据注入到对象
		List deepCopy = new ArrayList(original.size());
		boolean resolveNecessary = false;
		//类型转换,把属性转换为对应的类型
		for (PropertyValue pv : original) {
			if (pv.isConverted()) {
			//属性值不需要转
				deepCopy.add(pv);
			}
			else {
				//属性名
				String propertyName = pv.getName();
				//原始属性值,它的类型是一个 如: RuntimeBeanReference 引用类型
				Object originalValue = pv.getValue();
				//转换属性值,将引用转换为 IOC 容器中实例化对象引用  OtherBean
				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 ,把依赖的Bean设置给PropertyValue
						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;
					//转换好的依赖的属性最终放到一个ArrayList中
					deepCopy.add(new PropertyValue(pv, convertedValue));
				}
			}
		}
		if (mpvs != null && !resolveNecessary) {
			mpvs.setConverted();
		}

		// Set our (possibly massaged) deep copy.
		try {
			//把解析好的属性 设置到 BeanWrapper 中
			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
		}
	}

这里主要进行属性转换,然后应用到Bean身上,这里的属性转换比如: 在BeanDefinition中属性可能是用字符串类型来描述的,需要把属性转成真实的原始属性类型。

  • 首先判断属性是否需要转换类型,如果不需要转直接应用于Bean。比如: 这种属性值其实是个字符串“otherBean” ,需要解析成容器中的OtherBean实例的引用。
  • 如果属性值需要类型转换,比如:属性值是容器中的另外一个Bean,则需要根据属性值解析出引用的对象然后注入到对象的属性上,应用到Bean。

通过 BeanDefinitionValueResolver 类中的 resolveValueIfNecessary()方法中进行属性值的解析, 对属性值的注入是通过 bw.setPropertyValues()方法完成

解析: BeanDefinitionValueResolver#resolveValueIfNecessary

给定一个 PropertyValue根据属性值进行类型解析,必要时解析对工厂中其他 bean 的引用

@Nullable
	public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
		// We must check each value to see whether it requires a runtime reference
		// to another bean to be resolved.
		//对属性值是引用类型的解析
		if (value instanceof RuntimeBeanReference) {
			//比如: 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);
		}
		//对集合类型解析
		else if (value instanceof ManagedList) {
			// May need to resolve contained runtime references.
			return resolveManagedList(argName, (List>) value);
		}
		//对Set类型解析
		else if (value instanceof ManagedSet) {
			// May need to resolve contained runtime references.
			return resolveManagedSet(argName, (Set>) value);
		}
		//对Map类型解析
		else if (value instanceof ManagedMap) {
			// May need to resolve contained runtime references.
			return resolveManagedMap(argName, (Map, ?>) value);
		}
		//对Properties解析
		else if (value instanceof ManagedProperties) {
			Properties original = (Properties) value;
			Properties copy = new Properties();
			original.forEach((propKey, propValue) -> {
				if (propKey instanceof TypedStringValue) {
					propKey = evaluate((TypedStringValue) propKey);
				}
				if (propValue instanceof TypedStringValue) {
					propValue = evaluate((TypedStringValue) propValue);
				}
				if (propKey == null || propValue == null) {
					throw new BeanCreationException(
							this.beanDefinition.getResourceDescription(), this.beanName,
							"Error converting Properties key/value pair for " + argName + ": resolved to null");
				}
				copy.put(propKey, propValue);
			});
			return copy;
		}
		//解析字符串类型的属性值
		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 {
					//类型没获取到,就返回Object类型
					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 if (value instanceof NullBean) {
			return null;
		}
		else {
			return evaluate(value);
		}
	}

这个方法中就是根据属性的值的类型进行解析,如:String,Array,List,Set,Map的类型,比较复杂的就是属性值依赖的是一个Bean,那么就需要根据依赖的Bean的名字找到容器中的Bean的实例,查找如下:

/**
	 * Resolve a reference to another bean in the factory.
	 */
	 //关联对象的解析
	@Nullable
	private Object resolveReference(Object argName, RuntimeBeanReference ref) {
		try {
			Object bean;
			//引用对象的名称
			String refName = ref.getBeanName();
			refName = String.valueOf(doEvaluate(refName));
			//如果对象在父容器中,从父容器获取
			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");
				}
				//如果对象在父容器中,从父容器获取
				bean = this.beanFactory.getParentBeanFactory().getBean(refName);
			}
			else {
				//[重要]根据依赖的Bean的名字,从当前容器中获取Bean
				bean = this.beanFactory.getBean(refName);
				//把依赖的Bean的实例和当前对象建议依赖关系,使用 dependentBeanMap 去维护关系
				this.beanFactory.registerDependentBean(refName, this.beanName);
			}
			if (bean instanceof NullBean) {
				bean = null;
			}
			return bean;
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					this.beanDefinition.getResourceDescription(), this.beanName,
					"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
		}
	}



 * For each element in the managed array, resolve reference if necessary.
	 */
	 //解析数组
	private Object resolveManagedArray(Object argName, List> ml, Class> elementType) {
		Object resolved = Array.newInstance(elementType, ml.size());
		for (int i = ; i  resolveManagedList(Object argName, List> ml) {
		List resolved = new ArrayList(ml.size());
		for (int i = ; i  resolveManagedSet(Object argName, Set> ms) {
		Set resolved = new LinkedHashSet(ms.size());
		int i = ;
		for (Object m : ms) {
			resolved.add(resolveValueIfNecessary(new KeyedArgName(argName, i), m));
			i++;
		}
		return resolved;
	}

	/**
	 * For each element in the managed map, resolve reference if necessary.
	 */
	 //解析Map
	private Map, ?> resolveManagedMap(Object argName, Map, ?> mm) {
		Map resolved = new LinkedHashMap(mm.size());
		mm.forEach((key, value) -> {
			Object resolvedKey = resolveValueIfNecessary(argName, key);
			Object resolvedValue = resolveValueIfNecessary(new KeyedArgName(argName, key), value);
			resolved.put(resolvedKey, resolvedValue);
		});
		return resolved;
	}

属性值解析完成之后 是封装成一个 MutablePropertyValues,通过 BeanWrapperImpl.setPropertyValues()方法完成值的注入,BeanWrapperImpl中注入方法又是由AbstractPropertyAccessor#setPropertyValue(java.lang.String, java.lang.Object)去完成。

AbstractPropertyAccessor#setPropertyValue
@Override
	public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
			throws BeansException {

		List propertyAccessExceptions = null;
		//拿到所有的属性列表
		List 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);
			}
			...省略...

@Override
	public void setPropertyValue(String propertyName, @Nullable 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));
	}

这里看到,属性的注入交给了 AbstractNestablePropertyAccessor 属性访问器去完成

protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
		if (tokens.keys != null) {
			processKeyedProperty(tokens, pv);
		}
		else {
			//走这里
			processLocalProperty(tokens, pv);
		}
	}

private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
		//属性处理器
		PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
		if (ph == null || !ph.isWritable()) {
			if (pv.isOptional()) {
				if (logger.isDebugEnabled()) {
					logger.debug("Ignoring optional value for property '" + tokens.actualName +
							"' - property not found on bean class [" + getRootClass().getName() + "]");
				}
				return;
			}
			else {
				throw createNotWritablePropertyException(tokens.canonicalName);
			}
		}

		Object oldValue = null;
		try {
			//原生值
			Object originalValue = pv.getValue();
			Object valueToApply = originalValue;
			...省略...
			//这是重点,通过 PropertyHandler 把属性值设置给对象
			ph.setValue(valueToApply);
		}
		catch (TypeMismatchException ex) {
			throw ex;
		}

这里的属性值通过 PropertyHandler去设置

@Override
	public void setValue(@Nullable Object value) throws Exception {
		//得到属性的set方法
		Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
				((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
				this.pd.getWriteMethod());
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction) () -> {
				ReflectionUtils.makeAccessible(writeMethod);
				return null;
			});
			try {
				AccessController.doPrivileged((PrivilegedExceptionAction)
						() -> writeMethod.invoke(getWrappedInstance(), value), acc);
			}
			catch (PrivilegedActionException ex) {
				throw ex.getException();
			}
		}
		else {
			//设置访问权限
			ReflectionUtils.makeAccessible(writeMethod);
			//调用set方法把属性值设置进去
			writeMethod.invoke(getWrappedInstance(), value);
		}
	}

这里就是得到属性的set方法,然后调用set方法把值注入进去。

构造器注入参数

在之前分析Bean的创建的时候我们就说到,在 AbstractAutowireCapableBeanFactory#createBeanInstance 中会通过反射获取到Bean的构造器,如果是有参构造就会走autowireConstructor 方法,通过有参构造创建实例

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		Class> beanClass = resolveBeanClass(mbd, beanName);

		...省略...
		// 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);
	}

在autowireConstructor方法中会通过 ConstructorResolver 对构造器参数进行解析

protected BeanWrapper autowireConstructor(
			String beanName, RootBeanDefinition mbd, @Nullable Constructor>[] ctors, @Nullable Object[] explicitArgs) {
		//构造器解析器,注入
		return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
	}


public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
			@Nullable Constructor>[] chosenCtors, @Nullable final Object[] explicitArgs) {

		...省略...
			else {
				//得到构造器参数
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				//得到构造器参数值
				resolvedValues = new ConstructorArgumentValues();
				//解析参数值【重要】
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}
		...省略...
try {
			//实例化策略
			final InstantiationStrategy strategy = beanFactory.getInstantiationStrategy();
			Object beanInstance;

			if (System.getSecurityManager() != null) {
				final Constructor> ctorToUse = constructorToUse;
				final Object[] argumentsToUse = argsToUse;
				beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
						strategy.instantiate(mbd, beanName, beanFactory, ctorToUse, argumentsToUse),
						beanFactory.getAccessControlContext());
			}
			else {
				//实例化对象,根据有参构造器,使用反射创建实例
				beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
			}

			bw.setBeanInstance(beanInstance);
			return bw;
		}

resolveConstructorArguments 方法中又通过 BeanDefinitionValueResolver来解析属性值,有参数的值了,就会走反射,根据有参构造器创建实例返回。

private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
			ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {

		TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
		TypeConverter converter = (customConverter != null ? customConverter : bw);
		//属性值的解析器
		BeanDefinitionValueResolver valueResolver =
				new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);

		...省略...
		for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) {
			if (valueHolder.isConverted()) {
				resolvedValues.addGenericArgumentValue(valueHolder);
			}
			else {
			//为构造器参数值做解析,这里和之前分析的set注入的属性值解析就一样了
				Object resolvedValue =
						valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
				ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder(
						resolvedValue, valueHolder.getType(), valueHolder.getName());
				resolvedValueHolder.setSource(valueHolder);
				resolvedValues.addGenericArgumentValue(resolvedValueHolder);
			}
		}

		return minNrOfArgs;
	}

因为之前 resolveValueIfNecessary方法已经分析过了,这里就不多说了。

总结

到这里属性注入的流程就分析完了,总结都在这个图上

喜欢的话就给个好评吧,你的肯定是我坚持写作最大的动力,来吧兄弟们,给我一点动力

收藏 (0)
评论列表
正在载入评论列表...
我是有底线的