Spring @Autowired 注入类的集合类型深度解剖

作者: HelloLittleRain | 来源:发表于2019-01-18 18:04 被阅读46次

Spring是你可靠的大管家。

先看demo，放码过来

有一个用户实体类User，包含姓名name、年龄age、电话mobile三个属性。

/**
 * 用户实体
 *
 * @author weixiaoyu
 * @date 2018/4/27
 */
public class User {
    /**
     * 姓名
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 电话
     */
    private String mobile;
    /**
     * 构造方法
     *
     * @param name
     * @param age
     * @param mobile
     */
    public User(String name, Integer age, String mobile) {
        this.name = name;
        this.age = age;
        this.mobile = mobile;
    }

    /* setter & getter */
}

有一个接口BasePrintService，是打印信息基础服务类，接口中有一个print打印信息方法，方法的参数为上面定义的User用户类。

/**
 * 打印信息基础服务类
 *
 * @author weixiaoyu1
 * @date 2019/1/16
 */
public interface BasePrintService {
    /**
     * 打印
     *
     * @param user
     */
    void print(User user);
}

BasePrintService接口有三个实现类PrintNameServiceImpl、PrintAgeServiceImpl和PrintMobileServiceImpl，分别实现了打印名称、打印年龄和打印电话的功能。
注意：这三个实现类上方都标明了@Service注解，表明服务Bean交给Spring进行管理。

/**
 * 打印名称服务实现类
 *
 * @author weixiaoyu1
 * @date 2019/1/16
 */
@Service
public class PrintNameServiceImpl implements BasePrintService {
    /**
     * 打印名称
     *
     * @param user
     */
    @Override
    public void print(User user) {
        System.out.println("打印名称 ---> User.name = " + user.getName());
    }
}

/**
 * 打印年龄服务实现类
 *
 * @author weixiaoyu1
 * @date 2019/1/16
 */
@Service
public class PrintAgeServiceImpl implements BasePrintService {
    /**
     * 打印年龄
     *
     * @param user
     */
    @Override
    public void print(User user) {
        System.out.println("打印年龄 ---> User.age = " + user.getAge().toString());
    }
}

/**
 * 打印电话服务实现类
 *
 * @author weixiaoyu1
 * @date 2019/1/16
 */
@Service
public class PrintMobileServiceImpl implements BasePrintService {
    /**
     * 打印电话
     *
     * @param user
     */
    @Override
    public void print(User user) {
        System.out.println("打印电话 ---> User.mobile = " + user.getMobile());
    }
}

测试类，注释都写的很清楚哈

/**
 * 测试打印类
 *
 * @author weixiaoyu1
 * @date 2019/1/16
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = PpValidatorApplication.class)
public class PrintServiceTest {
    /**
     * '将所有类型为BasePrintService的Bean注入为一个List
     */
    @Autowired
    private List<BasePrintService> printServiceList;
    /**
     * '将所有类型为BasePrintService的Bean注入为一个Map
     * key为Bean的name
     */
    @Autowired
    private Map<String, BasePrintService> printServiceMap;

    /**
     * 测试方法，遍历List，执行每一个Bean的print方法
     */
    @Test
    public void testPrintList() {
        User user = new User("LittleRain", 25, "13010101100");
        for (BasePrintService printService : printServiceList) {
            printService.print(user);
        }
    }

    /**
     * 测试方法，遍历Map，先打印Map的key（也就是Bean的name），再执行每一个Bean的print方法
     */
    @Test
    public void testPrintMap() {
        User user = new User("LittleRain", 25, "13010101100");
        for (String beanName : printServiceMap.keySet()) {
            System.out.println("打印实现类beanName = " + beanName);
            printServiceMap.get(beanName).print(user);
        }
    }
}

通过@Autowired将所有类型为BasePrintService的Bean注入为ListList<BasePrintService>。
将所有类型为BasePrintService的Bean注入为MapMap<String, BasePrintService>，
Map的 key 为Bean的 name。
调用测试类的testPrintList()方法，遍历List，依次执行每一个类型为BasePrintService的Bean的print方法，执行结果如下：

打印年龄 ---> User.age = 25
打印电话 ---> User.mobile = 13010101100
打印名称 ---> User.name = LittleRain

调用测试类的testPrintMap()方法，遍历Map，先打印Map的key（也就是类型为BasePrintService的Bean的name），再依次执行每一个Bean的print方法，执行结果如下：

打印实现类beanName = printAgeServiceImpl
打印年龄 ---> User.age = 25
打印实现类beanName = printMobileServiceImpl
打印电话 ---> User.mobile = 13010101100
打印实现类beanName = printNameServiceImpl
打印名称 ---> User.name = LittleRain

demo总结：

所有实现了BasePrintService接口的实现类PrintNameServiceImpl、PrintAgeServiceImpl和PrintMobileServiceImpl，通过@Service注解，将Bean交给Spring进行管理。
此时Bean的name为类名的首字母小写，type为BasePrintService。

通过Spring提供的@Autowired注解，可以将所有类型为BasePrintService的Bean注入为一个List，也可以注入为一个Map，此时Map的 key 为Bean的 name。

所有Bean的配置和注入都交给Spring去管理，通过@Autowired注解可以一次性的将所有满足条件的Bean注入到一个集合中。

这种方式提供了代码设计上更多花样的可行性，咱们下篇文章再细说（提前占个坑）~

提问

为什么可以通过@Autowired注解可以一次性的将所有满足条件的Bean注入到一个集合中呢？具体Spring又是如何实现的呢？为神马？？？

那么，开始扒源码吧

我们知道可以通过注解@Service等将Bean注册到Spring容器中，交给Spring进行管理。

具体处理过程可以看这篇文章：Spring对注解(Annotation)处理源码分析1——扫描和读取Bean定义

画重点，管理注解Bean定义的容器AnnotationConfigApplicationContext直接注册、或扫描指定的包及其子包后调用注册方法，将Bean进行一系列处理过后注册到BeanFactory的HashMap中。

又知道可以通过使用getBean方法向Spring容器的BeanFactory索取被管理的Bean。

具体处理过程可以看这篇文章：《Spring技术内幕》学习笔记5——IoC容器的依赖注入

追踪实现了BeanFactory的getBean方法的AbstractApplicationContext

@Override
public Object getBean(String name) throws BeansException {
    assertBeanFactoryActive();
    return getBeanFactory().getBean(name);
}

调用了AbstractBeanFactory的doGetBean方法

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

doGetBean方法是实际干活的，里面重要的一步就是createBean方法创建Bean。

if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, () -> {
        try {
            return createBean(beanName, mbd, args);
        }
        catch (BeansException ex) {
            destroySingleton(beanName);
            throw ex;
        }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

我们跳进AbstractAutowireCapableBeanFactory的createBean方法，里面真正干活的是 doCreateBean方法，创建了Bean实例。

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

doCreateBean方法里面有两个重要的步骤， createBeanInstance和populateBean。

// 生成Bean所包含的java对象实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
// 对Bean属性的依赖注入进行处理
populateBean(beanName, mbd, instanceWrapper);

createBeanInstance方法生成Bean所包含的java对象实例，我们就不往里深扒了。
重点看populateBean方法，给刚创建的实例处理属性的依赖注入。
我们直接定位到关键代码。

pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

我们知道容器对Bean对象依赖注入时，是通过容器中注册的 Bean后置处理器 处理这些注解的。而对于@Autowired注解，则是通过AutowiredAnnotationBeanPostProcessor这个Bean后置处理器进行处理的。
所以直接定位到AutowiredAnnotationBeanPostProcessor的postProcessPropertyValues方法，终于找到注入inject相关的痕迹啦！

metadata.inject(bean, beanName, pvs);

跳进InjectionMetadata继续跟进inject方法。

element.inject(target, beanName, pvs);

又跳回到了AutowiredAnnotationBeanPostProcessor，里面有两个内部类AutowiredFieldElement和AutowiredMethodElement都实现了inject注入方法。根据名字很容易想到，一个是Field的注入，一个是Method的注入。
两个注入都实现了DefaultListableBeanFactory的resolveDependency解析依赖方法。

Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);

终于到了本文最关键的位置啦！！！睁大眼睛！！！

resolveDependency方法中真正干活的是doResolveDependency方法。

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

注意了！里面有一段调用resolveMultipleBeans方法，如果解析到了多个匹配条件的Bean，就直接返回解析结果。

Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
    return multipleBeans;
}

解析结果又是什么呢？我们进去看看代码咋说的，也到了此次解剖的最后一步。

private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {

    Class<?> type = descriptor.getDependencyType();
    if (type.isArray()) {
        Class<?> componentType = type.getComponentType();
        ResolvableType resolvableType = descriptor.getResolvableType();
        Class<?> resolvedArrayType = resolvableType.resolve();
        if (resolvedArrayType != null && resolvedArrayType != type) {
            type = resolvedArrayType;
            componentType = resolvableType.getComponentType().resolve();
        }
        if (componentType == null) {
            return null;
        }
        Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
                new MultiElementDescriptor(descriptor));
        if (matchingBeans.isEmpty()) {
            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.getResolvableType().asCollection().resolveGeneric();
        if (elementType == null) {
            return null;
        }
        Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
                new MultiElementDescriptor(descriptor));
        if (matchingBeans.isEmpty()) {
            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) {
            ((List<?>) result).sort(adaptDependencyComparator(matchingBeans));
        }
        return result;
    }
    else if (Map.class == type) {
        ResolvableType mapType = descriptor.getResolvableType().asMap();
        Class<?> keyType = mapType.resolveGeneric(0);
        if (String.class != keyType) {
            return null;
        }
        Class<?> valueType = mapType.resolveGeneric(1);
        if (valueType == null) {
            return null;
        }
        Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
                new MultiElementDescriptor(descriptor));
        if (matchingBeans.isEmpty()) {
            return null;
        }
        if (autowiredBeanNames != null) {
            autowiredBeanNames.addAll(matchingBeans.keySet());
        }
        return matchingBeans;
    }
    else {
        return null;
    }
}

由上面代码得出结论：

首先判断注入的类型，如果是数组、Collection、Map，则注入的是元素数据，即查找与元素类型相同的Bean，注入到集合中。
强调下Map类型，Map的 key 为Bean的 name，value 为 与定义的元素类型相同的Bean。

到此，真相大白了！！！

总结

/**
 * '将所有类型为BasePrintService的Bean注入为一个List
 */
@Autowired
private List<BasePrintService> printServiceList;
/**
 * '将所有类型为BasePrintService的Bean注入为一个Map
 * key为Bean的name
 */
@Autowired
private Map<String, BasePrintService> printServiceMap;

如上述代码所示，Spring本身就支持，通过使用@Autowired注解，将所有相同类型（实现了同一个接口）的Bean，一次性注入到集合类型中。
有理有据，请大家放心使用~

Spring @Autowired 注入类的集合类型深度解剖

先看demo，放码过来

提问

那么，开始扒源码吧

总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

程序员

Java 杂谈

spring全家桶