《系列二》-- 9、bean属性填充
阅读之前要注意的东西:本文就是主打流水账式的源码阅读,主导的是一个参考,主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。
写在开始前的话:
阅读spring 源码实在是一件庞大的工作,不说全部内容,单就最基本核心部分包含的东西就需要很长时间去消化了:
- beans
- core
- context
实际上我在博客里贴出来的还只是一部分内容,更多的内容,我放在了个人,fork自 spring 官方源码仓了; 而且对源码的学习,必须是要跟着实际代码层层递进的,不然只是干巴巴的文字味同嚼蜡。
这个仓设置的公共仓,可以直接拉取。
一、概述: populateBean 在什么时候执行?
在getBean 的调用链路中,如果是从零开始创建一个bean, 按照潦草的说法大致如下:
-
1.根据 beanName 从 beanFactory 读取 BeanDefinition
-
2.对BeanDefinition 进行简单的加工、转化 -> RootBeanDefinition
-
2.根据bean元数据(BeanDefinition) 中记录的信息,递归的去加载该bean 依赖的其它bean
-
3.根据bean 的作用域: [prototype、singleton...等等] 决定具体的创建bean的行为。
- singleton 需要应用三级缓存,保证全局唯一
- prototype 每次直接创建全新bean
-
4.bean的实例化: (所谓实例化,可以理解为,从java 堆上创建了一个'全新'的对象。)
根据 BeanDefinition 获取: bean的类型、参数、自定义构造函数、 注入方式(直接注入: 无参构造函数,间接注入: FactoryBean、factory-bean + factory-method)。最终根据上述的信息的配置情况,实例化一个bean。
-
5.上一步也提到,它只完成了实例化,但是如果有属性需要填充呢? 参考如下的例子:
<beans>
<bean id="myBean" class="demo.self.MySimpleBean">
<!-- property 是常量 -->
<property name="name" value="Bokerr"/>
<property name="age" value="27"/>
</bean>
<bean id="myBean" class="demo.self.MyBean">
<!-- property 是一个bean -->
<property name="bean1"><ref bean="populate1"/></property>
</bean>
<bean id="populate1" class="demo.self.populateBean"/>
</beans>
为什么说填充的就是 property 属性呢? 【详见后文,populateBean方法的第一个判断。】
bean 创建实例化之后,还处于一个 '空白' 状态,所以需要经过填充操作,将配置的 property 属性的值注入。
这就引入了本文需要讲述的操作:populateBean
这里有个很重要、很重要、很重要的起手式:
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
你需要记住: PropertyValues(它是 bean的全部 property 解析后得到的元数据信息)
它是来自于 mbd 的。(也就是 BeanDefinition),它的对象声明周期受到 BeanFactory 管理;
下文中任意对 PropertyValues 及其属性的 set 操作,都可等效认为,实在对 BeanDefinition 作缓存操作。
二、populateBean 的重要操作
/**
* Populate the bean instance in the given BeanWrapper with the property values
* from the bean definition.
*
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param bw the BeanWrapper with bean instance
*/
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
// bean 有属性需要被填充,但是对象包装器 bw 为空
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
} else {
// 包装器为空,且不需要 填充任何属性
// Skip property population phase for null instance.
return;
}
}
// 给 InstantiationAwareBeanPostProcessors 最后一次机会,通过属性注入改变 bean.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 所有 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()的返回值将决定
// [是/否] 继续进行property属性填充
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
// 所有需要注入的属性, 对应的bean缓存 【这里明确从 BeanDefinition 上获取的 property 的定义】
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
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) {
// {重要操作1-根据Bean名称注入} [下文将展开详说]
autowireByName(beanName, mbd, bw, newPvs); // 提取依赖的bean 保存到 pvs
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
// {重要操作1-根据Bean类型注入 <Class>} [下文将展开详说]
autowireByType(beanName, mbd, bw, newPvs); // 提取依赖的bean 缓存到 pvs
}
pvs = newPvs;
}
// beanFactory 是否已经注册了: bean 实例化相关的 "后置处理器"
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 是否需要依赖检查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.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) {// 依赖检查, depend-on 属性,spring-3.0弃用
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
if (pvs != null) {
// 属性填充 {重要操作2} [下文将展开详说]
applyPropertyValues(beanName, mbd, bw, pvs); // 将 propertyValue 应用/注入 到 bean 中
}
}
这里重点说两个操作:
- 1.属性值的注入, 将propertyName视作beanName, 并尝试从spring容器中获取该bean, 如果成功获取则通过 PropertyValues:pvs 保存
autowireByName(beanName, mbd, bw, newPvs);
autowireByType(beanName, mbd, bw, newPvs);
- 2.属性值的应用, 上述操作的后续只要存在 property 属性配置就进行 property 值的'应用'操作。
applyPropertyValues(beanName, mbd, bw, pvs);
三、重点操作一 propertyValue 的注入
3.1 根据 Bean名称注入
/**
* Fill in any missing property values with references to
* other beans in this factory if autowire is set to "byName".
*
* @param beanName the name of the bean we're wiring up.
* Useful for debugging messages; not used functionally.
* @param mbd bean definition to update through autowiring
* @param bw the BeanWrapper from which we can obtain information about the bean
* @param pvs the PropertyValues to register wired objects with
*/
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 从 BeanDefinition 读取,非-常量注入的属性,这里返回的都是 property 指向别的 bean的场景
// 这里会忽略: 基本类型、字符串常量等等 property
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
// 递归加载依赖的bean
Object bean = getBean(propertyName);
pvs.add(propertyName, bean);
// 在容器中记录 bean 及其依赖的 bean之间的关系, 不妨进去瞅瞅
registerDependentBean(propertyName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
} else {
// 根据beanName 未定位到bean, 记录到日志。[说明该 property 所依赖的可能并不是一个 bean,可能只是一个普通的常量。]
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
上文的内容很简单:
- 获取所有的property中的非 【基本类型、常量】形式的 property
- 然后遍历并逐个解析
- 应用 containsBean 方法,判断该 propertyName 是否是一个beanName,如果不是则说明property 可能是常量。
- registerDependentBean(propertyName, beanName); 见名知意,就是记录当前加载的bean,依赖 propertyName 指向的bean。
3.2 浅看一下,获取非'简单' 类型 property 的方法
/**
* Return an array of non-simple bean properties that are unsatisfied.
* These are probably unsatisfied references to other beans in the
* factory. Does not include simple properties like primitives or Strings.
*
* @param mbd the merged bean definition the bean was created with
* @param bw the BeanWrapper the bean was created with
* @return an array of bean property names
* @see org.springframework.beans.BeanUtils#isSimpleProperty
*/
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
Set<String> result = new TreeSet<>();
PropertyValues pvs = mbd.getPropertyValues();
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
for (PropertyDescriptor pd : pds) {
// 有 setter方法
// && 没有别识别过的依赖
// && 已经解析过的property字段中不包含该字段
// && property的类型不是简单类型(Date、Number、CharSequence、Enum等等)
if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
result.add(pd.getName());
}
}
return StringUtils.toStringArray(result);
}
3.3 根据 Bean类型注入
/**
* Abstract method defining "autowire by type" (bean properties by type) behavior.
* <p>This is like PicoContainer default, in which there must be exactly one bean
* of the property type in the bean factory. This makes bean factories simple to
* configure for small namespaces, but doesn't work as well as standard Spring
* behavior for bigger applications.
*
* @param beanName the name of the bean to autowire by type
* @param mbd the merged bean definition to update through autowiring
* @param bw the BeanWrapper from which we can obtain information about the bean
* @param pvs the PropertyValues to register wired objects with
*/
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); // 缓存依赖关系映射
// 从 BeanDefinition 读取,非-常量注入的属性,这里返回的都是 property 指向别的 bean的场景
// 这里会忽略: 基本类型、字符串常量等等 property
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
try {
// 我们这是根据 bean Type 注入,所以这里浅浅的获取了一下, bean的类对象反射信息
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()) {
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); // 探测属性指定的set 方法
// 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);
// 解析指定 beanName 的属性所匹配的值,
// 并把解析到的属性名称存储在 autowiredBeanNames 中
// 当存在多个属性被封装到一起时:
// @Autowired List<A> aList; 会把 所有 A 类型的bean 都注入其中 autowiredBeans (复数个)
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter); // 寻找类型匹配的 bean
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);
}
}
}
这里是根据 property 的类型来注入的,比起根据 propertyName 注入, 这里的操作复杂得多
- 获取所有的property中的非 【基本类型、常量】形式的 property
- 依次遍历
- 结合 BeanDefinition 中的 property 定义,以及包装器BeanWrapper 中的记录信息, 得到 property的类型
- 根据 bean类型描述进入方法: resolveDependency() 及其后文其实内容是相当丰富的,这里就不再展开了;
该方式看似没有返回值,实际上你看下 desc 的构造,你就能发现有什么东西偷偷摸摸的进去了。
如果想要深究 resolveDependency() 方法,可以下载我个人fork 的spring源码仓; 我在源码里也加了详细注释。
四、注入依赖的应用
书接上回 现在我们看第二个重点操作:
- populateBean().applyPropertyValues()
/**
* Apply the given property values, resolving any runtime references
* to other beans in this bean factory. Must use deep copy, so we
* don't permanently modify this property.
*
* @param beanName the bean name passed for better exception information
* @param mbd the merged bean definition
* @param bw the BeanWrapper wrapping the target object
* @param pvs the new property values
*/
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) {
// 实际上,如果执行过: autowireByType 和 autowireByName 后注入的 <property, propertyValue>
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// 根据 name / type 解析到的 bean 已经被 转化为 具体类型 那么直接进行注入操作
// Shortcut: use the pre-converted values as-is.
try {
// 将解析完成的 <property,propertyValue> 逐个应用到包装器: BeanWrapper
bw.setPropertyValues(mpvs);
return;
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
} else {
// 同样 applyPropertyValues 也可能在别的场景中被调用:
// 该场景中,PropertyValues 尚未进行任意的 property 的注入操作
// 所以进入当前分支,继续往下分析。
original = Arrays.asList(pvs.getPropertyValues());
}
// 获取自定义-转换器 其实这个应该并不陌生,在 populateBean().autowireByType() 方法中见过
// 其实到这里,可以简单做个推论了: 接下来的篇幅中,所作的事情,可能会跟 property 的注入操作类似
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw; // 默认使用 bean 包装器
}
// Spring表达式语言(SpEL) 解析器 #{bean.xxx} ${xx.key}
// 可由 ApplicationContext 注入
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) {
// 遍历 property 属性,将需要转换的属性,转换为对应的类型
if (pv.isConverted()) {
// 已经转化过,直接添加 [BeanDefinition 缓存应用 或者 前边的环节已经处理过]
deepCopy.add(pv);
} else {
// 先转换 后添加
String propertyName = pv.getName();
// 原始值
Object originalValue = pv.getValue();
// 包含SpEL表达式的解析
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
// property 是否可覆盖?
// 根据包装器 bw 判断 property 字段可写 && 并且 property 不是(索引/嵌套类型的属性)。
// 自引入概念:property 应该是一个 "原子属性"
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
// 可以写入,且是一个"原子属性", 那么就可以进行转化了
// 这里不太适合再钻进去了,除非spring源码出bug了,否则如下的逻辑是不太有可能接触到的,
// 可以简单做个盖棺定论: 这里会把 resolvedValue 转化为 property 字段所期望的值类型:
// String: 2023-07-10 -> Date: 2023-07-10 00:00:00.000
// String: false -> Boolean: false
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) {
// PropertyValue 是元数据 BeanDefinition 的一环,这里等价为缓存
// 避免重复的转换操作
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
} else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
// 转化后的值不等于原始值
// && 支持转换
// && 原始值是String
// && 原始值不是动态的(常量)
// && 转换后的值,不是集合、不是数组
pv.setConvertedValue(convertedValue); // BeanDefinition 设置缓存
deepCopy.add(pv);
} else {
// 上述情形之外的情况, 可以看到,区别是,这里没有被当作缓存设回 BeanDefinition 中
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
// mpvs 同样是 BeanDefinition 所包含的信息,这里也可视作缓存设置
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
// 将解析完成的 <property,propertyValue> 逐个应用到包装器: BeanWrapper
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
重要信息都放在注释里了。