Spring是你可靠的大管家。

先看demo，放码过来

1. 有一个客户实体类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 */}

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

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

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

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

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

/** * 测试打印类 * * @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又是如何实现的呢？为神马？？？

那么，开始扒源码吧

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

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

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

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

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

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

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

调用了AbstractBeanFactory的doGetBean方法

@Overridepublic 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 */@Autowiredprivate List<BasePrintService> printServiceList;/** * '将所有类型为BasePrintService的Bean注入为一个Map * key为Bean的name */@Autowiredprivate Map<String, BasePrintService> printServiceMap;

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