概要
过度
我们上文介绍了创建 Bean 实例并进行依赖注入、初始化的整体逻辑，我们介绍的是doCreateBean方法。还画了一个流程图，如下图所示：
1.png
其中，创建实例的操作我们在3-3中已经详细介绍完成了。现在我们拿到了 Bean 的一个实例引用，接下来有两条思路：
- 看如果是单例的话就提前暴露出去方便解决循环依赖，在最后完成创建后看是否成功解决了循环依赖
- 继续进行 Bean 的创建，包括依赖注入和调用初始化函数
其中，第一条路我们放在最后，在收束整个创建 Bean 实例流程时进行讲解。本节从第二条路入手，继续讲解 Bean 实例创建的整个流程。
本节主要介绍 Bean 实例创建中的依赖注入。
内容简介
本节主要介绍 Bean 实例创建中的依赖注入。
当然，这里的依赖注入特指创建了一个实例后根据getter/setter往里面填值的过程，不包括通过构造函数或者工厂方法塞进去的值（那个在创建实例时就塞进去了）。
所属环节
依赖注入。
上下环节
上文： 或者从factoryBeanInstanceCache中拿到了创建出的基础实例，或者通过定位到合适的构造方法构造出了一个基础实例。
下文： 填值完成，调用初始化的钩子。
源码解析
入口
Object exposedObject = bean;
try {
// 填充一些 bean 的属性
populateBean(beanName, mbd, instanceWrapper);
// 初始化 bean
// 这里才叫初始化，初始化特指调用初始化和那些钩子方法，其他的包括填充属性，都叫创建实例
exposedObject = initializeBean(beanName, exposedObject, mbd);
} catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
} else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
这个是 doCreateBean中的一段代码，大概就是在获得实例后依次调用一个依赖注入函数和一个初始化函数。
初始化函数可能对 Bean 实例作封装、代理之类的，可能返回的是一个截然不同的实例地址。当然这个我们后面再说。
依赖注入
先上代码：
/**
* 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
*/
// 将 bd 中的 property 填充到 bw 中去
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
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;
}
}
// 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.
// 让 InstantiationAwareBeanPostProcessor 来在填充之前对属性进行最后的修改，这个可以用来支持属性注入（@Value）
boolean continueWithPropertyPopulation = true;
// mbd 不是合成的 ，而且有 InstantiationAwareBeanPostProcessor 来修饰属性，那就搞起
// TODO 这个需要参考后处理器那些东西，专门统一的梳理一下那些后处理器
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) { // 不用再继续填充属性了
return;
}
// 获得 mbd 配置的那些要注入的属性的 key-value
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 根据对应的注入方法进行注入
// TODO 注意了，这个注入并不是我们熟悉的，想象中的那种注入
// 这里的注入主要是针对我们没配置的那些属性，作一些在此实例层面统一标准的注入。【极少使用】
//
// 我们在创建 BD 时写的属性，比如你在每个属性上打的@Resource/@Autowire标记；
// 或者用 xml，在 Bean 标签下面的 property 标签。这些东西都是在最后面 applyPropertyValues 实现注入的
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
// 根据名称注入
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
// 根据类型注入
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 根据情况看需不需要对即将填充进实例的属性进行处理
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); //有注册的钩子可以用
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);// 设置了需要依赖检测
// TODO： 这个条件实在是误导人
// 其实简化逻辑后就可以发现这两个条件仅用来执行 if (pvs == null)，这个也是怕后处理器或者依赖校验取到 null
// 实际上逻辑很简单：
// 1. 如果有可以对属性用的后处理器，调用一遍
// 2. 如果 mbd 中配置了要进行依赖检测，就检测一下
if (hasInstAwareBpps || needsDepCheck) {
if (pvs == null) { // 考虑到在进行依赖注入后拿到的结果可能是空？？注入失败？
pvs = mbd.getPropertyValues();
}
// 这个就不深入了，里面的东西还挺多的，根据上下文猜一下：
// 这个应该是根据 Bean 对应的 Class ，直接获得这个里面所有的属性
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) { // 处理结果是 null ，没得填充了
return;
}
}
}
}
// 这个是做一下依赖检测，主要看一下有没有该设置的属性结果给空着的
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
// 默认属性写入，配置属性注入
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
思路整体还是比较简单的，展示如下：
2.png
整体思路明确了，我们安排如下：
- 后处理器相关的东西，我们后面统一再介绍
接下来，我们依次介绍：
- 根据
mbd指定的默认依赖注入模式，将mbd中未配置的复杂引用属性进行填充【如果在mbd未配置自动注入则不填充】【绝大部分场景都不用】 - 检测我们最后归纳总结出的的
key-value有没有遗漏的属性并报错 - 将最后得到的属性填充至实例中
获得默认的依赖注入模式并注入未配置的属性
入口
// 获得 mbd 配置的那些要注入的属性的 key-value
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 根据对应的注入方法进行注入
// TODO 注意了，这个注入并不是我们熟悉的，想象中的那种注入
// 这里的注入主要是针对我们没配置的那些属性，作一些在此实例层面统一标准的注入。【极少使用】
//
// 我们在创建 BD 时写的属性，比如你在每个属性上打的@Resource/@Autowire标记；
// 或者用 xml，在 Bean 标签下面的 property 标签。这些东西都是在最后面 applyPropertyValues 实现注入的
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
// 根据名称注入
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
// 根据类型注入
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
代码逻辑很清晰：
- 先从配置的
mbd中读出指定的key-value的配置，【因为我们最后要凑一份全的给填充函数，所以就把配置的先放进去了】 - 根据确定的匹配模式将未配置的属性填充进去
根据名称注入
// 根据名称注入，这个貌似不会报错，因为一个名称【不管是 id 还是 alias 】只能定位到一个 bean 实例，
// 如果有冲突，在生成 BeanDefinition 时就报错了。
//
// 这里找不到就是没有了，就不加进去，如果设置了这个必传，最后会有统一检测并报错的
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 之前也介绍过，我们这里两种模式，根据名称、类型找实例都是为了将未配置的复杂引用注入成对实际实例的引用
// 对于那种没配置简单的属性我们也无能为力，只能按照java对基本类型对默认值来喽～～～所以只负责复杂的
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) { // 属性名称就是用来查询的 bean 的 id 或者 alias
Object bean = getBean(propertyName);
pvs.add(propertyName, bean);
// 你引用了 propertyName 对应的实例，也就依赖了它。注册一下依赖关系
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");
}
}
}
}
这个函数极其简单，原因也很明显：
- 基本
BeanFactory都提供了完善的，根据 Id/Alias 获得实例的操作。 - 能获得就能获得唯一的，这个
BeanFactory在注册时就给你滤掉重复的了 - 如果获得不了，就直接返回即可，最后有依赖检测，会兜底
所以会发现这个函数就是莽就行了。。。。。
获得未满足的复杂属性
// 返回实例参数名称列表，返回的列表满足以下条件：
// 1. 有 setter 方法
// 2. 需要进行依赖检查【属性的类型不是那种不需要检查的】
// 3. 在 mbd 中没有对这个参数进行安排
// 4. 不是简单的属性
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
Set<String> result = new TreeSet<>();
PropertyValues pvs = mbd.getPropertyValues();
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
for (PropertyDescriptor pd : pds) {
// TODO 注意此处，这里返回的是未在 properties 中配置的那部分属性中的引用属性 （unsatisfied）
if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
result.add(pd.getName());
}
}
return StringUtils.toStringArray(result);
}
注释够用了。。。
根据类型注入
// 通过类型注入
//
// 此种注入方式要求必须能根据类型唯一地确定 bean。这种注入方式在项目比较简单时能很方便的搞定；当项目比较大时，这种方式就显得有点力不从心了，
// 比如我的项目要连接两个数据库，就要创建两个 SqlSessionFactory
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()) {
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
// TODO 这里后面再看，有点深了
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);
}
}
}
有点牛逼没看懂。。。。。。
大概意思是根据属性的类型或者根据对应setter方法入参的类型找到对应的 Bean 实例，如果能唯一确定或者没有符合条件的还好，如果同时有多个满足条件就报错。
检测是否有漏配置的属性
我们上面拿到了mbd配置的属性，根据配置的默认填充方法将未配置的属性中可以确定的确定了。现在看看我们漏掉的属性是不是值得报错：
入口
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
具体逻辑
// 思路很简单：我们上面 filteredPds 拿到了所有的属性，也就是这里的 pds ，我们和处理后得到的属性集 pvs 一一比对
// 找出可设置但是没设置的属性，看看它是不是在我们的检查范围内，如果在就报错，如果不在就忽略。
protected void checkDependencies(
String beanName, AbstractBeanDefinition mbd, PropertyDescriptor[] pds, PropertyValues pvs)
throws UnsatisfiedDependencyException {
int dependencyCheck = mbd.getDependencyCheck(); // 获得我们配置的检测范围：所有/仅简单属性/仅复杂属性【对象引用】
for (PropertyDescriptor pd : pds) {
if (pd.getWriteMethod() != null && !pvs.contains(pd.getName())) {
// 这个属性有，切可以设置，但是在处理后获得的要注入的属性中没有
boolean isSimple = BeanUtils.isSimpleProperty(pd.getPropertyType()); // 获得属性所属范围
// 看看所属范围是不是在我们要检查的范围里，在就报错。
boolean unsatisfied = (dependencyCheck == AbstractBeanDefinition.DEPENDENCY_CHECK_ALL) ||
(isSimple && dependencyCheck == AbstractBeanDefinition.DEPENDENCY_CHECK_SIMPLE) ||
(!isSimple && dependencyCheck == AbstractBeanDefinition.DEPENDENCY_CHECK_OBJECTS);
if (unsatisfied) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, pd.getName(),
"Set this property value or disable dependency checking for this bean.");
}
}
}
}
属性注入【含配置复杂属性的确定化】
// 把这些属性处理一下，然后灌到 bw 中
// 为了安全，用到深拷贝
// TODO： 还是有一些问题的，这个后面可以细看
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;
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 { // 入参的参数列表仅仅是从 mbd 中读出来，调用了后处理钩子的那些配置了的属性值
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();
// 根据 PropertyValue 拿到对应的 value ，这里将那些
// 配置在 properties ref标签或者@Resource,@Autowire
// 标记的属性根据规则拿到的具体的实例值
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.
// TODO： 这里为什么要用一个新数组完成对 bean 中的设置，是怕传进来的数组还在别的地方用到，容易被修改吗？
// TODO： 那也不对，看 setPropertyValues（） ，好像是将数组拆开扔进去的。
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
因为把主要注意力都放在依赖注入里面了，所以忽略了很多次要的东西。我们主要关注valueResolver.resolveValueIfNecessary，在这里对参数做了解析：
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) {// 标签中的 ref
RuntimeBeanReference ref = (RuntimeBeanReference) value;
return resolveReference(argName, ref);
} else if (value instanceof RuntimeBeanNameReference) {
String refName = ((RuntimeBeanNameReference) value).getBeanName();
refName = String.valueOf(doEvaluate(refName));
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 bdHolder = (BeanDefinitionHolder) value;
return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
} else if (value instanceof BeanDefinition) {
// Resolve plain BeanDefinition, without contained name: use dummy name.
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);
} else if (value instanceof ManagedSet) {
// May need to resolve contained runtime references.
return resolveManagedSet(argName, (Set<?>) value);
} else if (value instanceof ManagedMap) {
// May need to resolve contained runtime references.
return resolveManagedMap(argName, (Map<?, ?>) value);
} 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) { // 标签中的 value
// 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 {
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);
}
}
代码一大堆，只关注其中的两个分支即可，分别和我们常用的 properties 中的 value,ref对应。
剩下的就是一些用xml配置出的什么Map/List/Set之类的东西。
扩展
依赖注入的地方
两处！！！！！
你配置的属性在applyPropertyValues中注入。
你没配置的属性如果配置了默认属性则在populateBean分析并调用函数注入。
网友评论