Spring源码学习--Bean对象变量初始化（三）

朱雀 2022-06-13 10:14 281阅读 0赞

在上一篇博客[ Spring源码学习--Bean对象初始化（二）][Spring_--Bean]中我们介绍了Bean对象的初始化过程，接下来我们介绍一下对初始化后的Bean的变量值初始化的操作流程。

对于Spring对属性值注入的方式，即使我们没有看Spring的实现方式可能也会猜到，对于通过set方法注入的变量值简单来说调用类的xx.xx.setXx(args ..)就完成了变量值的注入操作，对于通过注解@Autowired注入的对象，可以通过Java提供的反射机制通过获取Field对象来获取变量值，通过调用Field.set(Object obj, Object value)方法来完成变量的初始化工作，实际上Spring就是通过Java最基本的反射机制来完成变量值注入的（对于Java反射机制的了解参考[Java反射机制][Java]）。

首先在AbstractAutowireCapableBeanFactory的populateBean方法中首先会获取所有要注入的变量值设置，包括在xml中配置的property属性，通过@Autowired注释的变量以及提供了setXxx方法的变量值都会被收集为MutablePropertyValues对象

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    		//获取要设置的属性值
    		PropertyValues pvs = mbd.getPropertyValues();
    
    		if (bw == null) {
    			if (!pvs.isEmpty()) {
    				throw new BeanCreationException(
    						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
    			}
    			else {
    				return;
    			}
    		}
    		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;
    		}
    
    		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
    				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
    			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    
    			//通过名称来注入bean
    			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
    				autowireByName(beanName, mbd, bw, newPvs);
    			}
    
    			//通过类型来注入bean
    			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);
    			}
    		}
    		//对MutablePropertyValues注入属性
    		applyPropertyValues(beanName, mbd, bw, pvs);
    	}

applyPropertyValues方法中要开始尝试对属性值做注入处理，但是在注入处理之前做一些预处理操作，简单来说对参数值做了深拷贝处理（具体问什么这么做还不知），接下来是调用BeanWrapper.setPropertyValues方法做参数值注入处理。

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    		if (pvs == null || pvs.isEmpty()) {
    			return;
    		}
    
    		MutablePropertyValues mpvs = null;
    		List<PropertyValue> original;
    
    		if (System.getSecurityManager() != null) {
    			if (bw instanceof BeanWrapperImpl) {
    				((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
    			}
    		}
    
    		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 valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
    
    		// Create a deep copy, resolving any references for values.
    		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.
    		try {
    			//调用BeanWrapper的方法做参数值注入处理
    			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    		}
    		catch (BeansException ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    		}
    	}

在 BeanWrapper的setPropertyValues中会循环对每次属性值做注入处理操作

@Override
    	public void setPropertyValues(PropertyValues pvs) throws BeansException {
    		setPropertyValues(pvs, false, false);
    	}
    	
    @Override
    	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 {
    				//给属性注入操作
    				setPropertyValue(pv);
    			}
    			
    		}
    		
    	}

注入的操作分两种，一种是对有setXxx方法的注入则直接调用BeanPropertyHandler的setValue方法通过反射调用Method.invoke实现注入操作。

@Override
    		public void setValue(final Object object, Object valueToApply) throws Exception {
    			//通过使用setXxx方法进行注入
    			final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
    					((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
    					this.pd.getWriteMethod());
    			if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers()) && !writeMethod.isAccessible()) {
    				if (System.getSecurityManager() != null) {
    					AccessController.doPrivileged(new PrivilegedAction<Object>() {
    						@Override
    						public Object run() {
    							writeMethod.setAccessible(true);
    							return null;
    						}
    					});
    				}
    				else {
    					writeMethod.setAccessible(true);
    				}
    			}
    			final Object value = valueToApply;
    			if (System.getSecurityManager() != null) {
    				try {
    					AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
    						@Override
    						public Object run() throws Exception {
    							writeMethod.invoke(object, value);
    							return null;
    						}
    					}, acc);
    				}
    				catch (PrivilegedActionException ex) {
    					throw ex.getException();
    				}
    			}
    			else {
    				writeMethod.invoke(getWrappedInstance(), value);
    			}
    		}
    	}
    
    }

对于没有setXxx方法简单来说通过注解方法注释的属性则通过FieldPropertyHandler直接给属性赋值。

@Override
    		public void setValue(Object object, Object value) throws Exception {
    			try {
    				ReflectionUtils.makeAccessible(this.field);
    				//操作属性值进行注入
    				this.field.set(object, value);
    			}
    			catch (IllegalAccessException ex) {
    				throw new InvalidPropertyException(getWrappedClass(), this.field.getName(),
    						"Field is not accessible", ex);
    			}
    		}

总结：简单来说Spring对属性值的注入方法还是比较简单的，通过Java提供的反射机制，对于有setXxx方法的变量直接通过反射调用方法注入参数值；对于没有setXxx方法的变量则通过Field方法，直接对变量进行赋值操作。

[Spring_--Bean]: http://blog.csdn.net/qq924862077/article/details/73863579
[Java]: http://blog.csdn.net/qq924862077/article/details/74348488