Spring源码剖析-Bean的实例化-属性注入

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 List 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 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。比如：<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);

}

//对数组类型解析

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

}

//对集合类型解析

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 = 0; i < ml.size(); i++) {

Array.set(resolved, i, resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));

}

return resolved;

}

/**

• For each element in the managed list, resolve reference if necessary.

*/

//解析List

private List<?> resolveManagedList(Object argName, List<?> ml) {

List resolved = new ArrayList<>(ml.size());

for (int i = 0; i < ml.size(); i++) {

resolved.add(resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));

}

return resolved;

}

/**

• For each element in the managed set, resolve reference if necessary.

*/

//解析set

private Set<?> resolveManagedSet(Object argName, Set<?> ms) {

Set resolved = new LinkedHashSet<>(ms.size());

int i = 0;

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<Object, Object> resolved = new LinkedHashMap<>(mm.size());

mm.forEach((key, value) -> {

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）

总结

虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。

架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。

如果你也想成为一名好的架构师，那或许这份Java成长笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。

dHashMap<>(mm.size());

mm.forEach((key, value) -> {

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-VW8hFjuZ-1710742214320)]
[外链图片转存中…(img-Aqd0l97r-1710742214320)]
[外链图片转存中…(img-dWBC2S58-1710742214321)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-4BZFc2D2-1710742214321)]

总结

虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。

架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。

如果你也想成为一名好的架构师，那或许这份Java成长笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。

[外链图片转存中…(img-TKim7JMT-1710742214321)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录