1.populateBean方法
/**
* Populate the bean instance in the given BeanWrapper with the property values
* from the bean definition.
*
* 使用bean定义中的属性值来操作给定BeanWrapper中的bean实例
* @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, BeanWrapper bw) {
//获取支持Map的propertyValue,从xml中解析到property value配置
PropertyValues pvs = mbd.getPropertyValues();
//bean实例为null
if (bw == null) {
//属性不为空,但是没有创建bean直接抛出异常
if (!pvs.isEmpty()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
//跳过属性填充步骤
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.
//为任何InstantiationAwareBeanPostProcessors提供在设置属性之前修改bean状态的机会
//可以用来支持属性注入的类型
boolean continueWithPropertyPopulation = true;
//
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//TODO 是否执行post-processor,如果返回false代表需要对bean进行属性装配,反之退出bean装配
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
//如果不填充bean则终止bean的填充
if (!continueWithPropertyPopulation) {
return;
}
//
//
//下面的逻辑会把构造器中需要依赖注入的bean或者需要@Autowired注解或者xml配置autowire为byName或者byType
// 修饰的bean放到propertyValue中,如果bean依赖的bean还未创建
//则会在autowireByName或者autowireByType中创建
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 根据名称自动注入逻辑,如果某些依赖的bean没有创建则在这里会被初始化
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 根据类型自动注入.如果某些依赖的bean没有创建,则在这里会被初始化
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
//是否有InstantiationAwareBeanPostProcessor处理器
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
//是否需要依赖检查
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
//如果有InstantiationAwareBeanPostProcessor处理器或者需要依赖检查
if (hasInstAwareBpps || needsDepCheck) {
//需要进行依赖检查的propertyrDescriptor
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//TODO 扩展点 所有需要进行依赖检查的属性进行后处理
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
//depends-on属性检查
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
//属性应用到bean
applyPropertyValues(beanName, mbd, bw, pvs);
}
2.我们可以通过InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法来跳过属性赋值
3.autoByName和autoByType在执行过程中会创建依赖的bean
4.我们还可以对有InstantiationAwareBeanPostProcessor处理器的工厂或者需要依赖检查的bean进行属性的后置处理
5.应用属性到bean中大致有以下几个步骤
a.判断是否为MutablePropertyValues是的话,判断需不需要converted不需要直接转换
b.获取所有porpertyValues
c.获取coverter
d.处理propertyValue属性,解析map、list、array、runtimeBeanReference
e.判断propertyValue需不需要转换,需要的话会进行covertProperty,
f.保存propertyValue的到deepCopy,用于给bean赋值
g.赋值操作
/**
* 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.
*
* 应用给定的属性值,解析任何运行时引用
* 到这个bean工厂的其他bean。 必须使用深层复制,
* 所以我们永远不要修改属性
* @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) {
//pvs不存在不需要注入了
if (pvs == null || pvs.isEmpty()) {
return;
}
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
//如果是MutablePropertyValues,
//当bean的属性有通过autowireByName或者autowireByType时
//pvs就是MutablePropertyValues
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
//判断是否转换过了,转换过了直接setPropertyValues
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);
}
}
//获取propertyValues集合
original = mpvs.getPropertyValueList();
}
else {
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.
//将值引用保存到deepCopy 中
List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
boolean resolveNecessary = false;
//循环处理
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
//属性名称
String propertyName = pv.getName();
//值
Object originalValue = pv.getValue();
//解析value,比如value可能为map、list、runtimeBean类型
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
//property是否可写-->其实就是判断属性是否存在
//判断参数是否为index 或者嵌套比如属性为["name1","name2"];
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
//进行value转换操作
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.
//可以在合并的bean定义中存储转换后的值,以避免每个创建的bean实例重新转换。
if (resolvedValue == originalValue) {
if (convertible) {
//设置pv的转换后的值
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
//能转换并且原始值类型为TypedStringValue并且originalValue不是动态的
//并且转换的后的属性不是Collection的子类或者数组
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
//其他情况判定,还有必要进行resolve
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
//如果mpvs不为null并且需要不转换
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);
}
}
6.对于convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);方法,有必要了解下PropertyEditor到底怎么用的