阅读之前要注意的东西：本文就是主打流水账式的源码阅读，主导的是一个参考，主要内容需要看官自己去源码中验证。全系列文章基于 spring 源码 5.x 版本。
写在开始前的话：
阅读spring 源码实在是一件庞大的工作，不说全部内容，单就最基本核心部分包含的东西就需要很长时间去消化了：
实际上我在博客里贴出来的还只是一部分内容，更多的内容，我放在了个人，fork自 spring 官方源码仓了； 而且对源码的学习，必须是要跟着实际代码层层递进的，不然只是干巴巴的文字味同嚼蜡。
这个仓设置的公共仓，可以直接拉取。
在getBean 的调用链路中，如果是从零开始创建一个bean, 按照潦草的说法大致如下：
1.根据 beanName 从 beanFactory 读取 BeanDefinition
2.对BeanDefinition 进行简单的加工、转化 -> RootBeanDefinition
2.根据bean元数据(BeanDefinition) 中记录的信息，递归的去加载该bean 依赖的其它bean
3.根据bean 的作用域: [prototype、singleton...等等] 决定具体的创建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 作缓存操作。
/**
* 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 中
}
}
这里重点说两个操作：
autowireByName(beanName, mbd, bw, newPvs);
autowireByType(beanName, mbd, bw, newPvs);
applyPropertyValues(beanName, mbd, bw, pvs);
/**
* 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");
}
}
}
}
上文的内容很简单:
/**
* 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);
}
/**
* 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 注入, 这里的操作复杂得多
如果想要深究 resolveDependency() 方法，可以下载我个人fork 的spring源码仓; 我在源码里也加了详细注释。
书接上回 现在我们看第二个重点操作：
/**
* 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);
}
}
重要信息都放在注释里了。