前言
阅读准备
由于Spring源码分析是一个前后联系比较强的过程,而且这边分析,也是按照代码顺序讲解的,所以不了解前置知识的情况下,大概率没办法看懂当前的内容。所以,特别推荐看看我前面的文章(自上而下次序):
- Spring底层核心原理解析【学习难度:★★☆☆☆】
- 手写简易Spring容器过程分析【学习难度:★★☆☆☆】
- Spring之底层架构核心概念解析【学习难度:★★★☆☆,重要程度:★★★★★】
- Bean的生命周期流程图【学习难度:☆☆☆☆☆,重要程度:★★★★★】
- Spring之Bean的生命周期源码解析——阶段一(扫描生成BeanDefinition)【学习难度:★★☆☆☆,重要程度:★★★☆☆】
- Spring之Bean的生命周期源码解析——阶段二(IOC之实例化)【学习难度:★★★★★,重要程度:★★★☆☆】
(PS:特别是《Bean的生命周期流程图》,帮大家【开天眼】,先了解下流程。毕竟【通过业务了解代码,远比通过代码了解业务简单的多】!!!!)
(PS:特别是《Bean的生命周期流程图》,帮大家【开天眼】,先了解下流程。毕竟【通过业务了解代码,远比通过代码了解业务简单的多】!!!!)
(PS:特别是《Bean的生命周期流程图》,帮大家【开天眼】,先了解下流程。毕竟【通过业务了解代码,远比通过代码了解业务简单的多】!!!!)
阅读指引
我们在上一节课已经说到过了,本次Spring源码剖析的总入口是new AnnotationConfigApplicationContext("org.tuling.spring");
,这里就不再重复解释了。本节课要说的内容,是SpringIOC的属性填充/依赖注入,我们这里直接给到入口吧,调用链如下:(调用链比较深,不要纠结细枝末节)
- AbstractApplicationContext#refresh:刷新方法,不用在意
- AbstractApplicationContext#finishBeanFactoryInitialization:在这里实例化所有剩余的(非lazy-init)单例
- DefaultListableBeanFactory#preInstantiateSingletons:在这里实例化所有剩余的(非lazy-init)单例(上面的方法,核心干活的方法就是这里)
- DefaultListableBeanFactory#getBean:获取Bean的方法
- AbstractBeanFactory#doGetBean:返回指定bean的一个实例,它可以是共享的,也可以是独立的
- 上面这个
AbstractBeanFactory#doGetBean
里面的一段局部代码写的回调方法,如下:
// 如果是单例创建bean实例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
- AbstractAutowireCapableBeanFactory#createBean:这个类的中心方法:创建一个bean实例,填充bean实例,应用后处理器,等等。
- AbstractAutowireCapableBeanFactory#doCreateBean:【实例化】及后面声明周期调用地方。
- 【入口一】:AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors:应用合并BeanDefinition后置处理器给给定的BeanDefinition。
- 【入口二】AbstractAutowireCapableBeanFactory#populateBean:使用来自bean定义的属性值在给定的BeanWrapper中填充bean实例。
如上面的调用链所示,最后两个方法,才是我们本次要研究的核心方法。为什么这里会说有两个入口呢?主要是,本章的【属性填充/依赖注入】将分为两个部分来解析。【入口一】对应的是【第一部分:寻找注入点】;【入口二】对应的是【第二部分:属性填充及填充后】
阅读建议
- 看源码,切记纠结细枝末节,不然很容易陷进去。正常来说,看主要流程就好了
- 遇到不懂的,多看看类注释或者方法注释。Spring这种优秀源码,注释真的非常到位
- 如果你是idea用户,多用F11的书签功能。
- Ctrl + F11 选中文件 / 文件夹,使用助记符设定 / 取消书签 (必备)
- Shift + F11 弹出书签显示层 (必备)
- Ctrl +1,2,3…9 定位到对应数值的书签位置 (必备)
阅读导航
系列上一篇文章:《【Spring专题】Spring之Bean的生命周期源码解析——阶段二(一)(IOC之实例化)》
系列下一篇文章:《【Spring专题】Spring之Bean的生命周期源码解析——阶段二(三)(属性填充之循环依赖底层原理解析)》
课程内容
一、依赖注入方式(前置知识)
在Spring中,属性注入的方式分为两种,分别是:【手动注入】和【自动注入】。
1.1 手动注入
在XML中定义Bean时,就是手动注入,因为是程序员手动给某个属性指定了值。如下:
<bean name="userService" class="com.luban.service.UserService">
<property name="orderService" ref="orderService"/>
</bean>
有经验的同学应该知道,上面这种底层是通过setXxx
方法进行注入的。另外,还有一种方式,是通过构造方法进行注入的,如下:
<bean name="userService" class="com.luban.service.UserService">
<constructor-arg index="0" ref="orderService"/>
</bean>
所以手动注入的底层也就是分为两种:【set方法注入】和【构造方法注入】。
1.2 自动注入
自动注入又分为两种:【XML的autowire自动注入】和【@Autowired注解的自动注入】。
1.2.1 XML的autowire自动注入
在XML中,我们可以在定义一个Bean时去指定这个Bean的自动注入模式,它有如下几种方式:
1.2.1.1 byType:按照类型进行注入
byType注入方式,底层是基于setXxx
方法实现的,所以setter方法不能少。这里说的类型是【入参】的类型。
Spring在通过byType的自动填充属性时流程是:
- 获取到set方法中的唯一参数的参数类型,并且根据该类型去容器中获取bean
- 如果找到多个,会报错
使用示例如下:
<bean id="userService" class="com.luban.service.UserService" autowire="byType"/>
public void setOrderService(OrderService orderService) {
this.orderService = orderService;
}
如上示例的类型,就是指入参orderService
的类型OrderService
1.2.1.2 byName:按照名称进行注入
byType注入方式,底层是基于setXxx
方法实现的,所以setter方法不能少。这里说的【名称】,是指setXxx
后面的Xxx
部分。
所以,Spring在通过byName的自动填充属性时流程是:
- 找到所有set方法所对应的Xxx部分的名字
- 根据Xxx部分的名字去获取bean
使用示例如下:
<bean id="userXmlBean" class="org.tuling.spring.xml.bean.UserXmlBean" autowire="byName"/>
<bean id="walletXmlBean" class="org.tuling.spring.xml.bean.WalletXmlBean"/>
如上,我们定义了userXmlBean
的自动注入类型是byName
,并且定义了一个名字叫walletXmlBean
的bean。
public class UserXmlBean {
private WalletXmlBean wallet;
public void printProperty() {
System.out.println(wallet);
}
public void setWalletXmlBean(WalletXmlBean param) {
this.wallet = param;
}
}
如上,我们定义了一个UserXmlBean
,他有成员变量WalletXmlBean wallet
。同时给他声明了一个成员方法printProperty()
用来打印它的成员属性的地址。
测试代码:
public class MyXmlApplicationContextTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
UserXmlBean userXmlBean = (UserXmlBean)context.getBean("userXmlBean");
userXmlBean.printProperty();
}
// 系统输出:
// org.tuling.spring.xml.bean.WalletXmlBean@1d16f93d
}
如上,UserXmlBean
的WalletXmlBean
类型的属性出现了2个名称,一个是成员变量wallet
,另一个是setter方法入参中的param
,但是一点都不妨碍我们byName
注入。因为,根据byName
的规则,寻找的是setXxx
后面的Xxx
部分。还不够信服是吗?我们改一下UserXmlBean
里面的setter方法,如下:
public void setWalletXmlBean123(WalletXmlBean param) {
this.wallet = param;
}
这个时候再去调用,输出null
。
1.2.1.3 constructor:按照构造方法进行注入
constructor表示通过构造方法注入,其实这种情况就比较简单了,没有byType和byName那么复杂。
如果是constructor,那么就可以不写set方法了,当某个bean是通过构造方法来注入时,spring利用构造方法的参数信息从Spring容器中去找bean,找到bean之后作为参数传给构造方法,从而实例化得到一个bean对象,并完成属性赋值(属性赋值的代码得程序员来写)。
(PS:我们这里先不考虑一个类有多个构造方法的情况,后面单独讲推断构造方法。我们这里只考虑只有一个有参构造方法。)
其实构造方法注入相当于byType+byName。Spring在通过byName的自动填充属性时流程是:
- 通过构造方法中的参数类型去找bean,如果对应的类型只有一个bean,那就是它了;
- 如果找到多个会根据参数名确定
- 如果最后根据参数名都无法确定,则报错
使用示例如下:
<bean id="userXmlBean" class="org.tuling.spring.xml.bean.UserXmlBean" autowire="constructor"/>
<bean id="walletXmlBean123" class="org.tuling.spring.xml.bean.WalletXmlBean"/>
<bean id="walletXmlBean" class="org.tuling.spring.xml.bean.WalletXmlBean"/>
bean示例:
public class UserXmlBean {
private WalletXmlBean wallet;
public void printProperty() {
System.out.println(wallet);
}
public UserXmlBean(WalletXmlBean walletXmlBean) {
this.wallet = walletXmlBean;
}
}
具体的调用跟错误方式这边就不介绍了,大家回头自己试试吧
1.2.1.4 其他
其他,诸如:
- default:表示默认值,我们一直演示的某个bean的autowire,而也可以直接在<beans>标签中设置autowire,如果设置了,那么<bean>标签中设置的autowire如果为default,那么则会用<beans>标签中设置的autowire
- no:表示关闭autowire,不自动注入
1.2.1.5 XML的autowire自动注入方式总结
那么XML的自动注入底层其实也就是:
- set方法注入
- 构造方法注入
1.2.2 @Autowired注解的自动注入
@Autowired注解,本质上也是byType和byName的结合。它是先byType,如果找到多个则byName。这个跟xml构造方式注入原理如出一辙。就是:
- 先根据类型去找bean,如果对应的类型只有一个bean,那就是它了;
- 如果找到多个会根据属性名确定
- 如果最后根据属性名都无法确定,则报错
@Autowired注解可以写在:
- 属性上:先根据属性类型去找Bean,如果找到多个再根据属性名确定一个(属性注入)
- 构造方法上:先根据方法参数类型去找Bean,如果找到多个再根据参数名确定一个(构造方法注入)
- set方法上:先根据方法参数类型去找Bean,如果找到多个再根据参数名确定一个(set方法注入)
1.2.3 自动注入总结
可以发现XML中的自动注入是挺强大的,那么问题来了,为什么我们平时都是用的@Autowired注解呢?而没有用上文说的这种自动注入方式呢?
其实啊,@Autowired注解相当于XML中的autowire属性的注解方式的替代。从本质上讲,@Autowired注解提供了与autowire相同的功能,但是拥有更细粒度的控制和更广泛的适用性。
XML中的autowire控制的是整个bean的所有属性,而@Autowired注解是直接写在某个属性、某个set方法、某个构造方法上的。
再举个例子,如果一个类有多个构造方法,那么如果用XML的autowire=constructor,你无法控制到底用哪个构造方法,而你可以用@Autowired注解来直接指定你想用哪个构造方法。
同时,用@Autowired注解,还可以控制,哪些属性想被自动注入,哪些属性不想,这也是细粒度的控制。
二、依赖注入过程
2.1 简单回顾
依赖注入的过程,大体上其实能分为以下三步的:【寻找注入点】、【填充属性】、【填充属性后】。但其实,【寻找注入点】这个过程,会在两个地方被调用。第一个就是箭头所向,【实例化】阶段【BeanDefinition后置处理】那个地方。怎么理解呢?因为,【寻找注入点】的实现类就是【BeanDefinition后置处理】中的一个。
上面说的概念多少有点绕。简单来说,【寻找注入点】就是寻找被@Autowird
、@Value
、@Inject
、@Resource
注解修饰的属性、方法等等;然后,【属性填充】的时候再来处理这些找到的注入点,将他们设置到对应Bean属性中。
2.2 概念回顾
在这个【实例化】过程中,涉及到了一些Spring底层设计的概念,我在上一个笔记里面有大概介绍过Spring底层概念的一些讲解,不记得的同学记得回去翻一翻。
主要涉及的概念有:
- BeanDefinition(设计图纸):BeanDefinition表示Bean定义,BeanDefinition中存在很多属性用来描述一个Bean的特征
-
MergedBeanDefinitionPostProcessor:合并BeanDefinition后置处理器。但这里其实主要说的是
AutowiredAnnotationBeanPostProcessor
跟CommonAnnotationBeanPostProcessor
。他俩有什么作用呢?前者是处理Spring内部定义的@Autowired
跟@Value
自动注入注解;后者是处理jdk定义的@Resource
注解。主要是用到了这个MergedBeanDefinitionPostProcessor
的postProcessMergedBeanDefinition
去完成【寻找注入点】的操作 -
InstantiationAwareBeanPostProcessor:感知实例化的Bean后置处理器。这个也是跟上面一样,其实主要说的也是
AutowiredAnnotationBeanPostProcessor
跟CommonAnnotationBeanPostProcessor
。这两个类也继承了InstantiationAwareBeanPostProcessor
,并且在里面的postProcessProperties
完成了对应注解【自动注入】的操作
CommonAnnotationBeanPostProcessor
接口定义如下:
/**
* 这个后置处理器通过继承InitDestroyAnnotationBeanPostProcessor和InstantiationAwareBeanPostProcessor注解,
* 获得了对@PostConstruct和@PreDestroy的支持。
* 另外,这个类的核心处理元素是@Resource注解
*/
public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
// 具体代码就不贴了。学到这里大家应该知道如何通过【接口】继承、实现来猜测类能力了吧
}
AutowiredAnnotationBeanPostProcessor
接口定义如下:
// 继承类跟CommonAnnotationBeanPostProcessor 如出一辙,唯一不同的是,继承了功能更强大的
// SmartInstantiationAwareBeanPostProcessor(InstantiationAwareBeanPostProcessor子类)
// 实现这个类,是为了实现里面的推断构造方法
public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor,
MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
2.3 核心方法讲解
本节【属性注入】,将会分两个部分来讲。第一部分是:【寻找注入点】;剩下的是第二部分。
先说第一部分,第一部分主要涉及【3个类,7个核心方法】。
第二部分,待定…
三、【寻找注入点】方法讲解
我在上面说过,【寻找注入点】其实是有两个地方会调用到的。一个是在【属性填充populateBean()
】之前的【合并BeanDefinitionapplyMergedBeanDefinitionPostProcessors()
】,另一个就是在【属性填充】里面了。(【寻找注入点】源码以AutowiredAnnotationBeanPostProcessor举例)
3.1 AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors:寻找注入点代码入口
全路径:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors
将MergedBeanDefinitionPostProcessors应用于指定的bean定义,调用它们的postProcessMergedBeanDefinition方法。
源码如下:
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {
processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
我们点开这个循环的类对象,找到他们的两个实现类:AutowiredAnnotationBeanPostProcessor
和CommonAnnotationBeanPostProcessor
。为了方便,我们这里就只举例AutowiredAnnotationBeanPostProcessor
,因为他俩实现方式基本雷同,只不过前者处理的Spring的注解,由Spring本家写的;后者处理的JDK的注解。
3.2 AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition
方法调用链:由3.2的applyMergedBeanDefinitionPostProcessors()调用进来
全路径:org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition
方法注释:对指定bean的给定合并bean定义进行后处理。
源码如下:
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
metadata.checkConfigMembers(beanDefinition);
}
方法解读:代码很简单,整个过程真正干活的其实是里面的findAutowiringMetadata()
方法
3.3 AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata:寻找注入点
方法调用链:由3.2的applyMergedBeanDefinitionPostProcessors()调用进来
全路径:org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata
方法注释:寻找注入点
** private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
// 设置缓存key
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// 先看缓存里面有没有
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
metadata = buildAutowiringMetadata(clazz);
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}**
方法解读:在这里,用到了一个缓存,说白了就是一个map,来判断是否已经【寻找过注入点】了,也是为了方便后续做注入。在这里,最核心的操作还是通过调用buildAutowiringMetadata
,构建了当前类的注入点信息,并且包装成了InjectionMetadata
。
*3.4 AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata:构建注入点
方法调用链:由3.3的findAutowiringMetadata()调用进来
全路径:org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata
方法注释:构建注入点
源码如下:
private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
// 第一步:判断当前类是否候选类(是否需要【寻找注入点】)
if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
return InjectionMetadata.EMPTY;
}
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
do {
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
// 第二步:利用反射,寻找【字段】上是否有【自动注入】的注解
ReflectionUtils.doWithLocalFields(targetClass, field -> {
MergedAnnotation<?> ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
boolean required = determineRequiredStatus(ann);
currElements.add(new AutowiredFieldElement(field, required));
}
});
// 第三步:利用反射,寻找【方法】上是否有【自动注入】的注解
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterCount() == 0) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation should only be used on methods with parameters: " +
method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
return InjectionMetadata.forElements(elements, clazz);
}
方法解读:上面的方法看似很长,但整体上就分为三个步骤而已,没什么特别难理解的地方。特别是,如果你如果看过我前面的【手写Spring-引导篇】的话。
第一个步骤,判断当前类是否候选类(是否需要【寻找注入点】)。说实在这里暂时不确定啥意思,看代码就是过滤java.
开头的类跟注解(百度了下,java.开头的一般是JDK开放的API,其中元注解就在里面声明,如:@Retention、@Target等)。所以我的理解是,这里的判断逻辑是让Spring的类,或者说我们自定义的类,可以使用JDK的【自动装配】注解,比如@Resource;但是JDK只能用JDK自己的【自动装配】注解。
第二个步骤:我们都知道,@Autowired
注解,可以修饰在字段和方法上的,第二个步骤就是处理【字段】类型的注解。
第三个步骤:处理【方法】类型的注解。
关于第二、三步的源码实现其实都一样,只不过处理对象不一样而已,所以这里就只拿处理【字段】的逻辑来讲讲了。即如下:
ReflectionUtils.doWithLocalFields(targetClass, field -> {
MergedAnnotation<?> ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
boolean required = determineRequiredStatus(ann);
currElements.add(new AutowiredFieldElement(field, required));
}
});
不过还是要先说一点。大家可能注意到了,这整个处理是在一个do-while
循环体里面完成的,为什么呢?其实这里的do-while
循环就是为了处理存在【继承关系的Bean】的注入而已。
3.5 ReflectionUtils#doWithLocalFields:利用反射遍历类上的【字段】
方法调用链:由3.4的buildAutowiringMetadata()调用进来
全路径:org.springframework.util.ReflectionUtils#doWithLocalFields
方法注释:对给定类中所有局部声明的字段调用给定的回调。
反射工具方法实现如下:
public static void doWithLocalFields(Class<?> clazz, FieldCallback fc) {
for (Field field : getDeclaredFields(clazz)) {
try {
fc.doWith(field);
}
catch (IllegalAccessException ex) {
throw new IllegalStateException("Not allowed to access field '" + field.getName() + "': " + ex);
}
}
}
(PS:这上边的代码,如果对函数式接口,或者说lambda表达式使用不清楚的可能看不懂,得赶紧去复习下了)
3.6 AutowiredAnnotationBeanPostProcessor#findAutowiredAnnotation:寻找字段上的自动装配注解
方法调用链:由3.5的doWithLocalFields()调用进来
全路径:org.springframework.util.ReflectionUtils#doWithLocalFields
方法注释:对给定类中所有局部声明的字段调用给定的回调。
再然后,就是在反射【回调函数】里面,调用findAutowiredAnnotation
判断当前字段、方法是否有【自动装配】的注解。如下:
@Nullable
private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
MergedAnnotations annotations = MergedAnnotations.from(ao);
for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
MergedAnnotation<?> annotation = annotations.get(type);
if (annotation.isPresent()) {
return annotation;
}
}
return null;
}
细心的朋友可能会问了, this.autowiredAnnotationTypes
的值是啥?是的,我知道是@Autowired
和@Value
注解,但是在哪里赋值呢?啊,这个目前不会讲到,这是在Spring容器启动的章节才会给大家讲。但是可以先告诉大家,这个是在AutowiredAnnotationBeanPostProcessor
的构造方法中初始化的。如下:
public AutowiredAnnotationBeanPostProcessor() {
this.autowiredAnnotationTypes.add(Autowired.class);
this.autowiredAnnotationTypes.add(Value.class);
try {
this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
3.7 Modifier.isStatic
方法调用链:由3.5的doWithLocalFields()调用进来
全路径:java.lang.reflect.Modifier#isStatic
方法注释:对给定类中所有局部声明的字段调用给定的回调。
然后,如果找到有被@Autowired和@Value注解的字段或者方法,还会判断该字段或者方法是否被static
修饰,即静态的。静态的就不处理了。源码如下:
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static methods: " + method);
}
return;
}
点解啊?道理很简单的,你从原型Bean考虑一下就知道了。我们知道静态的是属于类的,不是属于对象的,那如果你每次注入的时候还要处理静态,那不就重复覆盖了吗?举例:
@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字段进行自动注入,那么现在调用两次
UserService userService1 = context.getBean("userService")
UserService userService2 = context.getBean("userService")
问此时,userService1的orderService值是什么?还是它自己注入的值吗?答案是不是,一旦userService2 创建好了之后,static orderService字段的值就发生了修改了,从而出现bug。
3.8 剩余步骤
剩余步骤,干了三件事,如下:
- 设置
@Autowired(required = false)
这个属性 - 将得到构建点包装成
InjectionMetadata.InjectedElement
- 将得到的所有注入点,封装成
InjectionMetadata
,接着缓存起来
四、【寻找注入点】逻辑流程图
流程描述:
- 遍历当前类的所有的属性字段Field
- 查看字段上是否存在@Autowired、@Value、@Inject中的其中任意一个,存在则认为该字段是一个注入点
- 如果字段是static的,则不进行注入
- 获取@Autowired中的required属性的值
- 将字段信息构造成一个AutowiredFieldElement对象,作为一个注入点对象添加到currElements集合中。
- 遍历当前类的所有方法Method
- 判断当前Method是否是桥接方法,如果是找到原方法
- 查看方法上是否存在@Autowired、@Value、@Inject中的其中任意一个,存在则认为该方法是一个注入点
- 如果方法是static的,则不进行注入
- 获取@Autowired中的required属性的值
- 将方法信息构造成一个AutowiredMethodElement对象,作为一个注入点对象添加到currElements集合中。
- 遍历完当前类的字段和方法后,将遍历父类的,直到没有父类。
- 最后将currElements集合封装成一个InjectionMetadata对象,作为当前Bean对于的注入点集合对象,并缓存。
四点五、特别声明
兄弟们,提前声明一下,下面的内容个人感觉特别复杂,是我按照Spring源码阅读顺序以来,目前最复杂的一部分。不过也由于分了两个部分,层次感还是有的,所以大家如果是在没有继续看下去的欲望了,剩下的下次再看吧。[/狗头][/狗头]
所以,我想着,在后面的讲解中,换一种方式来写写。
- 首先,我会先给出流程图,并且按照树形结构的方式写
- 其次,我将按照源码调用次序,【自上而下、从左往右】的方式映射到树形结构上
- 最后到了这里,我感觉大家需要打开Spring源码,一边看文章,一边看源码的方式来阅读了
- 我并不会讲解所有的源码,只会将一些比较陌生、或者关键的源码点一下
五、【属性填充】逻辑流程图
整体源码逻辑流程图如下:(画的我吐血)
图片点开来很不清晰,建议大家:右键、新建窗口打开。 然后就可以放大观看了
六、【属性填充】方法讲解
我们在【阅读建议】中已经说过【入口二】是AbstractAutowireCapableBeanFactory#populateBean
。在这个方法,我们在上面属性流程图画的第一二层,讲的就是这个方法。
6.1 AbstractAutowireCapableBeanFactory#populateBean
全路径:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
方法解释:使用来自bean定义的属性值在给定的BeanWrapper中填充bean实例。
对应流程图:
源码如下:(标记了步骤一、二、三才是本章研究内容)
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 空判断,有属性,但是bean为空,则报错
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// 这个在之前的【实例化阶段】的【实例化后】讲过了,不在本次研究范围内
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
// 下面才是我们本节课要研究的起点
// 下面才是我们本节课要研究的起点
// 下面才是我们本节课要研究的起点
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 步骤一:
// 处理beanDefinition的autowire属性。比如@Bean标签就可以设置这个属性;xml也可以设置这个属性
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 步骤二:
// 处理@Autowired、@Value、@Resource等【自动注入】的属性填充(注意,之前是寻找注入点,这里才是真正赋值的地方)
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
// 依赖检查,【细枝末节】,不看了
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
// 步骤三:
// 处理BeanDefinition里面的propertyValues。比如:我们在操作beanDefinition的时候会修改;
// 或者,在第一步处理@Bean的autowire属性的时候,实际上也是把结果跟旧有BeanDefinition的propertyValues合并。
// 最后在这里处理注入操作
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
方法解读:方法看着很长,但其实逻辑还算是比较清晰的。只不过有点可惜的是,感觉代码风格突然变了,跟前面研究的方法明显出于不同之人。比如,在之前,populateBean()
里面德的【处理实例化后】阶段源码,会搞个resolveAfterInstantiation()
方法来封装起来;步骤一也会写成一个resolveAutowireMode()
方法,语义会更加清晰点。唉,后面这样写,多少给源码阅读增添了点难受。
废话不多说了,我们分析里面的流程吧。
- 步骤一:主要是处理@Bean这个标签的
autowire
属性。其实严格来说,是处理beanDefinition下的autowire
属性。估计大家没怎么用过,如下:
@Bean(autowire = Autowire.BY_NAME)
public OrderService orderService1() {
return new OrderService();
}
或者这样:
<bean id="userService" class="org.example.spring.bean.UserService" autowire="byType"/>
- 步骤二:处理@Autowired、@Value、@Resource等【自动注入】的属性填充(注意,之前是寻找注入点,这里才是真正赋值的地方)。这个是本节课的核心内容,后面给大家细讲。
- 步骤三:处理BeanDefinition里面的propertyValues。比如:我们在操作beanDefinition的时候会修改;或者,在第一步处理@Bean的autowire属性的时候,实际上也是把结果跟旧有BeanDefinition的propertyValues合并,最后在这里处理注入操作。这个其实也没啥好讲的
下面着重讲步骤二【自动注入注解】的属性填充
6.2 InstantiationAwareBeanPostProcessor#postProcessProperties:处理属性
我们在前面的【概念回顾】讲过,这里用到的,其实还是AutowiredAnnotationBeanPostProcessor
跟CommonAnnotationBeanPostProcessor
,这里就简单的拿AutowiredAnnotationBeanPostProcessor
举例吧。
方法调用链:由6.1中的populateBean()调用进来
全路径:org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessProperties
方法注释:在工厂将给定的属性值应用到给定的bean之前,对它们进行后处理,不需要任何属性描述符。
对应流程图:
源码如下:
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
方法解读:这里面就干了两件事,其中第一件事就是【寻找注入点】的入口。我们在前面也介绍过了,并且也说过,【寻找注入点】会在两个地方被调用,这里就是说的第二个地方。但是这里,通常是直接拿到了缓存里面的东西的,重新【寻找注入点】的情况不多,这些就属于【细枝末节】了,毕竟看不看对我们掌握整体脉络影响不大。
所以,这里最主要的还是看这个metadata.inject()
方法,一看就知道是注入的意思
6.3 InjectionMetadata#inject:根据注入点注入
方法调用链:由6.2中的postProcessProperties()调用过来
全路径:org.springframework.beans.factory.annotationInjectionMetadata#inject
方法注释:注入目标类的属性
源码如下:
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
element.inject(target, beanName, pvs);
}
}
}
方法解读:方法挺简单的,这个this.injectedElements
就是我们在【寻找注入点】阶段缓存起来的注入点信息。那么大家还记得这里的注入点信息有哪些吗?哈,就是字段类、方法类封装出来的对象嘛。这里就是遍历所有,无论是方法类还是字段类的注入点了,然后依次调用对方的注入方法。
说到这里,Spring为了维护【单一职责】性,对于不同的注入对象,设计了两个类。分别是:
- AutowiredFieldElement:表示有关带注解【字段】的注入信息
- AutowiredMethodElement:表示有关带注解【方法】的注入信息
他们两个是AutowiredAnnotationBeanPostProcessor
定义的内部类
老样子,这两个都差不多,我们拿AutowiredFieldElement
的element.inject()
举例吧
6.4 AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject:字段类属性注入【入口】
方法调用链:由6.3的inject()调用过来
全路径:org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
方法注释:就是简单的,执行元素注入逻辑
源码如下:
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {
try {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
catch (NoSuchBeanDefinitionException ex) {
// Unexpected removal of target bean for cached argument -> re-resolve
value = resolveFieldValue(field, bean, beanName);
}
}
else {
value = resolveFieldValue(field, bean, beanName);
}
if (value != null) {
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
方法解读:很显然,我们第一次调用,理论上是没有缓存的,所以我们直接看else
的逻辑
6.5 AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#resolveFieldValue:解决字段属性注入【入口】
方法调用链:由6.4的inject()调用过来
全路径:org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
源码如下:
@Nullable
private Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {
// 步骤一:属性注入准备工作
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
Object value;
try {
// 步骤二:属性注入
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
// 步骤三:设置bean依赖信息
synchronized (this) {
if (!this.cached) {
Object cachedFieldValue = null;
if (value != null || this.required) {
cachedFieldValue = desc;
registerDependentBeans(beanName, autowiredBeanNames);
if (autowiredBeanNames.size() == 1) {
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
cachedFieldValue = new ShortcutDependencyDescriptor(
desc, autowiredBeanName, field.getType());
}
}
}
this.cachedFieldValue = cachedFieldValue;
this.cached = true;
}
}
return value;
}
}
方法解读:这里整体来说也是可以拆分成三个步骤来看的。
第一步就是做属性注入前的准备啦,比如之前设置的required
属性,还有什么类型转换器,确保bean工厂存在等等;
第二步是核心,下面讲,真正处理属性注入的地方;
第三步是设置bean依赖信息。这是啥?简单说就是为了方便后期维护,新增了两个map来记录bean之间的相互依赖关系。这两个map分别为:
- dependentBeanMap:记录bean依赖了哪些bean。以beanName记录
- dependenciesForBeanMap:记录bean被哪些bean依赖了。也是以beanName记录
6.6 DefaultListableBeanFactory#resolveDependency:解决属性注入【入口】
方法调用链:由6.5的resolveFieldValue()而来
全路径:org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency
方法注释:根据此工厂中定义的bean解析指定的依赖项。
对应流程图:
源码如下:
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
if (Optional.class == descriptor.getDependencyType()) {
return createOptionalDependency(descriptor, requestingBeanName);
}
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
else {
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}
方法解读:这里开始就很多判断了,判断这个属性要怎么注入,要不要注入。前面这三个if-elseif-elseif
说实在不看,显然我们在使用Spring的时候,基本上也不会用到这几个类型。感兴趣的朋友自己去看吧。我们直接看最后的else
。
这里有一个细节,如果判断到需要注入的地方,有@Lazy
,那就直接返回一个【代理对象】,并且直接返回了(这里的写法是判断result==null
来确定是不是有@Lazy
)。不知道有没有人想过,为什么要用代理对象?啊,大家还记得前面文章提到的【代理范式】吗?
// 代理对象
public class ProxyModel extends ProxyTarget {
private ProxyTarget proxyTarget;
public void setProxyTarget(ProxyTarget proxyTarget) {
this.proxyTarget = proxyTarget;
}
@Override
public void run() {
System.out.println("我代理对象可以在这里做加强---1");
super.run();
System.out.println("我代理对象也可以在这里做加强---2");
}
}
就上面这个。然后我们在回忆一下懒加载的特点,不就是使用的时候再注入嘛。所以,在代理模式下,在每个懒加载属性的调用方法里面做个proxyTarge==null
的判断不就得了嘛。这就是为什么返回代理对象的原因
6.7 DefaultListableBeanFactory#doResolveDependency:解决属性注入,真正干活的地方
方法调用链:由6.6的resolveDependency()而来
全路径:org.springframework.beans.factory.support.DefaultListableBeanFactory#doResolveDependency
方法注释:解决属性注入,真正干活的地方文章来源:https://www.toymoban.com/news/detail-659872.html
对应流程图:
到了这里源码就有点长了,就不截图看了。说到方法长,还是想吐槽因为跟之前的代码风格不一样,这个作者明显懒一点。文章来源地址https://www.toymoban.com/news/detail-659872.html
学习总结
到了这里,关于【Spring专题】Spring之Bean的生命周期源码解析——阶段二(二)(IOC之属性填充/依赖注入)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!