概述
一、介绍
在spring可以通过配置的方式指定bean的属性值，这些属性值可以是容器中的其他bean，也可以是配置的一个常量。如下
<bean id="person" class="com.kaka.spring.pojo.Person" autowire="byName">
<!-- 普通常量属性 -->
<property name="age" value="22"/>
<!-- 属性值为容器中的另一个bean -->
<property name="department" ref="department"/>
</bean>
在加载这个Person的时候，spring第一步会先创建一个Person对象；第二步把Person对象依赖的所有属性值都解析到一个PropertyValues对象中，这个阶段专注于属性值的解析。最后，再把PropertyValues中的属性值设置到Person中。
二、bean加载流程
- 获取用户传入name对应的beanName
- 尝试从缓存中获取bean实例
- 缓存中不存在，加载bean实例
3.1. 检查循环依赖
3.2 处理parentBeanFactory
3.3 处理依赖的bean（dependsOn）
3.4 三种bean实例的创建
3.4.1 单例bean的创建
3.4.1.1 获取单例bean，getSingleton()方法
3.4.1.2 准备创建bean，createBean()方法
3.4.1.3 创建bean，doCreateBean()方法
3.4.1.3.1 创建BeanWrapper
3.4.1.3.2 记录bean的Object-Factory
3.4.1.3.3 属性填充（本章解析）
3.4.2 原型bean的创建
3.4.3 根据scope策略创建bean - 从bean实例中获取真正的对象
- 转换对象类型
- 返回对象实例
三、相关类及方法
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean：填充bean的整体流程
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByName：根据名称自动装配
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByType：根据类型自动装配
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#checkDependencies：检查依赖
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyPropertyValues：把已上解析的属性填充到bean中
四、源码分析
1. 填充bean属性的主流程
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 1. beanWrapper为null的情况
if (bw == null) {
// 这个时候有属性需要填充，则抛异常
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;
}
}
// 2. 给InstantiationAwareBeanPostProcessors最后一次机会在属性设置前来改变bean
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// postProcessAfterInstantiation的返回值来控制是否继续填充bean
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
// 3. 自动注入类型(不推荐设置，默认为no)
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 3.1 根据名称自动注入(重点方法)
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 3.2 根据类型自动注入(重点方法)
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 4. 属性后处理和依赖检查
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
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) {
// 依赖检查，对应bean标签中的dependency-check属性(这个是spring2.5中的属性；3.0已废弃)
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
// 5. 把属性应用到bean中(重点方法)
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
以上代码在AbstractAutowireCapableBeanFactory类的populateBean方法，主要有以下五个步骤：
-
BeanWrapper判断是否为空
-
调用InstantiationAwareBeanPostProcessors的postProcessAfterInstantiation方法，来改变bean内容，并根据返回值控制是否继续填充属性。
-
根据自动注入类型，提取依赖的bean，存入到newPvs
自动注入类型，表示该bean中的所有的属性全部以某种注入方式自动填充，不推荐设置！
我们需要注入bean中哪个属性，直接在对应的属性上加@Autowire或者@Resource就行了。自动注入类型，支持以下四种：
no：不自动装配(默认值)
byName：根据属性名来自动装配。查找与属性名一致的bean，并将它与属性自动装配
byType：根据指定属性的类型查找相同类型的bean装配。注：如果有多个bean匹配会抛异常
constructor：与byType类似，只是用于构造器参数。如果没有在构造器参数中找到类型一致的bean就会抛异常。
<bean id="department" class="com.kaka.spring.pojo.Department">
<property name="id" value="1"/>
<property name="name" value="技术部"/>
</bean>
<!-- 使用byName就不用设置department属性指向的bean了 -->
<bean id="person" class="com.kaka.spring.pojo.Person" autowire="byName">
<property name="age" value="22"/>
<!-- <property name="department" ref="department"/>-->
</bean>
- 属性后处理和依赖检查
调用InstantiationAwareBeanPostProcessors的postProcessPropertyValues方法，来处理bean的属性。
依赖检查用于，检查bean中的所有属性是否已被赋值。 - 把属性应用到bean中
2. 按名称提取依赖的bean
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 1. 寻找bw中需要依赖注入的属性
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
// 2. 递归初始化相关的bean
Object bean = getBean(propertyName);
pvs.add(propertyName, bean);
// 3. 注册依赖
registerDependentBean(propertyName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("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");
}
}
}
}
先在BeanWrapper中解析出依赖的属性名称，然后根据这些名称去容器中寻找对应依赖的bean，并放入到MutablePropertyValues属性表中。
3. 按类型提取依赖的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);
// 寻找bw中需要依赖注入的属性名称
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);
boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
// 解析指定beanName的属性所匹配的值，并把解析到的属性名存储在autowiredBeanNames中
// 核心方法！
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
for (String autowiredBeanName : autowiredBeanNames) {
// 注册依赖
registerDependentBean(autowiredBeanName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("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);
}
}
}
根据类型提取依赖的bean比较复杂，但大致流程是一样的。核心方法在AutowireCapableBeanFactory类的resolveDependency方法中，有兴趣的可以继续深挖~
4. 把属性应用到bean中
在这之前的工作，都是为了解析bean中各属性的注入值，并把解析后的结果保存到了PropertyValues中。这一步就是把这些属性值，设置到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 {
// 如果pvs并不是使用MutablePropertyValues封装的类型，那么直接使用原始的属性获取方法
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<>(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 {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
至此创建好的bean已经注入完成依赖的属性了，再后面就是调用这个bean的初始化方法了。
最后
以上就是小巧胡萝卜为你收集整理的spring源码：bean加载之创建bean-属性填充的全部内容，希望文章能够帮你解决spring源码：bean加载之创建bean-属性填充所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复