Spring源码剖析-Bean的实例化-属性注入
Posted 墨家巨子@俏如来
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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<String> 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 List<A> as; 支持，根据类型走到所有的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 List<A> as; 集合注入的支持。
属性寻找好之后都会封装成 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<PropertyValue> 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<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
//类型转换，把属性转换为对应的类型
for (PropertyValue pv : original) {
if (pv.isConverted()) {
//属性值不需要转
deepCopy.add(pv);
}
else {
//属性名
String propertyName = pv.getName();
//原始属性值，它的类型是一个 如： RuntimeBeanReference<otherBean> 引用类型
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。比如：
<property name="otherBean" ref="otherBean" />这种属性值其实是个字符串“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) {
//比如：<property name="xx" ref="xxBean" 就是引用类型，会走这里
RuntimeBeanReference ref = (RuntimeBeanReference) value;
//对引用类型属性进行解析
return resolveReference(argName, ref);
}
///对属性值是引用容器中另一个 Bean 名称的解析
else if (value instanceof RuntimeBeanNameReference) {
String refName = ((RuntimeBeanNameReference) value).getBeanName();
refName = String.valueOf(doEvaluate(refName));
//判断容器中是否有这个Bean
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：包含带有名称和别名的 BeanDefinition
BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
//解析内部 Bean
return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
}
else if (value instanceof BeanDefinition) {
// Resolve plain BeanDefinition, without contained name: use dummy name.
//解析纯 BeanDefinition，不包含名称
BeanDefinition bd = (BeanDefinition) value;
String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
ObjectUtils.getIdentityHexString(bd);
return resolveInnerBean(argName, innerBeanName, bd);
}
//对数组类型解析
以上是关于Spring源码剖析-Bean的实例化-属性注入的主要内容，如果未能解决你的问题，请参考以下文章