1. 首页
  2. 文章中心
  3. spring

Spring之依赖注入源码解析

50 阅读 0 评论
我是靠谱客的博主 多情鸡，最近开发中收集的这篇文章主要介绍Spring之依赖注入源码解析，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

依赖注入底层原理流程图：Spring中Bean的依赖注入原理 | ProcessOn免费在线作图,在线流程图,在线思维导图 |

1、Spring中到底有几种依赖注入方式

手动注入和自动注入

1、手动注入

在XML中定义Bean时，就是手动注入，因为时我们手动给某个属性定值

<bean name="userService" class="com.luban.service.UserService">
	<property name="orderService" ref="orderService"/>
</bean>

上面这种底层是通过set方法进行注入

<bean name="userService" class="com.luban.service.UserService">
	<constructor-arg index="0" ref="orderService"/>
</bean>

上面这种底层是通过构造方法进行注入的

所以手动注入的底层也就是分为两种：set方法注入和构造方法注入

2、自动注入

自动注入分为两种：

1、XML的autowire自动注入

2、@Autowired注解的自动注入

XML的autowire自动注入

在XML中，我们可以在定义一个Bean时去指定这个Bean的自动注入模式：

1、byType

2、byName

3、constructor

4、default

5、no

比如：

<bean id="userService" class="com.luban.service.UserService" autowire="byType"/>

这么写，表示Spring会自动的给userService中所有的属性自动赋值，不需要这个属性上有@Autowired注解，但是需要这个属性有对应的set方法

在创建Bean的过程中，在填充属性时，Spring会去解析当前类，把当前类所有的方法都解析出来，Spring会去解析每个方法得到对应得PropertyDescriptor对象，PropertyDescriptor中有几个属性：

1、name：这个name并不是方法得名字，而是拿方法名字进行处理后的名字

a.如果方法名字以“get”开头，比如“getxxx”,那么name=xxx

。。。。

2、readMethodRef：表示get方法的Method对象的引用

3、readMethodName：表示get方法的名字

4、writeMethodRef：表示set方法的Method对象的引用

5、writeMethodName：表示set方法的名字

6、properTypeRef：表示有get方法，那么对应的就是返回值的类型，如果时set方法那么对一个的就是set方法中唯一参数的类型

所以，Spring在通过byName的自动填充属性时流程是:

1、找到所有set方法所对应的xxx部分的名字

2、根据xxx部分的名字去获取bean

Spring在通过byType的自动填充属性时流程是：

1、获取到set方法中的唯一参数的参数类型，并且根据该类型去容器中获取bean

2、如果找到多个，会报错

以上，分析了autowire的byType和byName情况，那么接下来分析constructor,constructor表示通过构造方法注入，其实这种情况就比较简单了，没有byType和byName那么复杂

如果是constructor，那么就可以不写set方法了，当某个bean是通过构造方法来注入时，spring利用构造方法的参数信息从Spring容器中去找bean，找到bean之后作为参数传给构造方法，从而实例化得到一个bean对象，并完成属性赋值

此处暂时不考虑多个构造方法，后续学习推断构造方法，，待补充。。。。。

其实构造方法注入相当于byType+byName，普通的byType是根据set方法中的参数类型去找bean，找到多个会报错，而constructor就是通过构造方法中的参数类型去找bean，如果找到多个会根据参数名确定

另外两个：

1、no，表示关闭antowire

2、default，表示默认值，我们一直演示的某个bean的autowire，而也可以直接在<beans>标签中设置autowire，如果设置了，那么<bean>标签中设置的autowire如果为default，那么则会用<beans>标签中设置的autowire。

可以发现XML中的自动注入是挺强大的，那么问题来了，为什么我们平时用的@Autowired注解呢？而没有用上问说的这种自动注入的方式？

@Autowired注解提供了与autowire相同的功能，但是拥有更细粒度的控制和更加广泛的适用性

那么XML的自动注入底层其实也就是：

1、set方法注入

2、构造方法注入

3、@Autowired注解的自动注入

上面说了@Autowired注解，是byType和buName的结合

@Autowired注解可以写在：

1、属性上：先根据属性类型去找Bean，如果找到多个再根据属性名确定一个

2、构造方法上：先根据方法参数类型去找Bean，如果找到对各再根据参数名确定一个

3、set方法上：先根据方法参数类型去找Bean，如果找到多个再根据参数名确定一个

4、寻找注入点

在创建一个Bean的过程中，Spring会利用AutowiredAnnotationBeanPostProcessor的postProcessMergedBeanDefinition()找出注入点并缓存，找到注入点的流程为：

1、遍历当前类的所有属性字段Field

2、查看字段是否存在@Autowired、@Value、@Inject中的其中任意一个，存在则认为该字段是一个注入点

3、如果字段是static的，则不进行注入

4、获取@Autowired中的required属性的值

5、将字段信息构造成一个AntowiredFieldElement对象，作为一个注入点对象添加到currElements集合中

6、遍历当前类的所有方法Method

7、判断当前Method是否是桥接方法，如果是找到原方法

8、查看方法上是否存在@Autowired、@Value、@Inject中的其中任意一个，存在则认为该方法是一个注入点

9、如果方法是static的，则不进行注入

10、获取@Autowired中的required属性的值

11、将方法信息构造成一个AntowiredFieldElement对象，作为一个注入点对象添加到currElements集合中

12、遍历完当前类的字段和方法后，将遍历父类的，知道没有父类

13、最后将currElement集合封装成一个InjectionMetadata对象，作为当前Bean对于的注入点集合对象，并缓存

static的字段或方法为什么不支持

@Component
@Scope("prototype")
public class OrderService {


}
@Component
@Scope("prototype")
public class UserService  {

	@Autowired
	private static OrderService orderService;

	public void test() {
		System.out.println("test123");
	}

}

看上面代码，UserService和OrderService都是原型Bean，假设Spring支持static字段进行自动注入，那么现在调用两次

  1. UserService userService1 = context.getBean("userService")
  2. UserService userService2 = context.getBean("userService")

问此时，userService1的orderService值是什么？还是它自己注入的值吗？

答案是不是，一旦userService2 创建好了之后，static orderService字段的值就发生了修改了，从而出现bug。

桥接方法

public interface UserInterface<T> {
	void setOrderService(T t);
}
@Component
public class UserService implements UserInterface<OrderService> {

	private OrderService orderService;

	@Override
	@Autowired
	public void setOrderService(OrderService orderService) {
		this.orderService = orderService;
	}

	public void test() {
		System.out.println("test123");
	}

}

一个看到在UserService的字节码中有两个setOrderService方法：

  1. public setOrderService(Lcom/zhouyu/service/OrderService;)V
  2. public synthetic bridge setOrderService(Ljava/lang/Object;)V

并且都是存在@Autowired注解

所以在Spring中需要处理这种情况，当遍历到桥接方法时，得找到原方法

5、注入点进行注入

Spring在AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法中，会遍历所找到的注入点依次进行注入

字段注入

1、遍历所有的AutowiredFieldElement对象

2、将对应的字段封装为DependencyDescriptor对象

3、调用BeanFactory的resolveDependency()方法，传入DependencyDescriptor对象，进行依赖查找，找到当前字段所匹配的Bean对象

4、将DependencyDescriptor对象和所找到的结果对象beanName封装成一个ShortcutDependencyDescriptor对象作为缓存，比如如果当前Bean是原型Bean，那么下次再来创建该Bean时，就可以直接拿缓存的结果对象beanName去BeanFactory中去那bean对象了，不用再次进行查找了

5、利用反射将结果对象赋值给字段

Set方法注入

  1. 遍历所有的AutowiredMethodElement对象
  2. 遍历将对应的方法的参数，将每个参数封装成MethodParameter对象
  1. 将MethodParameter对象封装为DependencyDescriptor对象
  2. 调用BeanFactory的resolveDependency()方法，传入DependencyDescriptor对象，进行依赖查找，找到当前方法参数所匹配的Bean对象。
  1. 将DependencyDescriptor对象和所找到的结果对象beanName封装成一个ShortcutDependencyDescriptor对象作为缓存，比如如果当前Bean是原型Bean，那么下次再来创建该Bean时，就可以直接拿缓存的结果对象beanName去BeanFactory中去那bean对象了，不用再次进行查找了
  2. 利用反射将找到的所有结果对象传给当前方法，并执行。

DefaultListtableBeanFactory中resolveDependency()方法的具体实现，流程图：

Spring中根据Type找Bean的流程 | ProcessOn免费在线作图,在线流程图,在线思维导图 |

2、findAntowireCandidates()实现

根据类型找beanName的底层流程：根据类型找beanName的底层流程 | ProcessOn免费在线作图,在线流程图,在线思维导图 |

对应执行流程图为：依赖注入流程 | ProcessOn免费在线作图,在线流程图,在线思维导图 |

  1. 找出BeanFactory中类型为type的所有的Bean的名字，注意是名字，而不是Bean对象，因为我们可以根据BeanDefinition就能判断和当前type是不是匹配，不用生成Bean对象
  2. 把resolvableDependencies中key为type的对象找出来并添加到result中
  1. 遍历根据type找出的beanName，判断当前beanName对应的Bean是不是能够被自动注入
  2. 先判断beanName对应的BeanDefinition中的autowireCandidate属性，如果为false，表示不能用来进行自动注入，如果为true则继续进行判断
  1. 判断当前type是不是泛型，如果是泛型是会把容器中所有的beanName找出来的，如果是这种情况，那么在这一步中就要获取到泛型的真正类型，然后进行匹配，如果当前beanName和当前泛型对应的真实类型匹配，那么则继续判断
  2. 如果当前DependencyDescriptor上存在@Qualifier注解，那么则要判断当前beanName上是否定义了Qualifier，并且是否和当前DependencyDescriptor上的Qualifier相等，相等则匹配
  1. 经过上述验证之后，当前beanName才能成为一个可注入的，添加到result中

3、关于依赖注入中泛型注入的实现

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;
}

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

4、@Qualifier的使用

定义两个注解：

@Target({ElementType.TYPE, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier("random")
public @interface Random {
}
@Target({ElementType.TYPE, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier("roundRobin")
public @interface RoundRobin {
}

定义一个接口和两个实现类，表示负载均衡：

public interface LoadBalance {
	String select();
}

@Component
@Random
public class RandomStrategy implements LoadBalance {

	@Override
	public String select() {
		return null;
	}
}

@Component
@RoundRobin
public class RoundRobinStrategy implements LoadBalance {

	@Override
	public String select() {
		return null;
	}
}

使用：

@Component
public class UserService  {

	@Autowired
	@RoundRobin
	private LoadBalance loadBalance;

	public void test() {
		System.out.println(loadBalance);
	}

}

5、@Resource

@Resource注解底层工作流程图：

@Resource注解底层工作原理 | ProcessOn免费在线作图,在线流程图,在线思维导图 |

6、@Autowired和@Resource的区别

@Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是javax.annotation.Resource，需要导入，但是Spring支持该注解的注入。

1、共同点

两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。

2、不同点

（1）@Autowired

@Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入

@Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false。如果我们想使用按照名称（byName）来装配，可以结合@Qualifier注解一起使用。(通过类型匹配找到多个candidate,在没有@Qualifier、@Primary注解的情况下，会使用对象名作为最后的fallback匹配)

（2）@Resource

@Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。@Resource有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略。

  • @Autowired默认按byType自动装配，而@Resource默认byName自动装配。
  • @Autowired只包含一个参数：required，表示是否开启自动准入，默认是true。而@Resource包含七个参数，其中最重要的两个参数是：name 和 type。
  • @Autowired如果要使用byName，需要使用@Qualifier一起配合。而@Resource如果指定了name，则用byName自动装配，如果指定了type，则用byType自动装配。
  • @Autowired能够用在：构造器、方法、参数、成员变量和注解上，而@Resource能用在：类、成员变量和方法上。
  • @Autowired是spring定义的注解，而@Resource是JSR-250定义的注解。

最后

以上就是多情鸡为你收集整理的Spring之依赖注入源码解析的全部内容，希望文章能够帮你解决Spring之依赖注入源码解析所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(33)

相关文章

spring validation的使用详解spring validation使用文档
spring validation的使用详解spring validation使用文档
准备依赖注入
准备依赖注入
Spring源码深度解析：十、bean的属性注入④ - populateBean一、前言二、属性填充入口- populateBean三、populateBean - 概述四、populateBean - 详解五、关于自动装配六、总结
Spring源码深度解析：十、bean的属性注入④ - populateBean一、前言二、属性填充入口- populateBean三、populateBean - 概述四、populateBean - 详解五、关于自动装配六、总结
Spring之依赖注入源码解析（上）一、Spring中到底有几种依赖注入的方式？二、寻找注入点三、注入点进行注入
Spring之依赖注入源码解析（上）一、Spring中到底有几种依赖注入的方式？二、寻找注入点三、注入点进行注入
Spring之依赖注入源码解析
Spring之依赖注入源码解析
全网最细致的spring源码分析（七）：属性注入
全网最细致的spring源码分析（七）：属性注入
Spring源码之bean的销毁registerDisposableBeanIfNecessary方法解读1. 前言2. registerDisposableBeanIfNecessary() 方法概览3. registerDisposableBeanIfNecessary() 方法小结4. Spring 注册关闭钩子 ShutdownHook5. 小结
Spring源码之bean的销毁registerDisposableBeanIfNecessary方法解读1. 前言2. registerDisposableBeanIfNecessary() 方法概览3. registerDisposableBeanIfNecessary() 方法小结4. Spring 注册关闭钩子 ShutdownHook5. 小结
认识配置中心
认识配置中心

评论列表共有 0 条评论

立即
投稿
返回
顶部