SpringloC容器的依赖注入源码解析（10）—— populateBean的剩余逻辑(1)

}

}

该方法遍历每一个属性元素去调用元素的inject方法，进入inject发现又回到了AutowiredAnnotationBeanPostProcessor类里：

@Override

protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {

// 获取要注入的成员变量

Field field = (Field) this.member;

Object value;

// 如果成员变量的值先前缓存过

if (this.cached) {

// 从缓存中获取成员变量的值

value = resolvedCachedArgument(beanName, this.cachedFieldValue);

}

// 没有缓存

else {

// 创建一个成员变量的依赖描述符实例

DependencyDescriptor desc = new DependencyDescriptor(field, this.required);

desc.setContainingClass(bean.getClass());

Set autowiredBeanNames = new LinkedHashSet<>(1);

Assert.state(beanFactory != null, “No BeanFactory available”);

// 获取容器的类型转换器

TypeConverter typeConverter = beanFactory.getTypeConverter();

try {

// 获取注入的值

value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);

}

catch (BeansException ex) {

throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);

}

synchronized (this) {

if (!this.cached) {

if (value != null || this.required) {

this.cachedFieldValue = desc;

registerDependentBeans(beanName, autowiredBeanNames);

if (autowiredBeanNames.size() == 1) {

String autowiredBeanName = autowiredBeanNames.iterator().next();

if (beanFactory.containsBean(autowiredBeanName) &&

beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {

this.cachedFieldValue = new ShortcutDependencyDescriptor(

desc, autowiredBeanName, field.getType());

}

}

}

else {

this.cachedFieldValue = null;

}

this.cached = true;

}

}

}

if (value != null) {

ReflectionUtils.makeAccessible(field);

field.set(bean, value);

}

}

}

在调用的过程中复用了其他类的装配能力，此时是给boyfriend装配上girlfriend实例，首先去缓存里看下之前是否解析过girlfriend，第一次执行会进入到else里，先用DependencyDescriptor包装一下属性field：

DependencyDescriptor desc = new DependencyDescriptor(field, this.required);

之后给desc注册上宿主的类名（Boyfriend）：

desc.setContainingClass(bean.getClass());

之后会尝试获取之前容器初始化时注册上去的转换器TypeConverter：

TypeConverter typeConverter = beanFactory.getTypeConverter();

converter用来做类型转换，默认获取spring自带的simpleTypeConverter用来处理简单类型的转换，之后执行

// 获取注入的值

value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);

进入resolveDependency方法里：

@Override

@Nullable

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,

@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());

if (Optional.class == descriptor.getDependencyType()) {

return createOptionalDependency(descriptor, requestingBeanName);

}

else if (ObjectFactory.class == descriptor.getDependencyType() ||

ObjectProvider.class == descriptor.getDependencyType()) {

return new DependencyObjectProvider(descriptor, requestingBeanName);

}

else if (javaxInjectProviderClass == descriptor.getDependencyType()) {

return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);

}

else {

Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(

descriptor, requestingBeanName);

if (result == null) {

result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);

}

return result;

}

}

在方法里会依据依赖描述符的不同类型进行不同的处理，但是最终都会到else里，真正起作用的是doResolveDependency方法

@Nullable

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,

@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);

try {

// 该方法最终调用了beanFactory.getBean(String, Class)，从容器中获取依赖

Object shortcut = descriptor.resolveShortcut(this);

// 如果容器缓存中存在所需依赖，这里进行短路路操作，提前结束依赖解析逻辑

if (shortcut != null) {

return shortcut;

}

Class<?> type = descriptor.getDependencyType();

// 处理@Value注解

Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);

if (value != null) {

if (value instanceof String) {

String strVal = resolveEmbeddedValue((String) value);

BeanDefinition bd = (beanName != null && containsBean(beanName) ?

getMergedBeanDefinition(beanName) : null);

value = evaluateBeanDefinitionString(strVal, bd);

}

TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());

try {

return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());

}

catch (UnsupportedOperationException ex) {

// A custom TypeConverter which does not support TypeDescriptor resolution…

return (descriptor.getField() != null ?

converter.convertIfNecessary(value, type, descriptor.getField()) :

converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));

}

}

// 如果标识@Autowired注解的成员变量是复合类型，如Array，Collection，Map

// 从这个方法获取@Autowired里的值

Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);

if (multipleBeans != null) {

return multipleBeans;

}

Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);

if (matchingBeans.isEmpty()) {

if (isRequired(descriptor)) {

raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);

}

return null;

}

String autowiredBeanName;

Object insta