前言

使用Spring，@Autowired注解肯定再熟悉不过了，今天彻底探究一下@Autowired实现的源码细节

实现

其实这个实现方式其实思路很简单：

就是在bean容器中找到type==@Autowired修饰的类型的bean，然后通过反射给属性赋值即可

道理很简单，但还是看代码证实一下，并关注一些实现细节

例子

写一个简单的例子，为方便后续说明

// B Service
@Service
public class BService {
}
// A Service 通过@Autowired依赖注入 B Service
@Service
public class AService {
    @Autowired
    private BService bService;
}

@Autowired实现步骤

spring内部的默认bean工厂实现为DefaultListableBeanFactory，然而该BeanFactory并不支持@Autowired注解

实际上@Autowired注解的支持是依靠于ApplicationContext向DefaultListableBeanFactory注册了Autowired后置处理器：AutowiredAnnotationBeanPostProcessor

在bean创建周期的populateBean(填充属性)中会执行该后置处理器的postProcessProperties方法来完成依赖注入

postProcessProperties

步骤如下

1.查找带有@Autowired的属性

findAutowiringMetadata方法查找了当前类属性中带有@Autowired，@Value的属性，包装成InjectionMetadata

findAutowiringMetadata

buildAutowiringMetadata

autowiredAnnotationTypes

二.通过beanFactory的resolveDependency方法获取需要依赖Bean

InjectionMetadata.inject方法中，调用beanFactory的resolveDependency方法

InjectionMetadata.inject1

其中desc即查找的目标，包含了目标的类型

三.给属性赋值

inject方法最终获取到依赖的bean后，反射完成属性赋值

InjectionMetadata.inject2

到此，依赖注入的功能就实现了

深入resolveDependency

上面的步骤都很好理解，重点是第二步通过beanFactory的resolveDependency查找依赖的bean，所以再次深入探究beanFactory是如何获取到依赖的bean的

以上例debugger一下调用resolveDependency时的参数

debugger

beanName为“AService”即被注入的bean, desc中存放BService的一些信息: BService的类型

所以resolveDependency实际上是根据type获取bean，即getBeanByType，再深入看一下(以下代码都是省略了分支逻辑和缓存逻辑，只保留重点逻辑)

resolveDependency：

public Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
    // spring一般doXXX就是实际的主干代码，如createBean和doCreateBean
    Object result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
    return result;
}

再来doResolveDependency：

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
                                  @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
    // 获取依赖的type，使用type去bean容器查找
    Class<?> type = descriptor.getDependencyType();
    // 查找所有符合的bean
    Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
    // 依赖的beanName
    String autowiredBeanName;
    // 依赖的bean实体
    Object instanceCandidate;
    // 一般情况只有一个，但多个符合的也要处理
    if (matchingBeans.size() > 1) {
        // 从多个里按优先级选择一个，determine即下决定
        autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
        instanceCandidate = matchingBeans.get(autowiredBeanName);
    }
    else {
        // 只有一个的情况(大部分情况)，直接取第一个
        Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
        autowiredBeanName = entry.getKey();
        instanceCandidate = entry.getValue();
    }
    // 如果返回的是class, 转换为实体
    if (instanceCandidate instanceof Class) {
        instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
    }
    // 返回以来的bean实体
    Object result = instanceCandidate;
    return result;
}

其中重点是：

• findAutowireCandidates：根据type查找依赖注入候选者
• determineAutowireCandidate： 当出现多候选者，选择一个(毕竟依赖注入只能注入一个对象)

findAutowireCandidates

根据type查找依赖注入候选者，先看一下它的定义

protected Map<String, Object> findAutowireCandidates(
            @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {            

其中：

• beanName：将被填充属性的bean的name
• requiredType：填充的类型，即要查找的依赖
• DependencyDescriptor：依赖的一些描述
• 返回一个Map<String, Object>，即beanName和bean实体的映射map(value不一定都是bean实体，有可能是实体的类)，一般情况下返回的map.size==1，但也会有多个的情况

再来看下具体代码

protected Map<String, Object> findAutowireCandidates(
        @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
    // 使用BeanFactoryUtils筛选Bean容器中的候选者
    String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
            this, requiredType, true, descriptor.isEager());
    // 初始化返回结构
    Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
    // 1.从resolvableDependencies中筛选候选者
    for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
        Class<?> autowiringType = classObjectEntry.getKey();
        if (autowiringType.isAssignableFrom(requiredType)) {
            Object autowiringValue = classObjectEntry.getValue();
            autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
            if (requiredType.isInstance(autowiringValue)) {
                result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
                break;
            }
        }
    }
    // 2.从bean容器中进一步筛选候选者
    for (String candidate : candidateNames) {
        if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
            addCandidateEntry(result, candidate, descriptor, requiredType);
        }
    }
    // 返回结果
    return result;
}

通过代码可以看出，依赖的候选者来源有两个地方：

• bean容器(使用addCandidateEntry方法加入返回map)
• resolvableDependencies(直接加入返回map)

其中bean容器的查找，交给方法BeanFactoryUtils.beanNamesForTypeIncludingAncestors，那么resolvableDependencies是一个什么东西？

通过查看源码，发现resolvableDependencies也是一个容器，存储的是type->实体的map

resolvableDependencies

再次查找发现容器内容添加基本只有一处，即registerResolvableDependency

registerResolvableDependency

registerResolvableDependency是一个public接口，实际上他的存在是为了实现依赖注入非Bean容器中的Bean，可以叫spring托管的外部bean

比如现在又个单例工具对象，你想让其他bean可以依赖注入这个对象，同时又不想把这个对象加入bean容器，则可以使用registerResolvableDependency加入到resolvableDependencies(相当于给spring中加入一个创建好的对象，供其他bean依赖注入，但不需要spring去创建管理它)

再ApplicationContext初始化阶段，会把ApplicationContext对象，BeanFactory对象通过registerResolvableDependency加入到spring中托管

ApplicationContext.refresh

这就是为什么我们的bean能依赖注入上下文对象和bean工厂本身，如下

注入

当然resolvableDependencies依然只是支线逻辑，重点和大部分情况还是从bean容器中查找依赖，即BeanFactoryUtils.beanNamesForTypeIncludingAncestors方法，这个方法返回的是一个字符串数组，也就是beanName的数组，那怎么返回候选项Object的呐？

答案在addCandidateEntry方法里，看一下它的内部

addCandidateEntry

可以看见它往findAutowireCandidates的result里面的value塞了一个根据字符串getType获取的type(Class)而不是bean的实体，这也是为什么上一步doResolveDependency会有这么一步代码

// 如果返回的是class, 转换为实体
if (instanceCandidate instanceof Class) {
    instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}

所以findAutowireCandidates返回的map可能是beanName->bean实体，但大部分情况下是beanName->beanClass

所以重点又回到了descriptor.resolveCandidate方法，当通过BeanFactoryUtils获取候选注入bean时，返回的是一个beanName->beanClass时，spring调用descriptor.resolveCandidate方法通过beanName获取实际注入的实体(此时beanClass基本就没啥用了)，而resolveCandidate方法内部也很简单，既然有了beanName，直接根据beanName获取bean即可：

public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) throws BeansException {
    return beanFactory.getBean(beanName);
}

getBeanByName就不展开了，这个是最基础的，即通过beanName获取bean定义，初始化创建bean

beanNamesForTypeIncludingAncestors

先看下定义

public static String[] beanNamesForTypeIncludingAncestors(
            ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {

根据命名：通过type查询beanName数组，参数type即查找的类型，IncludingAncestors代表如果lbf有父级，要递归去祖先bean工厂中查找，看下代码

public static String[] beanNamesForTypeIncludingAncestors(
        ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {

    Assert.notNull(lbf, "ListableBeanFactory must not be null");
    // 使用beanFactory的getBeanNamesForType方法查找
    String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
    // 如果有父级，递归查找
    if (lbf instanceof HierarchicalBeanFactory) {
        HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
        if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
            String[] parentResult = beanNamesForTypeIncludingAncestors(
                    (ListableBeanFactory) hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
            result = mergeNamesWithParent(result, parentResult, hbf);
        }
    }
    return result;
}

所以其实最核心的方法就是BeanFactory.getBeanNamesForType，也就是常用的方法getBean(Class<T> requiredType)内部调用的方法，即根据type在bean容器中获取bean，很好理解，本文就不展开了~

总结

总结一下@Autowired的整个过程，画个示意图如下

@Autowired过程