Spring自动装配原理

上一篇文章已经说到在第六次回调时，CommonAnnotationBeanPostProcessor#postProcessProperties 处理 Resource 注解。 AutowiredAnnotationBeanPostProcessor#postProcessProperties 处理 Autowired Inject注解。这篇文章就详细了解Spring如何完成依赖的注入。

// CommonAnnotationBeanPostProcessor#postProcessProperties 
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    // 从缓存中获取了所有的 @Resource 注解的属性
    InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
    try {
        // @Resource返回的Metadata是CommonAnnotationBeanPostProcessor$ResourceElement
        // InjectionMetadata#inject
        metadata.inject(bean, beanName, pvs);
    } catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
    }
    return pvs;
}

// InjectionMetadata#inject
public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
    Collection<InjectedElement> checkedElements = this.checkedElements;
    Collection<InjectedElement> elementsToIterate =
        (checkedElements != null ? checkedElements : this.injectedElements);
    // 如果不存在依赖信息，那么直接跳过这里，不进行注入
    if (!elementsToIterate.isEmpty()) {
        for (InjectedElement element : elementsToIterate) {
            // 不同的InjectedElement实现类调用不同的inject方法
            //  CommonAnnotationBeanPostProcessor$ResourceElement#inject
            // InjectionMetadata$InjectedElement#inject
            // AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement#inject 方法
            // AutowiredAnnotationBeanPostProcessor$AutowiredMethodElement#inject 方法
            element.inject(target, beanName, pvs);
        }
    }
}

InjectedElement：

• @Resource CommonAnnotationBeanPostProcessor$ResourceElement
• @Inject InjectionMetadata$InjectedElement
• @Autowired AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement
  • AutowiredAnnotationBeanPostProcessor$AutowiredMethodElement
• @Lookup CommonAnnotationBeanPostProcessor.LookupElement

// CommonAnnotationBeanPostProcessor$ResourceElement#inject 会直接调用父类的父类InjectedElement#inject
protected void inject(Object target, String requestingBeanName, PropertyValues pvs) {
    // 设置属性值
    if (this.isField) {
        Field field = (Field) this.member;
        ReflectionUtils.makeAccessible(field);
        field.set(target, getResourceToInject(target, requestingBeanName));
    }else {
        if (checkPropertySkipping(pvs)) {
            return;
        }
        try {
            // 处理@Resource的方法
            Method method = (Method) this.member;
            ReflectionUtils.makeAccessible(method);
            method.invoke(target, getResourceToInject(target, requestingBeanName));
        }catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }
}

获取属性值的方法getResourceToInject --> ResourceElement#getResourceToInject

protected Object getResourceToInject(Object target, String requestingBeanName) {
    // lazyLookup就是@Lazy注解中的值，默认没有加注解的话这里就是false
    return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
            getResource(this, requestingBeanName));
}

CommonAnnotationBeanPostProcessor#getResource

​ -> CommonAnnotationBeanPostProcessor#autowireResource

protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName){
    String name = element.name;
    if (factory instanceof AutowireCapableBeanFactory) {
        AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
        DependencyDescriptor descriptor = element.getDependencyDescriptor();
        // containsBean 去singleton和bdMap中寻找了 name
        if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
            // 找名字找不到，这里就根据类型去匹配
            autowiredBeanNames = new LinkedHashSet<>();
            resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
            if (resource == null) {
                throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
            }
        }else {
            // 根据beanName去找
            resource = beanFactory.resolveBeanByName(name, descriptor);
            autowiredBeanNames = Collections.singleton(name);
        }
    }else {
        resource = factory.getBean(name, element.lookupType);
        autowiredBeanNames = Collections.singleton(name);
    }
    // 缓存依赖关系
    if (factory instanceof ConfigurableBeanFactory) {
        ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
        for (String autowiredBeanName : autowiredBeanNames) {
            if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
                // 关键代码
                beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
            }
        }
    }
    return resource;
}

调用doGetBean => getSingleton => 最终返回对象

public Object resolveBeanByName(String name, DependencyDescriptor descriptor) {
    InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
    try {
        return getBean(name, descriptor.getDependencyType());
    }finally {
        ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
    }
}

缓存依赖关系

public void registerDependentBean(String beanName, String dependentBeanName) {
    String canonicalName = canonicalName(beanName);
    synchronized (this.dependentBeanMap) {
        Set<String> dependentBeans =
            this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
        if (!dependentBeans.add(dependentBeanName)) {
            return;
        }
    }
    // key = test2,value=test1,test3  test2依赖与test1和test3
    synchronized (this.dependenciesForBeanMap) {
        Set<String> dependenciesForBean =
            this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
        dependenciesForBean.add(canonicalName);
    }
}

AutowiredAnnotationBeanPostProcessor#postProcessProperties中处理@Autowired等注解

public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    // 获取缓存中的依赖信息
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    // 进行依赖注入  InjectionMetadata#inject AutowiredFieldElement/AutowiredMethodElement
    metadata.inject(bean, beanName, pvs);
}

• 为属性注入

// AutowiredFieldElement#inject
protected void inject(Object bean,String beanName, PropertyValues pvs) throws Throwable {
    // 仅列出核心代码
    // 从容器中获取依赖
    Object value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
    // 通过反射调用set方法
    if (value != null) {
        ReflectionUtils.makeAccessible(field);
        field.set(bean, value);
    }
}

• 为方法注入（从容器中获取方法的参数，然后在调用方法）

protected void inject(Object bean, String beanName,PropertyValues pvs) throws Throwable {
    // 从容器中获取参数列表
    for (int i = 0; i < arguments.length; i++) {
        Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
        if (arg == null && !this.required) {
            arguments = null;
            break;
        }
        arguments[i] = arg;
    }
    // 调用方法
    if (arguments != null) {
        ReflectionUtils.makeAccessible(method);
        method.invoke(bean, arguments);
    }
}

beanFactory.resolveDependency方法，调用了DefaultListableBeanFactory#resolveDependency方法

• 断定依赖的类型是不是Optional类型（构建NestedDependencyDescriptor，去容器中找这个类型的对象）
• 断定依赖的类型是不是ObjectFactory或者ObjectProvider类型（直接返回DependencyObjectProvider）
• 断定依赖的类型是不是java.inject.Provider类型（调用Jsr330Factory#createDependencyProvider创建Jsr330Provider对象返回）

重点看其他情况

// DefaultListableBeanFactory#resolveDependency
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);

注入步骤：

• 根据类型去容器中find 找出这个类型的所有bean

• 如果找出了多个，会根据属性的名称进行筛选（@Primary、@Priority、Ordered等）

• 找到了依赖的bean，判断依赖的类型是不是Class类型，是class获取容器找出对应的bean对象

// DefaultListableBeanFactory#doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
    // 根据类型去容器中find  找出所有的这个类型的bean
    Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
    // 存在多个类型相同的bean对象
    if (matchingBeans.size() > 1) {
        // 根据属性名称进行筛选
        autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
    }else {
        // We have exactly one match.
        Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
        autowiredBeanName = entry.getKey();
        instanceCandidate = entry.getValue();
    }
    if (instanceCandidate instanceof Class) {
        // 如果依赖是class类型
        instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
    }
    Object result = instanceCandidate;
    // 判断类型是否匹配
    if (!ClassUtils.isAssignableValue(type, result)) {
        throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
    }
    return result;
}

findAutowireCandidates是根据类型获取容器中对应的beanName

比如根据IUserService接口的类型，找出来的结果(matchingBeans)如下

matchingBeans{
    {
        key : userServiceImpl1,
        value : 'top.gmfcj.service.impl.UserServiceImpl1'
    },
    {
        key : userServiceImpl2,
        value : 'top.gmfcj.service.impl.UserServiceImpl2'
    }
}

这时，instanceCandidate的类型就是Class，就会再次去容器中根据class去找bean对象（找bean -> 不存在就创建）

public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) {
    // 根据bean名称从容器中获取  AbstractBeanFactory#doGetBean
    return beanFactory.getBean(beanName);
}

自动装配流程.png