Spring学习笔记--SpringIOC源码(一)

最新推荐文章于 2024-08-16 23:08:28 发布

痛冕

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量236

点赞数 1

分类专栏： IOC容器设计实现及Spring源码分析文章标签： java spring

本文链接：https://blog.csdn.net/qq_40977467/article/details/117047375

版权

IOC容器设计实现及Spring源码分析专栏收录该内容

12 篇文章 1 订阅

订阅专栏

Spring学习笔记–SpringIOC源码

再查看源码的过程中我们应该遵守定焦原则和宏观原则，抓主线，关注源码结构和业务流程，通过断点、反调、和经验来阅读源码以此来提高培养代码架构思维并深入的理解框架。

SpringIOC容器初始化主体流程

Spring IoC的容器体系

IoC容器是Spring的核⼼模块，是抽象了对象管理、依赖关系管理的框架解决⽅案。Spring 提供了很多的容器，其中 BeanFactory 是顶层容器（根容器），不能被实例化，它定义了所有 IoC 容器必须遵从的⼀套原则，具体的容器实现可以增加额外的功能，⽐如我们常⽤到的ApplicationContext，其下更具体的实现如 ClassPathXmlApplicationContext 包含了解析 xml 等⼀系列的内容,AnnotationConfigApplicationContext 则是包含了注解解析等⼀系列的内容。Spring IoC 容器继承体系⾮常聪明，需要使⽤哪个层次⽤哪个层次即可，不必使⽤功能⼤⽽全的。BeanFactory 顶级接⼝⽅法栈如下
在这里插入图片描述
BeanFactory 容器继承体系

通过其接⼝设计，我们可以看到我们⼀贯使⽤的 ApplicationContext 除了继承BeanFactory的⼦接⼝，还继承了ResourceLoader、MessageSource等接⼝，因此其提供的功能也就更丰富了。
下⾯我们以 ClasspathXmlApplicationContext 为例，深⼊源码说明 IoC 容器的初始化流程。

Bean生命周期关键时机点

思路：创建⼀个类 Bean ，让其实现⼏个特殊的接⼝，并分别在接⼝实现的构造器、接⼝⽅法中断点，观察线程调⽤栈，分析出 Bean 对象创建和管理关键点的触发时机。

LagouBean类

package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import
org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

public class LagouBean implements InitializingBean{
	 /**
	 * 构造函数
	 */
	 public LagouBean(){
	 	System.out.println("LagouBean 构造器...");
	 }
	 /**
	 * InitializingBean 接⼝实现
	 */
	 public void afterPropertiesSet() throws Exception {
	 	System.out.println("LagouBean afterPropertiesSet...");
	 }
}

BeanPostProcessor 接⼝实现类

package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

public class MyBeanPostProcessor implements BeanPostProcessor {
	 public MyBeanPostProcessor() {
	 	System.out.println("BeanPostProcessor 实现类构造函数...");
	 }
	 @Override
	 public Object postProcessBeforeInitialization(Object bean, String beanName)throws BeansException {
		 if("lagouBean".equals(beanName)) {
		 System.out.println("BeanPostProcessor 实现类
		postProcessBeforeInitialization ⽅法被调⽤中......");
		 }
		 return bean;
	 }
	 @Override
	 public Object postProcessAfterInitialization(Object bean, String beanName)throws BeansException {
		 if("lagouBean".equals(beanName)) {
		 System.out.println("BeanPostProcessor 实现类
		postProcessAfterInitialization ⽅法被调⽤中......");
		 }
		 return bean;
	 }
}

BeanFactoryPostProcessor 接口实现

package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import
org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
	 public MyBeanFactoryPostProcessor() {
	 	System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
	 }
	 @Override
	 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
	 	System.out.println("BeanFactoryPostProcessor的实现⽅法调⽤中......");
	 }
}

applicationContext.xm

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="
 http://www.springframework.org/schema/beans
 https://www.springframework.org/schema/beans/spring-beans.xsd
">
 <bean id="lagouBean" class="com.lagou.LagouBean"/>
 <bean id="myBeanFactoryPostProcessor"
class="com.lagou.MyBeanFactoryPostProcessor"/>
 <bean id="myBeanPostProcessor" class="com.lagou.MyBeanPostProcessor"/>
</beans>

IoC 容器源码分析用例

/**
* Ioc 容器源码分析基础案例
*/
@Test
public void testIoC() {
	 ApplicationContext applicationContext = new  ClassPathXmlApplicationContext("classpath:applicationContext.xml");
	 LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
	 System.out.println(lagouBean);
}

分析 Bean 的创建是在容器初始化时还是在 getBean 时

根据断点调试，我们发现，在未设置延迟加载的前提下，Bean 的创建是在容器初始化过程中完成的。
在这里插入图片描述

分析构造函数调调用情况

在这里插入图片描述
观察调用栈：

通过如上观察，我们发现构造函数的调⽤时机在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory)处;

分析 InitializingBean 之 afterPropertiesSet 初始化方法调用情况

在这里插入图片描述
通过如上观察，我们发现 InitializingBean中afterPropertiesSet ⽅法的调⽤时机也是在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory);

分析BeanFactoryPostProcessor 初始化和调用情况

分别在构造函数、postProcessBeanFactory ⽅法处打断点，观察调⽤栈，发现BeanFactoryPostProcessor 初始化在AbstractApplicationContext类refresh⽅法的invokeBeanFactoryPostProcessors(beanFactory);postProcessBeanFactory 调⽤在AbstractApplicationContext类refresh⽅法的invokeBeanFactoryPostProcessors(beanFactory);

分析 BeanPostProcessor 初始化和调用情况

分别在构造函数、postProcessBeanFactory ⽅法处打断点，观察调⽤栈，发现BeanPostProcessor 初始化在AbstractApplicationContext类refresh⽅法的registerBeanPostProcessors(beanFactory);
postProcessBeforeInitialization 调⽤在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory);
postProcessAfterInitialization 调⽤在AbstractApplicationContext类refresh⽅法的finishBeanFactoryInitialization(beanFactory)

总结

根据上⾯的调试分析，我们发现 Bean对象创建的⼏个关键时机点代码层级的调⽤都在AbstractApplicationContext 类的 refresh ⽅法中，可见这个⽅法对于Spring IoC 容器初始化来说相当关键，汇总如下：
在这里插入图片描述

Spring IoC容器初始化主流程

由上分析可知，Spring IoC 容器初始化的关键环节就在 AbstractApplicationContext#refresh() ⽅法中，我们查看 refresh ⽅法来俯瞰容器创建的主体流程，主体流程下的具体⼦流程我们后⾯再来讨论。

@Override
public void refresh() throws BeansException, IllegalStateException {
	 synchronized (this.startupShutdownMonitor) {
	 // 第⼀步：刷新前的预处理
	 prepareRefresh();
	 /*
	 第⼆步：
	 获取BeanFactory；默认实现是DefaultListableBeanFactory
	 加载BeanDefition 并注册到 BeanDefitionRegistry
	 */
	 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
	 // 第三步：BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，⽐如context的类加载器等）
	 prepareBeanFactory(beanFactory);
	 try {
		 // 第四步：BeanFactory准备⼯作完成后进⾏的后置处理⼯作
		 postProcessBeanFactory(beanFactory);
		 // 第五步：实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
		 invokeBeanFactoryPostProcessors(beanFactory);
		 // 第六步：注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执
		⾏
		 registerBeanPostProcessors(beanFactory);
		 // 第七步：初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
		 initMessageSource();
		 // 第⼋步：初始化事件派发器
		 initApplicationEventMulticaster();
		 // 第九步：⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
		 onRefresh();
		 // 第⼗步：注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器bean
		 registerListeners();
		 /*
		 第⼗⼀步：
		 初始化所有剩下的⾮懒加载的单例bean
		 初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）
		 填充属性
		 初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、init-method⽅法）
		 调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处
		 */
		 finishBeanFactoryInitialization(beanFactory);
		 /*
		 第⼗⼆步：
		 完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事
		件 （ContextRefreshedEvent）
		 */
		 finishRefresh();
	 }
	 ......
	 }
}

BeanFactory创建流程

获取BeanFactory子流程
在这里插入图片描述
BeanDefinition加载解析及注册子流程
该子流程涉及到如下几个关键步骤
Resource定位：指对BeanDefinition的资源定位过程。通俗讲就是找到定义Javabean信息的XML⽂
件，并将其封装成Resource对象。
BeanDefinition载⼊：把⽤户定义好的Javabean表示为IoC容器内部的数据结构，这个容器内部的数
据结构就是BeanDefinition。
注册BeanDefinition到 IoC 容器
过程分析
Step 1：子流程入口在 AbstractRefreshableApplicationContext#refreshBeanFactory 方法中
在这里插入图片描述
Step 2：依次调⽤多个类的 loadBeanDefinitions ⽅法 —> AbstractXmlApplicationContext —>AbstractBeanDefinitionReader —> XmlBeanDefinitionReader ⼀直执⾏到XmlBeanDefinitionReader 的 doLoadBeanDefinitions ⽅法

Step 3：我们重点观察XmlBeanDefinitionReader 类的 registerBeanDefinitions ⽅法，期间产⽣了多
次重载调⽤，我们定位到最后⼀个
在这里插入图片描述
此处我们关注两个地⽅：⼀个createRederContext⽅法，⼀个是DefaultBeanDefinitionDocumentReader类的registerBeanDefinitions⽅法，先进⼊createRederContext ⽅法看看

我们可以看到，此处 Spring ⾸先完成了 NamespaceHandlerResolver 的初始化。我们再进⼊ registerBeanDefinitions ⽅法中追踪，调⽤了
DefaultBeanDefinitionDocumentReader#registerBeanDefinitions 方法
在这里插入图片描述
进⼊ parseBeanDefinitions 方法

进⼊ parseDefaultElement 方法

进⼊ processBeanDefinition ⽅法

⾄此，注册流程结束，我们发现，所谓的注册就是把封装的 XML 中定义的 Bean信息封装为BeanDefinition 对象之后放⼊⼀个Map中，BeanFactory 是以 Map 的结构组织这些 BeanDefinition的。
在这里插入图片描述
可以在DefaultListableBeanFactory中看到此Map的定义

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new
ConcurrentHashMap<>(256);

时序图

在这里插入图片描述

Bean创建流程

通过最开始的关键时机点分析，我们知道Bean创建⼦流程⼊⼝在AbstractApplicationContext#refresh()⽅法的finishBeanFactoryInitialization(beanFactory) 处
进⼊finishBeanFactoryInitialization
继续进⼊DefaultListableBeanFactory类的preInstantiateSingletons⽅法，我们找到下⾯部分的代码，看到⼯⼚Bean或者普通Bean，最终都是通过getBean的⽅法获取实例
继续跟踪下去，我们进⼊到了AbstractBeanFactory类的doGetBean⽅法，这个⽅法中的代码很多，我们直接找到核心部分
接着进⼊到AbstractAutowireCapableBeanFactory类的⽅法，找到以下代码部分
进⼊doCreateBean⽅法看看，该⽅法我们关注两块重点区域

创建Bean实例，此时尚未设置属性
给Bean填充属性，调⽤初始化⽅法，应⽤BeanPostProcessor后置处理器

痛冕

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
Spring学习笔记--SpringIOC源码(一)

Spring学习笔记–SpringIOC源码再查看源码的过程中我们应该遵守定焦原则和宏观原则，抓主线，关注源码结构和业务流程，通过断点、反调、和经验来阅读源码以此来提高培养代码架构思维并深入的理解框架。SpringIOC容器初始化主体流程Spring IoC的容器体系IoC容器是Spring的核⼼模块，是抽象了对象管理、依赖关系管理的框架解决⽅案。Spring 提供了很多的容器，其中 BeanFactory 是顶层容器（根容器），不能被实例化，它定义了所有 IoC 容器必须遵从的⼀套原则，具体的容
复制链接

扫一扫

专栏目录