003-依赖注入、属性赋值源码分析

引入

之前我们了解到BeanDefinition到Bean，经历了

1. 实例化
2. 属性赋值
3. 初始化
   3个步骤现在详细分析下属性赋值：populateBean(beanName, mbd, instanceWrapper);

作用

就是查找Bean内字段或者方法上是否有@Autowired
如果有则从 context中查找并赋值，完成依赖注入

代码分析

其实就是解析各种依赖存入 getPropertyValues 缓存（相当于一个Map）
最后在统一反射到属性中

beanName – the name of the bean 
mbd – the bean definition for the bean 
bw – the BeanWrapper with bean instance
populateBean(beanName, mbd, instanceWrapper);

ropertyValues pvs = mbd.getPropertyValues();

//可以这样设置@Bean(autowire = Autowire.BY_NAME)
//这里只是解析 但是并没有真的设置 设值在最后一行
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || AUTOWIRE_BY_TYPE) {
	创建一个缓存 newPvs
	//意思是Bean的属性注入自动根据其Setter的名字或者属性
	if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
		newPvs.put(属性的名字(propertyName), getBean(propertyName));
	}
	//也可以 Autowire.BY_TYPE 就是根据Setter 参数的类型
	if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
		newPvs.put(属性的名字(propertyName), getBean(属性Setter的参数的类型));
	}
	pvs = newPvs;
}
//注意：这个方式已经被标记为过时的 因为这样调试起来很麻烦 而且不是很方便推荐还是@Autowired

遍历处理器 InstantiationAwareBeanPostProcessor bp {
	pvs = bp.postProcessProperties();
}

//根据pvs给对象设值
if (pvs != null) {
	//这里最终也是通过反射把值设置到字段中BeanWrapperImpl.BeanPropertyHandler#setValue
	applyPropertyValues(beanName, mbd, bw, pvs);
}

InstantiationAwareBeanPostProcessor#postProcessProperties()

这个处理器就是用来专门处理Bean的属性的

AutowiredAnnotationBeanPostProcessor

这个处理器实现就是专门处理@Autowired之类的逻辑
初始化的时候autowiredAnnotationTypes设置了

1. Autowired.class
2. Value.class
3. javax.inject.Inject

postProcessProperties():

//查找注入点元数据
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
//给注入点注入属性
metadata.inject(bean, beanName, pvs);

查找注入点元数据

findAutowiringMetadata():

//这里metadata 其实已经有值了
//在 MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition
//其实就进入了AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition
//在buildAutowiringMetadata()就把带注解的字段和方法解析完了
//并设置到injectedElements字段中
//最后 this.injectionMetadataCache.put(cacheKey, new InjectionMetadata(clazz, injectedElements)));
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (metadata == null) {
	metadata = buildAutowiringMetadata(clazz);
	this.injectionMetadataCache.put(beanName, );
}

//这里就是构建元数据
//构建元数据的前提是有需要注入的点 如果有则创建一个AutowiredFieldElement加入currElements
buildAutowiringMetadata(clazz):

遍历所有的字段（field） {
	if(带有4个注解之一) {
		currElements.add(new AutowiredFieldElement(field, required));
	}
}

遍历所有方法（method）{
	if(带有4个注解之一) {
		PropertyDescriptor pd = 这个方法是否是某个字段的读写
		currElements.add(new AutowiredMethodElement(method, required, pd));
	}
}

return new InjectionMetadata(currElements, clazz);

给注入点注入属性

AutowiredFieldElement#inject

//找到字段的值
value = resolveFieldValue(field, bean, beanName);
//反射
if (value != null) {
	ReflectionUtils.makeAccessible(field);
	field.set(bean, value);
}

resolveFieldValue(field, bean, beanName):

//包装成统一的描述符
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
//找到值
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);

return value;

resolveDependency(desc, beanName, autowiredBeanNames, typeConverter):

//设置参数Name发现器
//1. -parameters java8 编译带了这个参数就能获取参数的name
//2. 本地变量表 基于ASM技术
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
if (类型不是 ObjectFactory || Optional) {
	if(依赖带有@Lazy) {
		return 对名称和依赖进行代理（在用的时候再查找注入）;
	} 
	
	return doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}

doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter):

if (descriptor储存了快速解析出来的对象) {
	return shortcut;
}

Object value = 查找依赖是否有@Value, 并获取值
if (value != null && value instanceof String) {
	//解析 ${} 配置内容并获取值
	//计算解析不到也把#Value的值读取出来 后续el表达式解析
	String strVal = resolveEmbeddedValue((String) value);
	value = evaluateBeanDefinitionString(strVal, bd);
	return 类型转化(value);
}

//这里就是判断依赖是否是复数的 下边的Object只是指代对象 不是特定的类型
//Map 会注入 BeanName : 符合要求的Bean对象 作为map的entry
//List