Spring 依赖注入优化

Spring 最大的好处就是依赖注入,关于什么是依赖注入,在Stack Overflow上面有一个问题,如何向一个5岁的小孩解释依赖注入,其中得分最高的一个答案是:

When you go and get things out of the refrigerator for yourself, you can cause problems. You might leave the door open, you might get something Mommy or Daddy doesn’t want you to have. You might even be looking for something we don’t even have or which has expired.
What you should be doing is stating a need, “I need something to drink with lunch,” and then we will make sure you have something when you sit down to eat.

映射到面向对象程序开发中就是:

高层类(5岁小孩)应该依赖底层基础设施(家长)来提供必要的服务。

把对象纳入到 Spring 容器的管理,然后就可以很容器的进行对象的引用了,也就是依赖注入(DI)。Spring 依赖注入一般有以下三种方式依赖注入方式:

  • xml 依赖注入
  • 注解依赖注入
  • 方法参数依赖注入(通过 Class 定义 Bean)

下面就介绍一下 Spring 依赖注入的三种方式。

1、xml 依赖注入

具体的实体类我就不写了(使用过 Spring 的朋友应该的知道),通过 xml 来定义 bean。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.segmentfault.spring.ioc.pogo.User" >
        <property name="id" value="1" />
        <property name="name" value="carl" />
        <property name="car" ref="car" />
    </bean>

    <bean id="car" class="com.segmentfault.spring.ioc.pogo.Car">
        <property name="color" value="red" />
        <property name="price" value="20000" />
    </bean>

</beans>

测试类:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:xml-bean.xml"})
public class XmlBeanTest implements ApplicationContextAware {

    private ApplicationContext context;

    @Test
    public void testXmlBean() {
        User user = context.getBean("user", User.class);
        Assert.assertEquals("Spring xml依赖注入失败:" + user.getName(),"carl", user.getName());
        Assert.assertEquals("Spring xml依赖注入失败:" + user.getCar().getPrice(), "red", user.getCar().getColor());
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
}

通过 Spring 获取对象的时候只需要调用 ApplicationContext#getBean 方法传入我们需要的对象的 beanId。然后就可以获取到 Spring 帮我们创建好的对象,里面包含了我们定义的各种属性。

2、注解依赖注入

通过 xml 定义 Spring bean,把对象纳入 Spring 容器的管理。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.segmentfault.spring.ioc.beans.annotation" />

    <bean class="com.segmentfault.spring.ioc.pogo.User" >
        <property name="name" value="xiaomage" />
        <property name="id" value="1" />
    </bean>

</beans>

使用 @Component 声明这个对象是 Spring bean 对象,因为在 xml 里面定义了 <context:component-scan > 会把这个包下所有标注了 @Component 注解及其扩展注解(如:@Service、@Controller)都扫描到 Spring 容器当中。

@Component
public class Computer {

    @Autowired
    private User owner;

    public User getOwner() {
        return owner;
    }

    public void setOwner(User owner) {
        this.owner = owner;
    }
}

测试类:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:annotation-bean.xml"})
public class AnnotationBeanTest implements ApplicationContextAware {

    private ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }

    @Test
    public void testAnnotationBean() {
        Computer computer = context.getBean(Computer.class);
        Assert.assertEquals("Spring 注解注入失败" + computer.getOwner().getName(),"xiaomage", computer.getOwner().getName());
    }

}

同样的,通过调用 ApplicationContext#getBean 方法就可以获取到 Spring 帮我们创建好的对象。

3、 Class 依赖注入

通过 Class 定义 Spring 的 bean,通过 @Bean 方法参数把需要的对象依赖注入到 @Bean 方法创建的对象当中对。

@Configuration
public class ClazzBeanConfig {

    @Bean
    public Computer computer(User user) {
        Computer computer = new Computer();
        computer.setOwner(user);
        return computer;
    }

    @Bean
    public User  user(){
        User user = new User();
        user.setId(1);
        user.setName("carl");
        return user;
    }

}

Class 依赖注入测试类:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {ClazzBeanConfig.class})
public class ClazzBeanTest implements ApplicationContextAware {

    private ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }

    @Test
    public void testClazzBean(){
        Computer computer = context.getBean(Computer.class);
        Assert.assertEquals("Spring class注入失败","carl", computer.getOwner().getName());
    }

}

我们可样的可以看到这个 TestCase 是成功的,说明这也是 Spring 依赖注入的一种。虽然都是依赖注入,但是 Spring 对它的实现是不一样的。

4、依赖注入原理分析

如果大家不太清楚依赖注入的原始,推荐看一下我之前写的一篇 Spring 相关的文章 – Spring 源码导读。里面大概分析了 Spring IOC 的大概原理。Spring IOC 其实就是资源(xml、annotation、class)解析以及依赖注入(BeanFactory#getBean)。在这里我再概述一下:

  • 在 Spring 进行 依赖注入的时候,首先把各种资源(xml、annotation、class) 转化成 Resource 抽象,通过里面的 IO 流读取定义的 bean。然后再转化成 BeanDefinitioin,里面定义了包括构造器注入,以及 setter 注入的定义。
  • 调用 BeanFactory#getBean 开始依赖注入,通过 BeanWrapper 这个接口,首先获取定义的构造器注入属性,通过反射中的 Constructor 来创建对象。基于这个对象,通过 java 里面的内省机制获取到定义属性的属性描述器(PropertyDescriptor),调用属性的写入方法。如果这个字段的值是简单对象直接调用 setter 方法,如果这个字段的值是复杂对象那么继续调用 BeanFactory#getBean 直到所有的属性都是简单对象为止。

4.1 getBean

在 xml 定义一个对象依赖于另外一个对象的时候一般都是通过 <property name="fieldName" ref="beanId" /> 通过定义字段名称以及依赖的对象的 beanId 来进行依赖注入的。 在这里 Spring 其实是直接通过调用BeanFactory#getBean(java.lang.String) 来进行依赖注入的。具体的实现位置为

BeanDefinitionValueResolver#resolveReference

xml-ioc.png

下面我们来分析一下通过注解来进行依赖注入,我们使用注解进行依赖注入,在 Spring 里面依赖注入分为简单对象依赖注入与复杂对象依赖注入。简单对象依赖注入可以使用 @Value 注解进行注入。它的逻辑是固定的,一般用于占位符的值的注入。今天我们讨论点主要是复杂对象的依赖注入。使用注解的时候一般可以使用 @Resource 以及 @Autowired ,下面我们来分别讨论一下这两个注解的实现。它的实现的大体逻辑是在对象实例化之后,通过这找到这个定义类上面的注解,看看哪些属性包含依赖注入的注解,然后循环遍历依次依赖注入。

4.2 @Resource

@Resource 注解的实现是通过 Spring ioc 扩展的 BeanPostProcessor 来实现的。具体的实现类是 CommonAnnotationBeanPostProcessor,它是找到具体类的上面标注了所有标注 @Resource 的字段。

    public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
        try {
            metadata.inject(bean, beanName, pvs);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
        }
        return pvs;
    }

具体依赖注入的逻辑在:

InjectedElement.java

        protected void inject(Object target, String requestingBeanName, PropertyValues pvs) throws Throwable {
            if (this.isField) {
                Field field = (Field) this.member;
                ReflectionUtils.makeAccessible(field);
                field.set(target, getResourceToInject(target, requestingBeanName));
            }
            else {
                if (checkPropertySkipping(pvs)) {
                    return;
                }
                try {
                    Method method = (Method) this.member;
                    ReflectionUtils.makeAccessible(method);
                    method.invoke(target, getResourceToInject(target, requestingBeanName));
                }
                catch (InvocationTargetException ex) {
                    throw ex.getTargetException();
                }
            }
        }

然后调用 CommonAnnotationBeanPostProcessor#getResource 获取到需要注入对象的值。

    protected Object getResource(LookupElement element, String requestingBeanName) throws BeansException {
        if (StringUtils.hasLength(element.mappedName)) {
            return this.jndiFactory.getBean(element.mappedName, element.lookupType);
        }
        if (this.alwaysUseJndiLookup) {
            return this.jndiFactory.getBean(element.name, element.lookupType);
        }
        if (this.resourceFactory == null) {
            throw new NoSuchBeanDefinitionException(element.lookupType,
                    "No resource factory configured - specify the 'resourceFactory' property");
        }
        return autowireResource(this.resourceFactory, element, requestingBeanName);
    }

它查询的逻辑是先通过 beanName 从容器中获取对象的值。 如果对象创建好那么 Spring 是通过 以 beanName 为 key , 然后对象的实例为值来保存的。所以这种方式的查询复杂度是 O(1)。beanName 可以通过 @Resouce 注解的 name() 指定,如果没有指定就以这个属性的变量名称为 beanName。如果通过 beanName 查询不到,就会以类型依赖注入。如果这个接口有多个实现,使用类型依赖注入就会报错。因为它不知道你需要哪个对象来注入。类型依赖注入的逻辑其实就是 @Autowired 的逻辑一样。下面我们就来讲解一下 @Autowired 的实现逻辑。

4.3 @Autowired

@Autowired 注解的实现是同样是通过 Spring ioc 扩展的 BeanPostProcessor 来实现的。具体的实现类是 AutowiredAnnotationBeanPostProcessor,它是找到具体类的上面标注了所有标注 @Autowired 的字段。

AutowiredAnnotationBeanPostProcessor.java

    public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
        try {
            metadata.inject(bean, beanName, pvs);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
        }
        return pvs;
    }

具体依赖注入的逻辑在:

AutowiredFieldElement.java

        protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
            Field field = (Field) this.member;
            try {
                Object value;
                if (this.cached) {
                    value = resolvedCachedArgument(beanName, this.cachedFieldValue);
                }
                else {
                    DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
                    desc.setContainingClass(bean.getClass());
                    Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
                    TypeConverter typeConverter = beanFactory.getTypeConverter();
                    value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
                    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)) {
                                        if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                                            this.cachedFieldValue = new RuntimeBeanReference(autowiredBeanName);
                                        }
                                    }
                                }
                            }
                            else {
                                this.cachedFieldValue = null;
                            }
                            this.cached = true;
                        }
                    }
                }
                if (value != null) {
                    ReflectionUtils.makeAccessible(field);
                    field.set(bean, value);
                }
            }
            catch (Throwable ex) {
                throw new BeanCreationException("Could not autowire field: " + field, ex);
            }
        }
    }

@Autowired 使用的是类型注入,如果需要这个接口有多个实现可以使用 @Qualifier 指定具体实现类。但是它的实现逻辑是一致的,只是通过 @Qualifier 进行的选择。类型依赖注入是通过调用 beanFactory#resolveDependency 获取到依赖注入的类。下面我们来看一下类型依赖注入的具体实现逻辑。

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

它具体的实现类是在 DefaultListableBeanFactory 里:

DefaultListableBeanFactory#resolveDependency

    public Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

        descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
        if (javaUtilOptionalClass == descriptor.getDependencyType()) {
            return new OptionalDependencyFactory().createOptionalDependency(descriptor, requestingBeanName);
        }
        else if (ObjectFactory.class == descriptor.getDependencyType()) {
            return new DependencyObjectFactory(descriptor, requestingBeanName);
        }
        else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
            return new DependencyProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
        }
        else {
            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
                    descriptor, requestingBeanName);
            if (result == null) {
                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
            }
            return result;
        }
    }

上面代码的逻辑是:

  1. 依赖注入的对象类型是 java.util.Optional
  2. 依赖注入的对象类型是 org.springframework.beans.factory.ObjectFactory
  3. 依赖注入的对象类型是 javax.inject.Provider
  4. 依赖注入的字段包含 org.springframework.context.annotation.Lazy
  5. 其它处理逻辑

下面我们再来看一下除了上面特殊的逻辑处理, Spring 接下来是如何处理的。

DefaultListableBeanFactory#doResolveDependency

    public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

        Class<?> type = descriptor.getDependencyType();
        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());
            return (descriptor.getField() != null ?
                    converter.convertIfNecessary(value, type, descriptor.getField()) :
                    converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
        }

        if (type.isArray()) {
            Class<?> componentType = type.getComponentType();
            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
            targetDesc.increaseNestingLevel();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, targetDesc);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (getDependencyComparator() != null && result instanceof Object[]) {
                Arrays.sort((Object[]) result, adaptDependencyComparator(matchingBeans));
            }
            return result;
        }
        else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
            Class<?> elementType = descriptor.getCollectionType();
            if (elementType == null) {
                if (descriptor.isRequired()) {
                    throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");
                }
                return null;
            }
            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
            targetDesc.increaseNestingLevel();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, targetDesc);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            Object result = converter.convertIfNecessary(matchingBeans.values(), type);
            if (getDependencyComparator() != null && result instanceof List) {
                Collections.sort((List<?>) result, adaptDependencyComparator(matchingBeans));
            }
            return result;
        }
        else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
            Class<?> keyType = descriptor.getMapKeyType();
            if (String.class != keyType) {
                if (descriptor.isRequired()) {
                    throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +
                            "] must be [java.lang.String]");
                }
                return null;
            }
            Class<?> valueType = descriptor.getMapValueType();
            if (valueType == null) {
                if (descriptor.isRequired()) {
                    throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");
                }
                return null;
            }
            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
            targetDesc.increaseNestingLevel();
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, targetDesc);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);
                }
                return null;
            }
            if (autowiredBeanNames != null) {
                autowiredBeanNames.addAll(matchingBeans.keySet());
            }
            return matchingBeans;
        }
        else {
            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
            if (matchingBeans.isEmpty()) {
                if (descriptor.isRequired()) {
                    raiseNoSuchBeanDefinitionException(type, "", descriptor);
                }
                return null;
            }
            if (matchingBeans.size() > 1) {
                String primaryBeanName = determineAutowireCandidate(matchingBeans, descriptor);
                if (primaryBeanName == null) {
                    throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
                }
                if (autowiredBeanNames != null) {
                    autowiredBeanNames.add(primaryBeanName);
                }
                return matchingBeans.get(primaryBeanName);
            }
            // We have exactly one match.
            Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
            if (autowiredBeanNames != null) {
                autowiredBeanNames.add(entry.getKey());
            }
            return entry.getValue();
        }
    }

上面代码的处理逻辑是:

  1. 依赖注入的对象类型是 java.lang.String
  2. 依赖注入的对象类型是 java.lang.Class#isArray
  3. 依赖注入的对象类型是 java.util.Collection 或其子接口
  4. 依赖注入的对象类型是 java.util.Map 或其子接口
  5. 找到依赖注入对象,如果找到的对象数量超过 1 就会报错

我们来分析一下 Spring 是如何根据类型来查询具体的实例。

DefaultListableBeanFactory#findAutowireCandidates

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

        String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                this, requiredType, true, descriptor.isEager());
        Map<String, Object> result = new LinkedHashMap<String, Object>(candidateNames.length);
        for (Class<?> autowiringType : this.resolvableDependencies.keySet()) {
            if (autowiringType.isAssignableFrom(requiredType)) {
                Object autowiringValue = this.resolvableDependencies.get(autowiringType);
                autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
                if (requiredType.isInstance(autowiringValue)) {
                    result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
                    break;
                }
            }
        }
        for (String candidateName : candidateNames) {
            if (!isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, descriptor)) {
                result.put(candidateName, getBean(candidateName));
            }
        }
        if (result.isEmpty()) {
            DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
            for (String candidateName : candidateNames) {
                if (!candidateName.equals(beanName) && isAutowireCandidate(candidateName, fallbackDescriptor)) {
                    result.put(candidateName, getBean(candidateName));
                }
            }
        }
        return result;
    }

上面代码的逻辑是:

  1. 在 Spring 容器中遍历注册的 Bean 信息,获取到类型为传入类型的的 beanName 数组
  2. 遍历 resolvableDependencies 集合,判断传入类型是否是它的对象实例,如果是添加到 result 的 Map 里面。
  3. 遍历查询到的 beanName 数据,如果不是自我依赖,就是对象 A 依赖 A,并且是依赖注入的候选者(里面包含 @Qualifier 注解),如果是添加到 result 的 Map 里面。
  4. 如果获取到的 result 为空,遍历第一步获取到的所有的 beanNames 数组判断如果不包含传入的 beanName,并且是依赖注入的候选者,如果是添加到 result 的 Map 里面。

因为查询出来的返回 Map 的 size 可能大于 1 ,所以 Spring 再外面又一次进行了筛选(之前查询经过了 @Qualifier 注解的筛选)。

Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
    if (descriptor.isRequired()) {
        raiseNoSuchBeanDefinitionException(type, "", descriptor);
    }
    return null;
}
if (matchingBeans.size() > 1) {
    String primaryBeanName = determineAutowireCandidate(matchingBeans, descriptor);
    if (primaryBeanName == null) {
        throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
    }
    if (autowiredBeanNames != null) {
        autowiredBeanNames.add(primaryBeanName);
    }
    return matchingBeans.get(primaryBeanName);
}
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
if (autowiredBeanNames != null) {
    autowiredBeanNames.add(entry.getKey());
}
return entry.getValue();

上面代码的逻辑是:

  1. 如果返回 Map 是空,并且依赖注入是必须的就抛出 NoSuchBeanDefinitionException
  2. 如果返回 Map 的 size 大于 1 ,进行筛选出唯一一个 beanName。

筛选逻辑规则如下:

    protected String determineAutowireCandidate(Map<String, Object> candidateBeans, DependencyDescriptor descriptor) {
        Class<?> requiredType = descriptor.getDependencyType();
        String primaryCandidate = determinePrimaryCandidate(candidateBeans, requiredType);
        if (primaryCandidate != null) {
            return primaryCandidate;
        }
        String priorityCandidate = determineHighestPriorityCandidate(candidateBeans, requiredType);
        if (priorityCandidate != null) {
            return priorityCandidate;
        }
        // Fallback
        for (Map.Entry<String, Object> entry : candidateBeans.entrySet()) {
            String candidateBeanName = entry.getKey();
            Object beanInstance = entry.getValue();
            if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
                    matchesBeanName(candidateBeanName, descriptor.getDependencyName())) {
                return candidateBeanName;
            }
        }
        return null;
    }
  1. 判断所有的候选者的 beanName 中看是不是实例对象有且只有一个对象标注了 @Primary 注解(多个标注会报错)。
  2. 根据 bean 实现的 Ordered 接口,及其相关注解判断 bean 实例的优先级,取最优先的 bean。
  3. 判断依赖注入的字段的变量名称,如果这个变量的名称与返回的多个实例其中的 beanName 一致就返回这个对象。
  4. 返回空。

Class 依赖注入的逻辑和注解依赖注入的逻辑类型,并且比注解依赖注入的逻辑更复杂。在这里就不深入分析了。经过上面的分析,我们可以得出以下判断。 @Resource 是可以根据它指定的 beanName 进行依赖注入并且它查询依赖注入的时间复杂度为 O(1),如果查询不到就走和 @Autowired 的依赖注入的查询逻辑。不管是否添加了 @Qualifier, 这个过程都是相当复杂。

所以优化 Spring 依赖注入的方式是使用 xml 进行 bean 依赖注入或者 使用 @Resource 根据 beanName 查询依赖对象进行依赖注入。

参考资料:
- https://www.cnblogs.com/yangecnu/p/Introduce-Dependency-Injection.html

发布了173 篇原创文章 · 获赞 221 · 访问量 70万+

猜你喜欢

转载自blog.csdn.net/u012410733/article/details/81436610