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

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
 */
@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());
    }
}
复制代码

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

@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，一次性注入到集合类型中。
有理有据，请大家 放心 使用~

---

分享自我的简书 HelloLittleRain（链接戳我）

转载于:https://juejin.im/post/5c491edfe51d4506d613c781