Spring 依赖注入优化

原创: carl.zhao SpringForAll社区 今天

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。

  1. <?xml version="1.0" encoding="UTF-8"?>

  2. <beans xmlns="http://www.springframework.org/schema/beans"

  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  4.       xsi:schemaLocation="http://www.springframework.org/schema/beans

  5.       http://www.springframework.org/schema/beans/spring-beans.xsd">

  6.    <bean id="user" class="com.segmentfault.spring.ioc.pogo.User" >

  7.        <property name="id" value="1" />

  8.        <property name="name" value="carl" />

  9.        <property name="car" ref="car" />

  10.    </bean>

  11.    <bean id="car" class="com.segmentfault.spring.ioc.pogo.Car">

  12.        <property name="color" value="red" />

  13.        <property name="price" value="20000" />

  14.    </bean>

  15. </beans>

测试类:

  1. @RunWith(SpringJUnit4ClassRunner.class)

  2. @ContextConfiguration(locations = {"classpath:xml-bean.xml"})

  3. public class XmlBeanTest implements ApplicationContextAware {

  4.    private ApplicationContext context;

  5.    @Test

  6.    public void testXmlBean() {

  7.        User user = context.getBean("user", User.class);

  8.        Assert.assertEquals("Spring xml依赖注入失败:" + user.getName(),"carl", user.getName());

  9.        Assert.assertEquals("Spring xml依赖注入失败:" + user.getCar().getPrice(), "red", user.getCar().getColor());

  10.    }

  11.    @Override

  12.    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

  13.        this.context = applicationContext;

  14.    }

  15. }

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

2、注解依赖注入

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

  1. <?xml version="1.0" encoding="UTF-8"?>

  2. <beans xmlns="http://www.springframework.org/schema/beans"

  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  4.       xmlns:context="http://www.springframework.org/schema/context"

  5.       xsi:schemaLocation="http://www.springframework.org/schema/beans

  6.        http://www.springframework.org/schema/beans/spring-beans.xsd

  7.        http://www.springframework.org/schema/context

  8.        http://www.springframework.org/schema/context/spring-context.xsd">

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

  10.    <bean class="com.segmentfault.spring.ioc.pogo.User" >

  11.        <property name="name" value="xiaomage" />

  12.        <property name="id" value="1" />

  13.    </bean>

  14. </beans>

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

  1. @Component

  2. public class Computer {

  3.    @Autowired

  4.    private User owner;

  5.    public User getOwner() {

  6.        return owner;

  7.    }

  8.    public void setOwner(User owner) {

  9.        this.owner = owner;

  10.    }

  11. }

测试类:

  1. @RunWith(SpringJUnit4ClassRunner.class)

  2. @ContextConfiguration(locations = {"classpath:annotation-bean.xml"})

  3. public class AnnotationBeanTest implements ApplicationContextAware {

  4.    private ApplicationContext context;

  5.    @Override

  6.    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

  7.        this.context = applicationContext;

  8.    }

  9.    @Test

  10.    public void testAnnotationBean() {

  11.        Computer computer = context.getBean(Computer.class);

  12.        Assert.assertEquals("Spring 注解注入失败" + computer.getOwner().getName(),"xiaomage", computer.getOwner().getName());

  13.    }

  14. }

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

3、 Class 依赖注入

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

  1. @Configuration

  2. public class ClazzBeanConfig {

  3.    @Bean

  4.    public Computer computer(User user) {

  5.        Computer computer = new Computer();

  6.        computer.setOwner(user);

  7.        return computer;

  8.    }

  9.    @Bean

  10.    public User  user(){

  11.        User user = new User();

  12.        user.setId(1);

  13.        user.setName("carl");

  14.        return user;

  15.    }

  16. }

Class 依赖注入测试类:

  1. @RunWith(SpringJUnit4ClassRunner.class)

  2. @ContextConfiguration(classes = {ClazzBeanConfig.class})

  3. public class ClazzBeanTest implements ApplicationContextAware {

  4.    private ApplicationContext context;

  5.    @Override

  6.    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

  7.        this.context = applicationContext;

  8.    }

  9.    @Test

  10.    public void testClazzBean(){

  11.        Computer computer = context.getBean(Computer.class);

  12.        Assert.assertEquals("Spring class注入失败","carl", computer.getOwner().getName());

  13.    }

  14. }

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

BeanDefinitionValueResolver#resolveReference

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

4.2 @Resource

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

  1.    public PropertyValues postProcessPropertyValues(

  2.            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

  3.        InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);

  4.        try {

  5.            metadata.inject(bean, beanName, pvs);

  6.        }

  7.        catch (Throwable ex) {

  8.            throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);

  9.        }

  10.        return pvs;

  11.    }

具体依赖注入的逻辑在:

InjectedElement.java

  1.        protected void inject(Object target, String requestingBeanName, PropertyValues pvs) throws Throwable {

  2.            if (this.isField) {

  3.                Field field = (Field) this.member;

  4.                ReflectionUtils.makeAccessible(field);

  5.                field.set(target, getResourceToInject(target, requestingBeanName));

  6.            }

  7.            else {

  8.                if (checkPropertySkipping(pvs)) {

  9.                    return;

  10.                }

  11.                try {

  12.                    Method method = (Method) this.member;

  13.                    ReflectionUtils.makeAccessible(method);

  14.                    method.invoke(target, getResourceToInject(target, requestingBeanName));

  15.                }

  16.                catch (InvocationTargetException ex) {

  17.                    throw ex.getTargetException();

  18.                }

  19.            }

  20.        }

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

  1.    protected Object getResource(LookupElement element, String requestingBeanName) throws BeansException {

  2.        if (StringUtils.hasLength(element.mappedName)) {

  3.            return this.jndiFactory.getBean(element.mappedName, element.lookupType);

  4.        }

  5.        if (this.alwaysUseJndiLookup) {

  6.            return this.jndiFactory.getBean(element.name, element.lookupType);

  7.        }

  8.        if (this.resourceFactory == null) {

  9.            throw new NoSuchBeanDefinitionException(element.lookupType,

  10.                    "No resource factory configured - specify the 'resourceFactory' property");

  11.        }

  12.        return autowireResource(this.resourceFactory, element, requestingBeanName);

  13.    }

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

4.3 @Autowired

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

AutowiredAnnotationBeanPostProcessor.java

  1.    public PropertyValues postProcessPropertyValues(

  2.            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

  3.        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);

  4.        try {

  5.            metadata.inject(bean, beanName, pvs);

  6.        }

  7.        catch (Throwable ex) {

  8.            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);

  9.        }

  10.        return pvs;

  11.    }

具体依赖注入的逻辑在:

AutowiredFieldElement.java

  1.        protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {

  2.            Field field = (Field) this.member;

  3.            try {

  4.                Object value;

  5.                if (this.cached) {

  6.                    value = resolvedCachedArgument(beanName, this.cachedFieldValue);

  7.                }

  8.                else {

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

  10.                    desc.setContainingClass(bean.getClass());

  11.                    Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);

  12.                    TypeConverter typeConverter = beanFactory.getTypeConverter();

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

  14.                    synchronized (this) {

  15.                        if (!this.cached) {

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

  17.                                this.cachedFieldValue = desc;

  18.                                registerDependentBeans(beanName, autowiredBeanNames);

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

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

  21.                                    if (beanFactory.containsBean(autowiredBeanName)) {

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

  23.                                            this.cachedFieldValue = new RuntimeBeanReference(autowiredBeanName);

  24.                                        }

  25.                                    }

  26.                                }

  27.                            }

  28.                            else {

  29.                                this.cachedFieldValue = null;

  30.                            }

  31.                            this.cached = true;

  32.                        }

  33.                    }

  34.                }

  35.                if (value != null) {

  36.                    ReflectionUtils.makeAccessible(field);

  37.                    field.set(bean, value);

  38.                }

  39.            }

  40.            catch (Throwable ex) {

  41.                throw new BeanCreationException("Could not autowire field: " + field, ex);

  42.            }

  43.        }

  44.    }

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

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

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

DefaultListableBeanFactory#resolveDependency

  1.    public Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName,

  2.            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

  3.        descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());

  4.        if (javaUtilOptionalClass == descriptor.getDependencyType()) {

  5.            return new OptionalDependencyFactory().createOptionalDependency(descriptor, requestingBeanName);

  6.        }

  7.        else if (ObjectFactory.class == descriptor.getDependencyType()) {

  8.            return new DependencyObjectFactory(descriptor, requestingBeanName);

  9.        }

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

  11.            return new DependencyProviderFactory().createDependencyProvider(descriptor, requestingBeanName);

  12.        }

  13.        else {

  14.            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(

  15.                    descriptor, requestingBeanName);

  16.            if (result == null) {

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

  18.            }

  19.            return result;

  20.        }

  21.    }

上面代码的逻辑是:

  1. 依赖注入的对象类型是 java.util.Optional

  2. 依赖注入的对象类型是 org.springframework.beans.factory.ObjectFactory

  3. 依赖注入的对象类型是 javax.inject.Provider

  4. 依赖注入的字段包含 org.springframework.context.annotation.Lazy

  5. 其它处理逻辑

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

DefaultListableBeanFactory#doResolveDependency

  1.    public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,

  2.            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

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

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

  5.        if (value != null) {

  6.            if (value instanceof String) {

  7.                String strVal = resolveEmbeddedValue((String) value);

  8.                BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);

  9.                value = evaluateBeanDefinitionString(strVal, bd);

  10.            }

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

  12.            return (descriptor.getField() != null ?

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

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

  15.        }

  16.        if (type.isArray()) {

  17.            Class<?> componentType = type.getComponentType();

  18.            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);

  19.            targetDesc.increaseNestingLevel();

  20.            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, targetDesc);

  21.            if (matchingBeans.isEmpty()) {

  22.                if (descriptor.isRequired()) {

  23.                    raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);

  24.                }

  25.                return null;

  26.            }

  27.            if (autowiredBeanNames != null) {

  28.                autowiredBeanNames.addAll(matchingBeans.keySet());

  29.            }

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

  31.            Object result = converter.convertIfNecessary(matchingBeans.values(), type);

  32.            if (getDependencyComparator() != null && result instanceof Object[]) {

  33.                Arrays.sort((Object[]) result, adaptDependencyComparator(matchingBeans));

  34.            }

  35.            return result;

  36.        }

  37.        else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {

  38.            Class<?> elementType = descriptor.getCollectionType();

  39.            if (elementType == null) {

  40.                if (descriptor.isRequired()) {

  41.                    throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");

  42.                }

  43.                return null;

  44.            }

  45.            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);

  46.            targetDesc.increaseNestingLevel();

  47.            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, targetDesc);

  48.            if (matchingBeans.isEmpty()) {

  49.                if (descriptor.isRequired()) {

  50.                    raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);

  51.                }

  52.                return null;

  53.            }

  54.            if (autowiredBeanNames != null) {

  55.                autowiredBeanNames.addAll(matchingBeans.keySet());

  56.            }

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

  58.            Object result = converter.convertIfNecessary(matchingBeans.values(), type);

  59.            if (getDependencyComparator() != null && result instanceof List) {

  60.                Collections.sort((List<?>) result, adaptDependencyComparator(matchingBeans));

  61.            }

  62.            return result;

  63.        }

  64.        else if (Map.class.isAssignableFrom(type) && type.isInterface()) {

  65.            Class<?> keyType = descriptor.getMapKeyType();

  66.            if (String.class != keyType) {

  67.                if (descriptor.isRequired()) {

  68.                    throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +

  69.                            "] must be [java.lang.String]");

  70.                }

  71.                return null;

  72.            }

  73.            Class<?> valueType = descriptor.getMapValueType();

  74.            if (valueType == null) {

  75.                if (descriptor.isRequired()) {

  76.                    throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");

  77.                }

  78.                return null;

  79.            }

  80.            DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);

  81.            targetDesc.increaseNestingLevel();

  82.            Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, targetDesc);

  83.            if (matchingBeans.isEmpty()) {

  84.                if (descriptor.isRequired()) {

  85.                    raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);

  86.                }

  87.                return null;

  88.            }

  89.            if (autowiredBeanNames != null) {

  90.                autowiredBeanNames.addAll(matchingBeans.keySet());

  91.            }

  92.            return matchingBeans;

  93.        }

  94.        else {

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

  96.            if (matchingBeans.isEmpty()) {

  97.                if (descriptor.isRequired()) {

  98.                    raiseNoSuchBeanDefinitionException(type, "", descriptor);

  99.                }

  100.                return null;

  101.            }

  102.            if (matchingBeans.size() > 1) {

  103.                String primaryBeanName = determineAutowireCandidate(matchingBeans, descriptor);

  104.                if (primaryBeanName == null) {

  105.                    throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());

  106.                }

  107.                if (autowiredBeanNames != null) {

  108.                    autowiredBeanNames.add(primaryBeanName);

  109.                }

  110.                return matchingBeans.get(primaryBeanName);

  111.            }

  112.            // We have exactly one match.

  113.            Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();

  114.            if (autowiredBeanNames != null) {

  115.                autowiredBeanNames.add(entry.getKey());

  116.            }

  117.            return entry.getValue();

  118.        }

  119.    }

上面代码的处理逻辑是:

  1. 依赖注入的对象类型是 java.lang.String

  2. 依赖注入的对象类型是 java.lang.Class#isArray

  3. 依赖注入的对象类型是 java.util.Collection 或其子接口

  4. 依赖注入的对象类型是 java.util.Map 或其子接口

  5. 找到依赖注入对象,如果找到的对象数量超过 1 就会报错

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

DefaultListableBeanFactory#findAutowireCandidates

  1.    protected Map<String, Object> findAutowireCandidates(

  2.            String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

  3.        String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(

  4.                this, requiredType, true, descriptor.isEager());

  5.        Map<String, Object> result = new LinkedHashMap<String, Object>(candidateNames.length);

  6.        for (Class<?> autowiringType : this.resolvableDependencies.keySet()) {

  7.            if (autowiringType.isAssignableFrom(requiredType)) {

  8.                Object autowiringValue = this.resolvableDependencies.get(autowiringType);

  9.                autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);

  10.                if (requiredType.isInstance(autowiringValue)) {

  11.                    result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);

  12.                    break;

  13.                }

  14.            }

  15.        }

  16.        for (String candidateName : candidateNames) {

  17.            if (!isSelfReference(beanName, candidateName) && isAutowireCandidate(candidateName, descriptor)) {

  18.                result.put(candidateName, getBean(candidateName));

  19.            }

  20.        }

  21.        if (result.isEmpty()) {

  22.            DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();

  23.            for (String candidateName : candidateNames) {

  24.                if (!candidateName.equals(beanName) && isAutowireCandidate(candidateName, fallbackDescriptor)) {

  25.                    result.put(candidateName, getBean(candidateName));

  26.                }

  27.            }

  28.        }

  29.        return result;

  30.    }

上面代码的逻辑是:

  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 注解的筛选)。

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

  2. if (matchingBeans.isEmpty()) {

  3.    if (descriptor.isRequired()) {

  4.        raiseNoSuchBeanDefinitionException(type, "", descriptor);

  5.    }

  6.    return null;

  7. }

  8. if (matchingBeans.size() > 1) {

  9.    String primaryBeanName = determineAutowireCandidate(matchingBeans, descriptor);

  10.    if (primaryBeanName == null) {

  11.        throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());

  12.    }

  13.    if (autowiredBeanNames != null) {

  14.        autowiredBeanNames.add(primaryBeanName);

  15.    }

  16.    return matchingBeans.get(primaryBeanName);

  17. }

  18. // We have exactly one match.

  19. Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();

  20. if (autowiredBeanNames != null) {

  21.    autowiredBeanNames.add(entry.getKey());

  22. }

  23. return entry.getValue();

上面代码的逻辑是:

  1. 如果返回 Map 是空,并且依赖注入是必须的就抛出 NoSuchBeanDefinitionException

  2. 如果返回 Map 的 size 大于 1 ,进行筛选出唯一一个 beanName。

筛选逻辑规则如下:

  1.    protected String determineAutowireCandidate(Map<String, Object> candidateBeans, DependencyDescriptor descriptor) {

  2.        Class<?> requiredType = descriptor.getDependencyType();

  3.        String primaryCandidate = determinePrimaryCandidate(candidateBeans, requiredType);

  4.        if (primaryCandidate != null) {

  5.            return primaryCandidate;

  6.        }

  7.        String priorityCandidate = determineHighestPriorityCandidate(candidateBeans, requiredType);

  8.        if (priorityCandidate != null) {

  9.            return priorityCandidate;

  10.        }

  11.        // Fallback

  12.        for (Map.Entry<String, Object> entry : candidateBeans.entrySet()) {

  13.            String candidateBeanName = entry.getKey();

  14.            Object beanInstance = entry.getValue();

  15.            if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||

  16.                    matchesBeanName(candidateBeanName, descriptor.getDependencyName())) {

  17.                return candidateBeanName;

  18.            }

  19.        }

  20.        return null;

  21.    }

  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

招人:数心,造化心数奇;用心等你...

上一篇:Spring 中 BeanFactory 和 ApplicationContext 的区别

Spring 依赖注入优化的更多相关文章

  1. Entity Framework 实体框架的形成之旅--利用Unity对象依赖注入优化实体框架(2)

    在本系列的第一篇随笔<Entity Framework 实体框架的形成之旅--基于泛型的仓储模式的实体框架(1)>中介绍了Entity Framework 实体框架的一些基础知识,以及构建 ...

  2. Spring依赖注入(IOC)那些事

    小菜使用Spring有几个月了,但是对于它的内部原理,却是一头雾水,这次借着工作中遇到的一个小问题,来总结一下Spring. Spring依赖注入的思想,就是把对象交由Spring容器管理,使用者只需 ...

  3. Spring依赖注入三种方式详解

    在讲解Spring依赖注入之前的准备工作: 下载包含Spring的工具jar包的压缩包 解压缩下载下来的Spring压缩包文件 解压缩之后我们会看到libs文件夹下有许多jar包,而我们只需要其中的c ...

  4. Spring依赖注入:注解注入总结

    更多11   spring   依赖注入   注解   java 注解注入顾名思义就是通过注解来实现注入,Spring和注入相关的常见注解有Autowired.Resource.Qualifier.S ...

  5. Spring 依赖注入,在Main方法中取得Spring控制的实例

    Spring依赖注入机制,在Main方法中通过读取配置文件,获取Spring注入的bean实例.这种应用在实训的时候,老师曾经说过这种方法,而且学Spring入门的时候都会先学会使用如何在普通的jav ...

  6. Spring依赖注入 --- 简单使用说明

    Spring依赖注入 --- 简单使用说明 本文将对spring依赖注入的使用做简单的说明,enjoy your time! 1.使用Spring提供的依赖注入 对spring依赖注入的实现方法感兴趣 ...

  7. Spring依赖注入 --- 模拟实现

    Spring依赖注入 --- 模拟实现 面向接口编程,又称面向抽象编程, 数据库如果发生更改,对应的数据访问层也应该改变多写几个实现,需要用谁的时候在service里new谁就可以了面向抽象编程的好处 ...

  8. Java Web系列:Spring依赖注入基础

    一.Spring简介 1.Spring简化Java开发 Spring Framework是一个应用框架,框架一般是半成品,我们在框架的基础上可以不用每个项目自己实现架构.基础设施和常用功能性组件,而是 ...

  9. Spring依赖注入的三种方式

    看过几篇关于Spring依赖注入的文章,自己简单总结了一下,大概有三种方式: 1.自动装配 通过配置applicationContext.xml中的标签的default-autowire属性,或者标签 ...

随机推荐

  1. druid 连接Oracle时出现的错误

    转博主https://blog.csdn.net/jiangyu1013/article/details/70237550#commentsedit mysql 更新 SQL 语句 无错误 批量 报错 ...

  2. Linux基础学习笔记2-文件管理和重定向

    本节内容 1)文件系统结构元素 2)创建和查看文件 3)复制.转移和删除文件 4)软和硬链接 5)三种I/O设备 6)把I/O重定向至文件 7)使用管道 文件系统和结构 文件系统 文件和目录被组织成一 ...

  3. shit vue & shit iview

    shit vue & shit iview <Switch> !== <i-switch> https://www.iviewui.com/components/swi ...

  4. js的常用文档对象,document

    1.document的概念:window的子对象,由于DOM对象模型的默认对象就是window,因此Window对象中的方法和子对象不需要通过Window来引用. - 2.document的组成:属性 ...

  5. Vasya and a Tree CodeForces - 1076E(线段树+dfs)

    I - Vasya and a Tree CodeForces - 1076E 其实参考完别人的思路,写完程序交上去,还是没理解啥意思..昨晚再仔细想了想.终于弄明白了(有可能不对 题意是有一棵树n个 ...

  6. hdu-4763(kmp+拓展kmp)

    题意:给你一个串,问你满足最大字串既是前后缀,也在字符串除去前后缀的位置中出现过: 思路:我用的是拓展kmp求的前后缀,只用kmp也能解,在字符串2/3的位置后开始遍历,如果用一个maxx保存前2/3 ...

  7. Tyche 2191 WYF的递推式

    题目描述 WYF手中有这样一条递推式 WYF并不是想让你帮他做出结果,事实上,给定一个n,他能够迅速算出Fn.WYF只是想单纯的考验一下读者们. 输入描述 仅一行,三个整数N,F1,P 输出描述 仅一 ...

  8. Auth模块使用方法大全

    auth认证 导包 from django.contrib import auth 默认数据库中使用auth_user表 创建超级用户 python manage.py createsuperuser ...

  9. Qt 获取屏幕信息

    void GetScreenInfo() { QDesktopWidget* desktopWidget = QApplication::desktop(); //获取可用桌面大小 QRect des ...

  10. hbase系列

    jvmhttps://www.cnblogs.com/jiyukai/p/6665199.html hbase https://blog.csdn.net/lizhitao/article/detai ...