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