【Spring】Spring之依赖注入源码解析
1 Spring注入方式
1.1 手动注入
xml中定义Bean，程序员手动给某个属性赋值。
- set方式注入
<bean name="userService" class="com.firechou.service.UserService">
<property name="orderService" ref="orderService"/>
</bean>
- 构造方法注入
<bean name="userService" class="com.firechou.service.UserService">
<constructor-arg index="0" ref="orderService"/>
</bean>
1.2 自动注入
1.2.1 XML的autowire自动注入
<bean id="userService" class="com.firechou.service.UserService" autowire="byType"/>
Spring会自动的给userService中所有的属性自动赋值（不需要这个属性上有@Autowired注解，但需要这个属性有对应的set方法）；
XML的自动注入底层其实也就是set方法注入和构造方法注入；
Bean的自动注入模式autowire：
- byType
获取到set方法中的唯一参数的参数类型，并且根据该类型去容器中获取bean，如果找到多个，会报错。
- byName
找到所有set方法所对应的XXX部分的名字，根据XXX部分的名字去获取bean。
- constructor
通过构造方法注入，可以不写set方法；
如果存在多个构造方法，则通过构造方法推断来选择某个构造方法；
Spring利用构造方法的参数信息从Spring容器中去找Bean，找到Bean之后作为参数传给构造方法，从而实例化得到一个bean对象，并完成属性赋值（属性赋值的代码得程序员来写）；
- default
- no
关闭autowire
PropertyDescriptor：
创建Bean的过程中，填充属性时，Spring会去解析当前类，解析类中每个方法得到对应的PropertyDescriptor对象，PropertyDescriptor中有几个属性：
- name：这个name并不是方法的名字，而是拿方法名字进过处理后的名字
- 如果方法名字以“get”开头，比如“getXXX”，那么name=XXX
- 如果方法名字以“is”开头，比如“isXXX”，那么name=XXX
- 如果方法名字以“set”开头，比如“setXXX”，那么name=XXX
- readMethodRef：表示get方法的Method对象的引用
- readMethodName：表示get方法的名字
- writeMethodRef：表示set方法的Method对象的引用
- writeMethodName：表示set方法的名字
- propertyTypeRef：如果有get方法那么对应的就是返回值的类型，如果是set方法那么对应的就是set方法中唯一参数的类型
什么是set和get方法：
- get方法定义
方法参数个数为0个，并且方法名字以"get"开头，或者方法名字以"is"开头并且方法的返回类型为boolean
- set方法定义
方法参数个数为1个，并且方法名字以"set"开头并且方法返回类型为void
1.2.2 @Autowired注解的自动注入
@Autowired注解相当于XML中的autowire属性的注解方式的替代；
@Autowired注解提供了与XML中autowire相同的功能，但是拥有更细粒度的控制和更广泛的适用性；
XML中的autowire控制的是整个bean的所有属性，而@Autowired注解是直接写在某个属性、某个set方法、某个构造方法上的；
如果一个类有多个构造方法，那么如果用XML的autowire=constructor，无法控制到底用哪个构造方法，可以用@Autowired注解来直接指定想用哪个构造方法；
@Autowired注解还可以控制，哪些属性想被自动注入，哪些属性不想，这也是细粒度的控制；
@Autowired无法区分byType和byName，@Autowired是先byType，如果找到多个则byName；
@Autowired注解可以写在：
- 属性上：先根据属性类型去找Bean，如果找到多个再根据属性名确定一个
- 构造方法上：先根据方法参数类型去找Bean，如果找到多个再根据参数名确定一个
- set方法上：先根据方法参数类型去找Bean，如果找到多个再根据参数名确定一个
2 寻找注入点
在创建一个Bean的过程中，Spring会利用AutowiredAnnotationBeanPostProcessor的**postProcessMergedBeanDefinition()**找出注入点并缓存。
找注入点的流程为：
- 遍历当前类的所有的属性字段Field
- 查看字段上是否存在@Autowired、@Value、@Inject中的其中任意一个，存在则认为该字段是一个注入点
- 如果字段是static的，则不进行注入
- 获取@Autowired中的required属性的值
- 将字段信息构造成一个AutowiredFieldElement对象，作为一个注入点对象添加到currElements集合中。
- 遍历当前类的所有方法Method
- 判断当前Method是否是桥接方法，如果是找到原方法
- 查看方法上是否存在@Autowired、@Value、@Inject中的其中任意一个，存在则认为该方法是一个注入点
- 如果方法是static的，则不进行注入
- 获取@Autowired中的required属性的值
- 将方法信息构造成一个AutowiredMethodElement对象，作为一个注入点对象添加到currElements集合中
- 遍历完当前类的字段和方法后，将遍历父类的，直到没有父类
- 最后将currElements集合封装成一个InjectionMetadata对象，作为当前Bean对于的注入点集合对象，并缓存
3 注入点进行注入
Spring在AutowiredAnnotationBeanPostProcessor的**postProcessProperties()**方法中，会遍历所找到的注入点依次进行注入。
字段注入：
- 遍历所有的AutowiredFieldElement对象。
- 将对应的字段封装为DependencyDescriptor对象。
- 调用BeanFactory的resolveDependency()方法，传入DependencyDescriptor对象，进行依赖查找，找到当前字段所匹配的Bean对象。
- 将DependencyDescriptor对象和所找到的结果对象beanName封装成一个ShortcutDependencyDescriptor对象作为缓存，比如如果当前Bean是原型Bean，那么下次再来创建该Bean时，就可以直接拿缓存的结果对象beanName去BeanFactory中去那bean对象了，不用再次进行查找了
- 利用反射将结果对象赋值给字段。
Set方法注入：
- 遍历所有的AutowiredMethodElement对象
- 遍历将对应的方法的参数，将每个参数封装成MethodParameter对象
- 将MethodParameter对象封装为DependencyDescriptor对象
- 调用BeanFactory的resolveDependency()方法，传入DependencyDescriptor对象，进行依赖查找，找到当前方法参数所匹配的Bean对象。
- 将DependencyDescriptor对象和所找到的结果对象beanName封装成一个ShortcutDependencyDescriptor对象作为缓存，比如如果当前Bean是原型Bean，那么下次再来创建该Bean时，就可以直接拿缓存的结果对象beanName去BeanFactory中去那bean对象了，不用再次进行查找了
- 利用反射将找到的所有结果对象传给当前方法，并执行。
4 获取Bean对象
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
// 根据DependencyDescriptor依赖描述从BeanFactory中找出对应的唯一的一个Bean对象。
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
}
}
resolveDependency()
- 判断descriptor.getDependencyType()
- 如果是Optional.class，返回包装成Optional的对象
- ObjectFactory或ObjectProvider，返回DependencyObjectProvider对象
- 如果是
javax.inject.Provider类对象，则返回Jsr330Provider对象 - 如果依赖描述上有@Lazy注解，那么会生成一个代理对象然后返回，那么在调用代理对象中的方法时调用
doResolveDependency(descriptor)。或这，直接生成一个ObjectFactory对象，在调用ObjectFactory的getObject方法时调用调用doResolveDependency(descriptor)
- doResolveDependency()方法
- 是否存在@Value注解，如果存在，获取并解析descriptor上的@Value注解，进行解析并返回
- 如果不存在@Value注解，判断descriptor的类型
- 如果是Map，直接返回map
- 如果是Collection，则会调用方法findAutowireCandidates(beanName, type, descriptor)，该方法返回一个Map，表示会根据type去找bean，Map的key为beanName，Map的value为对象（注意可能是bean对象，也可能是某个bean的class对象，因为该方法只负责根据类型找到对应的bean，如果该bean还没有实例化，那么该方法不负责去实例化，只返回该Bean对应的Class对象，表示这个Bean也是结果之一）
- 根据type没有找到Bean，是isRequired则报错，不是isRequired则返回null
- 根据type找到了Bean，如果只有一个Bean，就直接返回该bean，如果是Class对象，则调用getBean生成该bean对象
- 根据type找打了Bean，如果有多个，从多个Bean中选择被@Primary标注了的Bean，如果有多个@Primary会报错。如果没有@Primary，那么则看Bean上是否通过@Priority定义了优先级，如果定义了则获取优先级最高的Bean。如果没有优先级，那么则使用descriptor.getDependencyName()来确定一个唯一的Bean
- 是否找出了唯一的Bean，没有则并且isRequired则报错，不是isRequired则返回null
- 找到了唯一的Bean，也会判断是否是Class对象，如果是，则调用getBean方法生成Bean对象，然后返回
findAutowireCandidates()
根据类型找beanName。
- 找出BeanFactory中类型为type的所有的Bean的名字，注意是名字，而不是Bean对象，因为我们可以根据BeanDefinition就能判断和当前type是不是匹配，不用生成Bean对象
- 把resolvableDependencies中key为type的对象找出来并添加到result中
- 遍历根据type找出的beanName，判断当前beanName对应的Bean是不是能够被自动注入
- 先判断beanName对应的BeanDefinition中的autowireCandidate属性，如果为false，表示不能用来进行自动注入，如果为true则继续进行判断
- 判断当前type是不是泛型，如果是泛型是会把容器中所有的beanName找出来的，如果是这种情况，那么在这一步中就要获取到泛型的真正类型，然后进行匹配，如果当前beanName和当前泛型对应的真实类型匹配，那么则继续判断
- 如果当前DependencyDescriptor上存在@Qualifier注解，那么则要判断当前beanName上是否定义了Qualifier，并且是否和当前DependencyDescriptor上的Qualifier相等，相等则匹配
- 经过上述验证之后，当前beanName才能成为一个可注入的，添加到result中
依赖注入中泛型的实现
java中的泛型：java.lang.reflect.Type通过反射获取字段类型，分为：
- raw types：也就是普通Class
- parameterized types：对应ParameterizedType接口，泛型类型
- array types：对应GenericArrayType，泛型数组
- type variables：对应TypeVariable接口，表示类型变量，也就是所定义的泛型，比如T、K
- primitive types：基本类型，int、boolean
示例：
public class ParameterizedTypeTest<T> {
private int i;
private Integer it;
private int[] iarray;
private List list;
private List<String> slist;
private List<T> tlist;
private T t;
private T[] tarray;
public static void main(String[] args) throws NoSuchFieldException {
test(ParameterizedTypeTest.class.getDeclaredField("i"));
System.out.println("=======");
test(ParameterizedTypeTest.class.getDeclaredField("it"));
System.out.println("=======");
test(ParameterizedTypeTest.class.getDeclaredField("iarray"));
System.out.println("=======");
test(ParameterizedTypeTest.class.getDeclaredField("list"));
System.out.println("=======");
test(ParameterizedTypeTest.class.getDeclaredField("slist"));
System.out.println("=======");
test(ParameterizedTypeTest.class.getDeclaredField("tlist"));
System.out.println("=======");
test(ParameterizedTypeTest.class.getDeclaredField("t"));
System.out.println("=======");
test(ParameterizedTypeTest.class.getDeclaredField("tarray"));
}
public static void test(Field field) {
if (field.getType().isPrimitive()) {
System.out.println(field.getName() + "是基本数据类型");
} else {
System.out.println(field.getName() + "不是基本数据类型");
}
if (field.getGenericType() instanceof ParameterizedType) {
System.out.println(field.getName() + "是泛型类型");
} else {
System.out.println(field.getName() + "不是泛型类型");
}
if (field.getType().isArray()) {
System.out.println(field.getName() + "是普通数组");
} else {
System.out.println(field.getName() + "不是普通数组");
}
if (field.getGenericType() instanceof GenericArrayType) {
System.out.println(field.getName() + "是泛型数组");
} else {
System.out.println(field.getName() + "不是泛型数组");
}
if (field.getGenericType() instanceof TypeVariable) {
System.out.println(field.getName() + "是泛型变量");
} else {
System.out.println(field.getName() + "不是泛型变量");
}
}
}
结果：
i是基本数据类型
i不是泛型类型
i不是普通数组
i不是泛型数组
i不是泛型变量
=======
it不是基本数据类型
it不是泛型类型
it不是普通数组
it不是泛型数组
it不是泛型变量
=======
iarray不是基本数据类型
iarray不是泛型类型
iarray是普通数组
iarray不是泛型数组
iarray不是泛型变量
=======
list不是基本数据类型
list不是泛型类型
list不是普通数组
list不是泛型数组
list不是泛型变量
=======
slist不是基本数据类型
slist是泛型类型
slist不是普通数组
slist不是泛型数组
slist不是泛型变量
=======
tlist不是基本数据类型
tlist是泛型类型
tlist不是普通数组
tlist不是泛型数组
tlist不是泛型变量
=======
t不是基本数据类型
t不是泛型类型
t不是普通数组
t不是泛型数组
t是泛型变量
=======
tarray不是基本数据类型
tarray不是泛型类型
tarray是普通数组
tarray是泛型数组
tarray不是泛型变量
Spring中注入点为泛型时：
@Component
public class UserService extends BaseService<OrderService, StockService> {
public void test() {
System.out.println(o);
}
}
public class BaseService<O, S> {
@Autowired
protected O o;
@Autowired
protected S s;
}
- Spring扫描时发现UserService是一个Bean
- 那就取出注入点，也就是BaseService中的两个属性o、s
- 接下来需要按注入点类型进行注入，但是o和s都是泛型，所以Spring需要确定o和s的具体类型
- 因为当前正在创建的是UserService的Bean，所以可以通过
userService.getClass().getGenericSuperclass().getTypeName()获取到具体的泛型信息，比如com.firechou.service.BaseService - 然后再拿到UserService的父类BaseService的泛型变量：
for (TypeVariable> typeParameter : userService.getClass().getSuperclass().getTypeParameters()) {
System._out_.println(typeParameter.getName());
} - 通过上面两段代码，就能知道，o对应的具体就是OrderService，s对应的具体类型就是StockService
- 然后再调用
oField.getGenericType()就知道当前field使用的是哪个泛型，就能知道具体类型了
@Resource注解
- 寻找@Resource注入点，可能在方法或则属性上
- 找到后进行注入，先判断BeanFactory中是否存在注入点名字对应的Bean
- 如果不存在，判断@Resource注解中是否指定了name属性
- 没有指定则会和@Autowired的工作原理一致，先byType再byName
- 指定了则会走A逻辑
- 如果存在，走A逻辑
- A逻辑：则只会根据name或注入点名字（属性名字或方法参数名字）去找bean，如果找不到对应名字的Bean是会报错的
- 如果不存在，判断@Resource注解中是否指定了name属性