栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring ioC源码深入剖析Bean的实例化

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring ioC源码深入剖析Bean的实例化

目录
  • 1 Spring源码阅读技巧
  • 2 ioC初始化流程与继承关系
  • 3 Bean是怎么实例化的
    • 3.1 找到 ioC源码的入口
  • 4 容器13大模板方法实例化bean
    • 4.1 容器13大模板方法之一:prepareRefresh()
    • 4.2 容器13大模板方法之二:obtainFreshBeanFactory()
    • 4.3 容器13大模板方法之三:prepareBeanFactory(beanFactory)
    • 4.4 容器13大模板方法之四:postProcessBeanFactory(beanFactory)
    • 4.5 容器13大模板方法之五:invokeBeanFactoryPostProcessors()
    • 4.6 容器13大模板方法之六:registerBeanPostProcessors(beanFactory)
    • 4.7 容器13大模板方法之七:initMessageSource()
    • 4.8 容器13大模板方法之八:initApplicationEventMulticaster()
    • 4.9 容器13大模板方法之九:onRefresh()
    • 4.10 容器13大模板方法之十:registerListeners()
    • 4.11 容器13大模板方法十一:finishBeanFactoryInitialization(beanFactory)
    • 4.12 容器13大模板方法十二:finishRefresh()
    • 4.13 容器13大模板方法十三:resetCommonCaches()


1 Spring源码阅读技巧

目标:学习阅读源码的技巧(理论+idea)
(重要)源码阅读七大原则:
1、不要一个类一个类的去看
2、更不要一行一行的去看(重点)
3、看不懂的先不看
4、只看核心接口(下面会讲到核心接口)和核心代码(do开头)
5、根据语义和返回值去看
6、ioc (父子容器----对应-父类子类)上下看、带着问题(目标)去看
7、灵活使用工具,将事半功倍(学会看类图ctrl+alt+shift+u、学会看类继承关系ctr+h;方法调用栈+查
找ctr+shift+f)
阅读源码目的
看设计思想!!!
总结:
1、通过理论中的技巧去阅读
2、通过idea自带的功能去辅助阅读

2 ioC初始化流程与继承关系

引言
在看源码之前需要掌握Spring的继承关系和初始化

  1. ioC容器初始化流程
    目标:
    1、ioC容器初始化过程中到底都做了哪些事情(宏观目标)
    2、ioC容器初始化是如何实例化Bean的(划重点,最终目标)
//没有Spring之前我们是这样的
User user=new User();
user.xxx();
//有了Spring之后我们是这样的

User user= context.getBean("xxx");
user.xxx();

ioC流程简化图(七大阶段):
tips:
下面的流转记不住没有关系
在剖析源码的整个过程中,我们一直会拿着这个图和源码对照

初始化:
1、容器环境的初始化
2、Bean工厂的初始化(ioC容器启动首先会销毁旧工厂、旧Bean、创建新的工厂)

读取与定义
读取:通过BeanDefinitonReader读取我们项目中的配置(application.xml)

定义:通过解析xml文件内容,将里面的Bean解析成BeanDefinition(未实例化、未初始化)实例化与销毁Bean实例化、初始化(注入)销毁缓存等

扩展点
事件与多播、后置处理器
复杂的流程学会划重点:


重点总结:
1、工厂初始化过程
2、解析xml到BeanDefinition,放到map
3、调用后置处理器
4、从map取出进行实例化( ctor.newInstance)
5、实例化后放到一级缓存(工厂)

  1. 容器与工厂继承关系
    tips:
    下面的继承记不住没有关系
    在剖析源码的整个过程中,我们一直会拿着这个图和源码对照

目标:简单理解ioC容器继承关系

继承关系理解:
1、ClassPathXmlApplicationContext最终还是到了 ApplicationContext 接口,同样的,我们也可以
使用绿颜色的 FileSystemXmlApplicationContext 和 AnnotationConfigApplicationContext 这两个类 完成容器初始化的工作

2、FileSystemXmlApplicationContext 的构造函数需要一个 xml 配置文件在系统中的路径,其他和
ClassPathXmlApplicationContext 基本上一样

Bean工厂继承关系
目标:1、简单理解Bean工厂继承关系
2、ioc容器与Bean工厂关系?

  1. ApplicationContext 继承了 ListableBeanFactory,这个 Listable 的意思就是,通过这个接口, 我们可以获取多个 Bean,最顶层 BeanFactory 接口的方法都是获取单个 Bean 的。
  2. ApplicationContext 继承了 HierarchicalBeanFactory,获取bean工厂关系.,HierarchicalBeanFactory 表示的是这些 Bean 是有继承关系的,也就是每个Bean 有可能有父
    Bean
  3. AutowireCapableBeanFactory 这个名字中的 Autowire 大家都非常熟悉,它就是用来自动装配
    Bean 用的,但是仔细看上图,ApplicationContext 并没有继承它,不过不用担心,不使用继承, 不代表不可以使用组合,如果你看到 ApplicationContext 接口定义中的最后一个方法getAutowireCapableBeanFactory() 就知道了。
  4. ConfigurableListableBeanFactory 也是一个特殊的接口,看图,特殊之处在于它继承了第二层
    所有的三个接口,而 ApplicationContext 没有。这点之后会用到。

总结:上面的继承关系不用刻意去记住它
我们再学习的源码的时候,遇到哪个类,可以和这个图对照

3 Bean是怎么实例化的

引言:
接下来,我们就正式讲解Spring ioC容器的源码
首先,我们要带着问题和目的去阅读;
比如,我们平时玩魔方,
魔方一共6个面,只要我们最终能每个面的颜色弄成一样的就算完成了这就是目的
读源码也是一样的,带着问题、有目的的就看
我们的目的很简单,就是看一下ioC如何帮我们生成对象的

3.1 找到 ioC源码的入口

目标:找到ioC源码的入口
测试代码:进入到Spring源码入口

package com.spring.test;
import com.spring.test.pojo.Person;
import com.spring.test.service.UserService;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
//宏观目标:ioC初始化到底做了哪些事情?
public class Main {
public static void main(String[] args) {
//1、使用注解
//AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Object.class);
//2、使用FileSystemXmlApplicationContext
// ApplicationContext context =new FileSystemXmlApplicationContext("classpath*:application.xml");
///3、使用ClassPathXmlApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:application.xml");
// (c)从容器中取出Bean的实例,call:
AbstractApplicationContext.getBean(java.lang.Class)
//工厂模式(simple)
UserService userService = context.getBean(UserService.class);
// 这句将输出: hello world
System.out.println(userService.getName());
   }
}

进入到ClassPathXmlApplicationContext的有参构造器

org.springframework.context.support.ClassPathXmlApplicationContext#ClassPathXmlApplication Context(java.lang.String[], boolean, org.springframework.context.ApplicationContext)

public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
//继承结构图
//1、返回一个classloader
//2、返回一个解析器
super(parent);
// 1、获取环境(系统环境、jvm环境)
// 2、设置Placeholder占位符解析器
// 2、将xml的路径解析完存储到数组
setConfigLocations(configLocations);
//默认为true
if (refresh) {
//核心方法(模板)
refresh();
   }
}

重点步骤解析(断点跟踪讲解)
super方法做了哪些事情
1、super方法:通过点查看父容器与子容器概念
2、super方法:调用到顶端,一共5层,每一层都要与讲义中的【ioC与Bean工厂类关系继承】进行对照
3、super方法:在什么地方初始化的类加载器和解析器
setConfigLocations方法做了哪些事情:
1、如何返回的系统环境和jvm环境
2、路径的解析
3、设置占位符解析器进入核心方法refresh

4 容器13大模板方法实例化bean 4.1 容器13大模板方法之一:prepareRefresh()

目标:prepareRefresh()到底做了哪些事情
prepareRefresh()【准备刷新】

// synchronized块锁(monitorenter --monitorexit),不然 refresh() 还没结束,
又来个启动或销毁容器的操作
synchronized (this.startupShutdownMonitor) {
//1、【准备刷新】【Did four things】
prepareRefresh();
......。略

1、为什么要加快锁synchronized
2、prepareRefresh干了哪些事情
1、记录启动时间/设置开始标志
2、子类属性扩展(模板方法)
3、校验xml配置文件
4、初始化早期发布的应用程序事件对象(不重要,仅仅是创建setg对象)

4.2 容器13大模板方法之二:obtainFreshBeanFactory()

obtainFreshBeanFactory【获得新的bean工厂】
最终目的就是解析xml,注册bean定义(架构图)(重要)为什么要注册bean定义?

项目中,配置bean(包含但不限于)或者aop的时候,我们可以使用xml
也可以使用注解,所以,在正式的实例化前;先把解析xml(或注解)成bean定义后续,实例化的时候,直接从bean定义去拿

// 2、【获得新的bean工厂】关键步骤
//1、关闭旧的 BeanFactory
//2、创建新的 BeanFactory(DefaluListbaleBeanFactory)
//3、解析xml/加载 Bean 定义、注册 Bean定义到beanFactory(未初始化)
//4、返回全新的工厂
ConfigurableListableBeanFactory beanFactory =obtainFreshBeanFactory();
refreshBeanFactory方法
//1、关闭旧的 BeanFactory
createBeanFactory();方法
//2、创建新的 BeanFactory(DefaluListbaleBeanFactory)
此处解释spring为什么创建DefaultListableBeanFactory?
原来所说的bean工厂就是DefaultListableBeanFactory
/
this.applicationEventMulticaster = new
SimpleApplicationEventMulticaster(beanFactory);
//将多播注册到Bean工厂
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,
this.applicationEventMulticaster);

关于beanFactory.registerSingleton( org.springframework.beans.factory.support.DefaultListableBeanFactory#registerSingleton
将新建的这个bean手动注册到bean工厂
步骤如下
调用:
org.springframework.beans.factory.support.DefaultListableBeanFactory#manualSingletonNames
这个集合器set中
然后:先去一级缓存去找,没有,直接放到一级缓存。移除二级三级缓存
最后:设置bean公厂、放到集合

4.9 容器13大模板方法之九:onRefresh()

【刷新】 子实现:默认情况下不执行任何操作

// 9、【刷新】具体的子类可以在这里初始化一些特殊的 Bean(在初始化singleton beans 之前)
onRefresh();
4.10 容器13大模板方法之十:registerListeners()

【注册所有监听器】

//10、【注册所有监听器】,监听器需要实现 ApplicationListener 接口。
registerListeners();

讲解重点(断点跟踪、类继承关系、架构图讲解)

//获取所有实现了ApplicationListener,然后进行注册
//查找顺序
//1、集合applicationListeners查找
//2、bean工厂找到实现ApplicationListener接口的bean
//3、this.earlyApplicationEvents;准备刷新(启动第一步设置)
4.11 容器13大模板方法十一:finishBeanFactoryInitialization(beanFactory)

核心:【完成bean工厂初始化操作】

//11、 【完成bean工厂初始化操作】负责初始化所有的 singleton beans,反射生
成对象/填充
//此处开始调用Bean的前置处理器和后置处理器
finishBeanFactoryInitialization(beanFactory);

讲解重点(断点跟踪、类继承关系、架构图讲解)

//1、设置辅助器:例如:解析器、转换器、类装载器
//2、实例化(反射)
//3、填充
//4、调用前置、后置处理器
//1、先从一级缓存拿(or 正在创建中),如果正在创建有,最后return null,说明此处为实例化
//2、在从二级缓存拿
//3、在从三级缓存拿
//以上三步为解决循环依赖
//4、getBean调用的时候,直接从一级缓存取出
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference)
{
//先从一级缓存中拿,此处为空
Object singletonObject = this.singletonObjects.get(beanName);
// 下面isSingletonCurrentlyInCreation的如果有值,即为true,说明当前线程是实例化
中...
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName))
{
synchronized (this.singletonObjects) {
//在从二级缓存拿
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
//在从三级缓存拿
ObjectFactory singletonFactory =
this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName,
singletonObject);
this.singletonFactories.remove(beanName);
    }
   }
  }
 }
return singletonObject;
}

上面的代码总结:
先从一级缓存拿(此处如果为空,正在创建,直接return)为空,在从二级缓存拿还为空;在从三级缓存拿将三级缓存内容赋值给二级缓存
重点关注4个方法(重要)
调用时机:实例化(反射)对象/填充/回调后置(循环依赖&三级缓存)
调用入口:
xx.getBean()
容器初始化

getBean
doGetBean
createBean
doCreateBean

实例化核心

org.springframework.beans.BeanUtils#instantiateClass(java.lang.reflect.Construct
or, java.lang.Object...)

注入核心

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#pop
ulateBean

调用bean的前置、后置方法(这个时候bean已经实例化、注入完毕了)

//注意:
//1、先调用bean的前置处理器
//中间过程:调用bean的init方法或者实现了 InitializingBean 接口,调用
afterPropertiesSet() 方法
//2、后调用bean的后置处理器

最后一次机会的回调(实例化后注入前)

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#pop
ulateBean
================================================================================
===
 boolean continueWithPropertyPopulation = true;
//如果存在这实现这个接口的bean
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp =
(InstantiationAwareBeanPostProcessor) bp;
// postProcessAfterInstantiation如果返回 false,代表不需要进行后
续的属性设值
if
(!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
   }
  }
 }
}
4.12 容器13大模板方法十二:finishRefresh()

【完成刷新】

protected void finishRefresh() {
// 1、清除上下文级资源缓存
clearResourceCaches();
// 2、LifecycleProcessor接口初始化
// ps:当ApplicationContext启动或停止时,它会通过LifecycleProcessor来与所有声明
的bean的周期做状态更新
// 而在LifecycleProcessor的使用前首先需要初始化
initLifecycleProcessor();
// 3、启动所有实现了LifecycleProcessor接口的bean
//DefaultLifecycleProcessor,默认实现
getLifecycleProcessor().onRefresh();
// 4、发布上下文刷新完毕事件到相应的监听器
//ps:当完成容器初始化的时候,
// 要通过Spring中的事件发布机制来发出ContextRefreshedEvent事件,以保证对应的监听
器可以做进一步的逻辑处理
publishEvent(new ContextRefreshedEvent(this));
// 5、把当前容器注册到到MBeanServer,用于jmx使用
LiveBeansView.registerApplicationContext(this);
}

tips:
不重要

4.13 容器13大模板方法十三:resetCommonCaches()

【重设公共缓存】

//15、重设公共缓存
resetCommonCaches();
//清除内核缓存;因为我们的对象已经实例化并且注入完毕了
//中间过程数据(缓存)就不在需要了
protected void resetCommonCaches() {
    //清除之前声明过的方法和列的缓存
ReflectionUtils.clearCache();
//清除解析类型的缓存、序列化缓存
ResolvableType.clearCache();
//清除所有的类加载器
CachedIntrospectionResults.clearClassLoader(getClassLoader());
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/951221.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号