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并不是方法的名字，而是拿方法名字进过处理后的名字
1. 如果方法名字以“get”开头，比如“getXXX”，那么name=XXX
2. 如果方法名字以“is”开头，比如“isXXX”，那么name=XXX
3. 如果方法名字以“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 AbstractAutowireCapableBeanFactoryimplements 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()
1. 如果是Optional.class，返回包装成Optional的对象
2. ObjectFactory或ObjectProvider，返回DependencyObjectProvider对象
3. 如果是javax.inject.Provider类对象，则返回Jsr330Provider对象
4. 如果依赖描述上有@Lazy注解，那么会生成一个代理对象然后返回，那么在调用代理对象中的方法时调用doResolveDependency(descriptor)。或这，直接生成一个ObjectFactory对象，在调用ObjectFactory的getObject方法时调用调用doResolveDependency(descriptor)
doResolveDependency()方法
1. 是否存在@Value注解，如果存在，获取并解析descriptor上的@Value注解，进行解析并返回
2. 如果不存在@Value注解，判断descriptor的类型
  1. 如果是Map，直接返回map
  2. 如果是Collection，则会调用方法findAutowireCandidates(beanName, type, descriptor)，该方法返回一个Map，表示会根据type去找bean，Map的key为beanName，Map的value为对象（注意可能是bean对象，也可能是某个bean的class对象，因为该方法只负责根据类型找到对应的bean，如果该bean还没有实例化，那么该方法不负责去实例化，只返回该Bean对应的Class对象，表示这个Bean也是结果之一）
    1. 根据type没有找到Bean，是isRequired则报错，不是isRequired则返回null
    2. 根据type找到了Bean，如果只有一个Bean，就直接返回该bean，如果是Class对象，则调用getBean生成该bean对象
    3. 根据type找打了Bean，如果有多个，从多个Bean中选择被@Primary标注了的Bean，如果有多个@Primary会报错。如果没有@Primary，那么则看Bean上是否通过@Priority定义了优先级，如果定义了则获取优先级最高的Bean。如果没有优先级，那么则使用descriptor.getDependencyName()来确定一个唯一的Bean
    4. 是否找出了唯一的Bean，没有则并且isRequired则报错，不是isRequired则返回null
    5. 找到了唯一的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> {@Autowiredprotected O o;@Autowiredprotected S s;
}

Spring扫描时发现UserService是一个Bean
那就取出注入点，也就是BaseService中的两个属性o、s
接下来需要按注入点类型进行注入，但是o和s都是泛型，所以Spring需要确定o和s的具体类型
因为当前正在创建的是UserService的Bean，所以可以通过userService.getClass().getGenericSuperclass().getTypeName()获取到具体的泛型信息，比如com.firechou.service.BaseService<com.firechou.service.OrderService, com.firechou.service.StockService>
然后再拿到UserService的父类BaseService的泛型变量： for (TypeVariable<? extends Class<?>> typeParameter : userService.getClass().getSuperclass().getTypeParameters()) {<br /> System._out_.println(typeParameter.getName());<br />}
通过上面两段代码，就能知道，o对应的具体就是OrderService，s对应的具体类型就是StockService
然后再调用oField.getGenericType()就知道当前field使用的是哪个泛型，就能知道具体类型了

@Resource注解

寻找@Resource注入点，可能在方法或则属性上
找到后进行注入，先判断BeanFactory中是否存在注入点名字对应的Bean
1. 如果不存在，判断@Resource注解中是否指定了name属性
  1. 没有指定则会和@Autowired的工作原理一致，先byType再byName
  2. 指定了则会走A逻辑
2. 如果存在，走A逻辑
3. A逻辑：则只会根据name或注入点名字（属性名字或方法参数名字）去找bean，如果找不到对应名字的Bean是会报错的