Spring架构体系总体介绍与导入 IOC源码和工厂的构建
- Spring架构体系总体介绍与导入 IOC源码和工厂的构建
- Spring架构体系总体介绍
- 1 Spring IoC源码深入剖析
- 2 singleton bean 创建【重点】
- 3 Spring的循环依赖
- 4 IoC用到的那些设计模式
- 总结
Spring架构体系总体介绍与导入 IOC源码和工厂的构建
Spring架构体系总体介绍
Spring总体架构介绍
引言
Spring从2004年诞生;到现在已有十几年的历史了
它也有由最初的一个简单框架,演变成了今天的一个生态
那么,Spring正是这个生态一个核心,或者说是基础
接下来,我们就一起来看下,Spring的整体架构到底是什么样的
Spring架构分层模型
Spring总体架构图如下(4层):
Source Position
数据访问与集成:
- spring-jdbc:提供JDBC主要实现模块,用于简化JDBC操作
- spring-tx:spring-jdbc事务管理
- spring-orm:主要集成Hibernate5,jpa
- spring-oxm:将java对象映射成xml数据或将xml映射为java对象
- spring-jms:发送和接受消息(MQ)web模块:
- spring-web:提供了最基础的web支持,主要建立在核心容器上
- spring-webmvc:实现了spring mvc的web应用
- spring-websocket:主要与前端页的全双工通讯协议
- spring-webflflux:一个新的非阻塞式Web框架(5.0中引入)
切面编程:
- spring-aop:面向切面编程,CGLB,JDKProxy
- spring-aspects:集成AspectJ,Aop应用框架
- spring-instrument(工具):动态Class Loading模块
- spring-messaging:4.0加入的模块,主要集成基础报文传送应用
核心模块
- spring-core:核心模块;供了框架的基本组成部分,包括控制反转(Inversion of Control,IOC) 和依赖注入(Dependency Injection,DI)功能
- spring-beans:Bean:提供了BeanFactory,是工厂模式的一个经典实现
- spring-context:上下文,即IOC容器(ApplicationContext)
- spring-context-support:对IOC的扩展,以及IOC子容器
- spring-context-indexer:类管理组件和Classpath扫描
- spring-expression:表达式语句
测试:
- spring-test:测试组件(JUnit、Mock)
Spring模块依赖关系
Spring模块依赖关系如下:
对应的源码工程
spring-jcl:日志框架
spring-jms:消息框架(mq的集成)
spring-webflux非阻塞函数式Reactive Web框架
源码环境编译与构建
源码调试搭建步骤:
自动化构建gradle
引言:
为什么要讲解gradle?
因为从Sping5开始,官方就开始使用gradle来构建环境了
接下来,我们所有的环境都要基于gradle
什么是gradle
Gradle是一个项目自动化构建工具。
是Apache的一个基于Ant 和Maven的软件,用于项目的依赖管理。
项目的构建经历了三个时代:
Apache Ant(2000 年左右)
Maven(2004年)
Gradle(2012 年左右)
Spring(5.0开始) 等优秀的开源项目都将自己的项目从 Maven 迁移到了 Gradle
Google 官方 Android 开发的 IDE Android Studio 也默认使用了 Gradle 进行构建。
源码环境搭建与编译
四大步骤
1)安装gralde环境
下载gradle,建议4.3.1即可,不要下载太高的版本,版本太高,后面在idea中编译的时候有些spring的组件下载不了
https://services.gradle.org/distributions/
https://gradle.org/releases/
gralde的安装非常简单,就和配置jdk、maven一样的道理,将主目录配置到环境变量即可
设置JAVA_HONME和GRADLE_HOME
然后cmd打开窗口,测试一下是否安装成功
gradle -V
常见问题
如果不能正常查看版本号,说明jdk版本太高,需要将JAVA_HOME修改为8
在~/.gradle/下创建 init.gradle文件,内容如下:(国内阿里云加速)
allprojects {
repositories {
//maven { url 'file:///Users/wangshouwen/.m2/repository'}
//mavenLocal()
maven { url 'https://maven.aliyun.com/repository/central'}
maven { url 'https://maven.aliyun.com/repository/jcenter'}
maven { url 'https://maven.aliyun.com/repository/public'}
maven { url 'https://maven.aliyun.com/repository/google'}
maven { url 'https://maven.aliyun.com/repository/gradle-plugin'}
maven { url 'https://maven.aliyun.com/repository/grails-core'}
maven { url 'https://maven.aliyun.com/repository/spring'}
maven { url 'https://maven.aliyun.com/repository/spring-plugin'}
maven { url 'https://maven.aliyun.com/repository/apache-snapshots'}
mavenCentral()
}
}
2)下载Spring源码
进入Spring官网,然后从下面的窗口进入到github
https://spring.io/projects/spring-framework#learn
直接从github下载
https://github.com/spring-projects/spring-framework
3)源码环境编译
执行项目下的gradlew.bat, 等待构建完成…
gradlew.bat (mac或linux下是 gradle )
4)IDEA导入源码
注意:这里必须使用import Project,不能使用open形式打开
2020用open
5)常见错误(如果遇到对应处理一下)
如果有很多类找不到,一般是一些测试案例相关的,运行当前的compileTestJava
手工删除上面的 build;如果遇到找不的class依赖,右键run
java version错误
设置版本就ok
1 Spring IoC源码深入剖析
1.1 Spring源码阅读技巧
1、类层次藏得太深,不要一个类一个类的去看,遇到方法该进就大胆的进
2、更不要一行一行的去看,看核心点,有些方法并不重要,不要跟它纠缠
3、看不懂的先不看,根据语义和返回值能知道这个方法达到了啥目的即可
4、只看核心接口(下面标注了重点的地方)和核心代码,有些地方也许你使用spring以来都没触发过
5、debug跟步走,源码中给大家标注好了,见到 ”===>“ 就进去
6、广度优先,而非深度优先。先沿着主流程走,了解大概,再细化某些方法
7、认命。spring里多少万行的代码,一部书都写不完。只能学关键点
阅读源码目的
加深理解spring的bean加载过程
面试吹牛x
1.2 IoC初始化流程与继承关系
1) IoC容器初始化流程
目标:
1、IoC容器初始化过程中到底都做了哪些事情(宏观目标)
2、IoC容器初始化是如何实例化Bean的(划重点,最终目标)
//没有Spring之前我们是这样的
User user=new User();
user.xxx();
//有了Spring之后我们是这样的
<bean id="userService" class="com.spring.test.impl.UserServiceImpl">
User user= context.getBean("xxx");
user.xxx();
IoC流程简化图:
初始化:
1、容器环境的初始化
2、Bean工厂的初始化(IoC容器启动首先会销毁旧工厂、旧Bean、创建新的工厂)
读取与定义
读取:通过BeanDefinitonReader读取我们项目中的配置(application.xml)
定义:通过解析xml文件内容,将里面的Bean解析成BeanDefinition(未实例化、未初始化)
实例化与销毁
Bean实例化、初始化(注入)
销毁缓存等
扩展点
事件与多播、后置处理器
复杂的流程关键点:
重点总结:
1、工厂初始化过程
2、解析xml到BeanDefinition,放到map
3、调用后置处理器
4、从map取出进行实例化( ctor.newInstance)
5、实例化后放到一级缓存(工厂)
2) 容器与工厂继承关系
继承关系理解:
1、ClassPathXmlApplicationContext最终还是到了 ApplicationContext 接口,同样的,我们也可以使用绿颜色的 FileSystemXmlApplicationContext 和AnnotationConfigApplicationContext 这两个类完成容器初始化的工作
2、FileSystemXmlApplicationContext 的构造函数需要一个 xml 配置文件在系统中的路径,其他和ClassPathXmlApplicationContext 基本上一样
3、AnnotationConfigApplicationContext 的构造函数扫描classpath中相关注解的类,主流程一样课程中我们以最经典的 classpathXml 为例。
目标:
ApplicationContext 和 BeanFactory 啥关系?
BeanFactory和FactoryBean区别
BeanFactory:负责生产和管理Bean的一个工厂接口,提供一个Spring Ioc容器规范,
FactoryBean: 一种Bean创建的一种方式,对Bean的一种扩展。对于复杂的Bean对象初始化创建使用其可封装对象的创建细节。
1.3 开始搭建测试项目
四步:
1、新建测试module项目
首先我们在 Spring 源码项目中新增一个测试项目,点击 New -> Module… 创建一个 Gradle 的 Java 项 目
2、详细信息
3、设置gradle
4、完善信息
在 build.gradle 中添加对 Spring 源码的依赖:
compile(project(‘:spring-context’))
spring-context 会自动将 spring-core、spring-beans、spring-aop、spring-expression 这几个
基础 jar 包带进来。
接着,我们需要在项目中创建一个 bean 和配置文件(application.xml)及启动文件(Main.java)接口如下:
package com.spring.test.service;
//用户接口
public interface UserService {
public String getName();
}
//实现类
public class UserServiceImpl implements UserService {
public String name;
public UserServiceImpl(){
System.out.println("userserviceImpl 初始化,构造函数被调用");
}
public void setName(String name) {
this.name = name;
}
@Override
public String getName() {
return "name="+name;
}
}
Main代码如下
@MapperScan(basePackages = "com.tx.test.mapper")
public class Main {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:application.xml");
UserService userService = (UserService) context.getBean("userService");
UserService userService = (UserService) context.getBean("userServiceBeanId"); // ===>
// 这句将输出: hello world
System.out.println(userService.getName());
}
}
配置文件 application.xml(在 resources 中)配置如下:
<bean id="userServiceBeanId" class="com.spring.test.impl.UserServiceImpl"">
</bean>
运行
输出如下
com.spring.test.impl.UserServiceImpl@2aa5fe93
Hello World
1.4 工厂的构建
引言:
接下来,我们就正式讲解Spring ioC容器的源码
我们的目的:看一下ioC如何帮我们生成对象的
1)ApplicationContext入口
参考 IocTest.java
测试代码:spring支持多种bean定义方式,为方便大家理解结构,以xml为案例,后面的解析流程一致
ApplicationContext context =
new ClassPathXmlApplicationContext("classpath*:${xmlName}.xml"); // ===>
// (c)从容器中取出Bean的实例,call:AbstractApplicationContext.getBean(java.lang.Class<T>)
//工厂模式(simple)
UserService userService = (UserService) context.getBean("userServiceBeanId"); // ===>
// 这句将输出: hello world
System.out.println(userService.getName());
进入到ClassPathXmlApplicationContext的有参构造器
org.springframework.context.support.ClassPathXmlApplicationContext#ClassPathXmlApplicationContext(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
// 1、获取环境(系统环境、jvm环境)
// 2、设置Placeholder占位符解析器,${xxx}.xml解析为完整文件名
// 2、将xml的路径解析完存储到数组
setConfigLocations(configLocations); // ===>
//默认为true
if (refresh) {
//核心方法(模板),前面就是些铺垫
refresh(); // ===> magic happens here!
}
}
重点步骤解析(断点跟踪讲解)
super方法做了哪些事情
1、super方法:通过点查看父容器与子容器概念
2、super方法:调用到顶端,一共5层,每一层都要与讲义中的【ioC与Bean工厂类关系继承】进行对照
3、super方法:在什么地方初始化的类加载器和解析器
setConfigLocations方法做了哪些事情:
1、如何返回的系统环境和jvm环境
2、路径的解析
3、设置占位符解析器
进入核心方法refresh
2)预刷新
prepareRefresh()【准备刷新】
// synchronized块锁(monitorenter --monitorexit)
// 不然 refresh() 还没结束,又来个启动或销毁容器的操作
// startupShutdownMonitor就是个空对象,锁
synchronized (this.startupShutdownMonitor) {
//1、【准备刷新】,设置了几个变量,也是准备工作
prepareRefresh(); // ===>
讲解重点(断点跟踪、类继承关系、架构图讲解)
prepareRefresh干了哪些事情
1、记录启动时间/设置开始标志
2、子类属性扩展(模板方法)
3、校验xml配置文件
4、初始化早期发布的应用程序事件对象(不重要,仅仅是创建setg对象)
//1、记录启动时间/设置开始标志
//2、子类属性扩展
//3、校验xml配置文件
//4、初始化早期发布的应用程序事件对象(仅仅是创建setg对象)
protected void prepareRefresh() {
// 设置3个属性的值,没啥可说的,一个时间,两个标记位
this.startupDate = System.currentTimeMillis();
//AtomicBoolean 类型,当前context是否被关闭
this.closed.set(false);
//AtomicBoolean 类型,当前context是否被激活,
// refresh失败出现异常的时候,会再改成false,可以多次refresh尝试
this.active.set(true);
//打条日志,看控制台
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
//2、protected,交给子类实现:在上下文环境中初始化属性源,非重点
initPropertySources(); // ===> 默认情况下其实为空
//3、校验配置文件的属性,合法性, 否则终止加载流程
getEnvironment().validateRequiredProperties();
//4、初始化一个set,用于记录应用程序事件
this.earlyApplicationEvents = new LinkedHashSet<>();
}
3)创建bean工厂【重点】
【获得新的bean工厂】obtainFreshBeanFactory()
最终目的就是解析xml,注册bean定义
关键步骤
1、关闭旧的 BeanFactory
2、创建新的 BeanFactory(DefaluListbaleBeanFactory)
3、解析xml/加载 Bean 定义、注册 Bean定义到beanFactory(未初始化)
4、返回全新的工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
4)bean工厂前置操作
【准备bean工厂】prepareBeanFactory(beanFactory);
1、设置 BeanFactory 的类加载器
2、设置 BeanFactory 的表达式解析器
3、设置 BeanFactory 的属性编辑器
4、智能注册
5)bean工厂后置操作
【后置处理器Bean工厂】postProcessBeanFactory(beanFactory) 空方法
tips:子类实现
空方法,跳过
6)工厂后置处理器【重点】
【调用bean工厂后置处理器】invokeBeanFactoryPostProcessors(beanFactory);
调用顺序一:bean定义注册后置处理器
调用顺序二:bean工厂后置处理器
PostProcessorRegistrationDelegate 类里有详细注解
tips
invoke方法近200行
关注两类后置处理器的方法执行步骤和顺序
7)bean后置处理器
【注册bean后置处理器】registerBeanPostProcessors(beanFactory)
6、【注册bean后置处理器】只是注册,但是不会反射调用
功能:找出所有实现BeanPostProcessor接口的类,分类、排序、注册
registerBeanPostProcessors(beanFactory);
核心:查看重要的3步;最终目的都是实现bean后置处理器的注册
第一步: implement PriorityOrdered
第二步: implement Ordered.
第三步: Register all internal BeanPostProcessors.
8)国际化
【初始化消息源】国际化问题i18n initMessageSource();
就加了个bean进去,非核心步骤,跳过
9)初始化事件广播器
【初始化应用程序事件多路广播】initApplicationEventMulticaster();
需要讲解观察者设计模式
重点:就放了个bean进去, 到下面的 listener再联调。
10)刷新
【刷新】 onRefresh();
空的,交给子类实现:默认情况下不执行任何操作
具体的子类可以在这里初始化一些特殊的 Bean(在初始化 singleton beans 之前)
onRefresh();
不重要,跳过
11)注册监听器【重点】
**【注册所有监听器】**registerListeners();
测试代码参考:MulticastTest
public static void main(String[] args) {
//=====================================多播器发布===============================================
ApplicationContext context =
new ClassPathXmlApplicationContext("classpath*:application-event.xml");
//***************使用spring的多播器发布**********************
ApplicationEventMulticaster applicationEventMulticaster
= (ApplicationEventMulticaster) context.getBean("applicationEventMulticaster");
applicationEventMulticaster.multicastEvent(new MessageSourceEvent("测试 消息..."));
//***************使用BeanFactory的publishEvent发布********************
// 其实一样,底层调的同样是 multicastEvent 方法,可以跟进去
// ApplicationContextListenerPubisher myPubisher = (ApplicationContextListenerPubisher)
// context.getBean("applicationContextListenerPublisher");
// myPubisher.publishEvent(new MessageSourceEvent("测试 消息...")); // ===>
}
获取所有实现了ApplicationListener,然后进行注册
1、集合applicationListeners查找
2、bean工厂找到实现ApplicationListener接口的bean
3、this.earlyApplicationEvents;
需要讲解观察者设计模式
重点:演示多播和容器发布
12)完成bean工厂【重点】
【完成bean工厂初始化操作】finishBeanFactoryInitialization(beanFactory);
【完成bean工厂初始化操作】负责初始化所有的 singleton beans
此处开始调用Bean的前置处理器和后置处理器
finishBeanFactoryInitialization(beanFactory);
讲解重点(断点跟踪、类继承关系、架构图讲解)
1、设置辅助器:例如:解析器、转换器、类装载器
2、实例化
3、填充
4、调用前置、后置处理器
核心代码在 getBean() , 下面单独讲解
13)完成刷新
【完成刷新】
protected void finishRefresh() {
// 1、清除缓存,其实就是一顿clear
clearResourceCaches();
// 2、LifecycleProcessor接口初始化,就是注册了个LifecycleProcessor的bean进去
// ps:当ApplicationContext启动或停止时,它会通过LifecycleProcessor
// 来与所有声明的bean的周期做状态更新
// 而在LifecycleProcessor的使用前首先需要初始化
initLifecycleProcessor();
// 3、启动所有实现了LifecycleProcessor接口的bean
//挨个调它们的start方法。一般没人用
getLifecycleProcessor().onRefresh();
// 4、发布一个 ContextRefreshedEvent事件
//宣布一下,refresh完成了,如果有需要的listener,那就去处理,一般没人关心
publishEvent(new ContextRefreshedEvent(this));
// 5、把当前容器注册到到MBeanServer,jmx会用
LiveBeansView.registerApplicationContext(this);
}
2 singleton bean 创建【重点】
下面拎出来,重点讲 getBean方法。
参考代码:
先看没有循环依赖的情况,普通单例bean的初始化 SinigleTest.java
后面再讲循环依赖
1)调用入口
大家都知道是getBean()方法,但是这个方法要注意,有很多调用时机
如果你把断点打在了这里,再点进去getBean,你将会直接从singleton集合中拿到一个实例化好的bean
无法看到它的实例化过程。
可以debug试一下。会发现直接从getSingleTon返回了bean,这不是我们想要的模样……
思考一下,为什么呢?
回顾 1.4中的第 12 小节,在bean工厂完成后,会对singleton的bean完成初始化,那么真正的初始化应该发生在那里!
那就需要找到:DefaultListableBeanFactory的第 809 行,那里的getBean
也可以从 1.4的第12小节的入口跟进去。断点打在这里试试:
2)主流程
小tip:先搞清除3级缓存的事
关于bean的三级缓存:DefaultSingletonBeanRegistry代码
/**
* 一级缓存:单例(对象)池,这里面的对象都是确保初始化完成,可以被正常使用的
* 它可能来自3级或者2级
*/
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/**
* 三级缓存:单例工厂池,这里面不是bean本身,是它的一个工厂,未来调getObject来获取真正 的bean
* 一旦获取,就从这里删掉,进入2级(发生闭环的话)或1级(没有闭环)
*/
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/**
* 二级缓存:早期(对象)单例池,这里面都是半成品,只是有人用它提前从3级get出来,把引用 暴露出去
* 它里面的属性可能是null,所以叫早期对象,early!半成品
* 未来在getBean付完属性后,会调addSingleton清掉2级,正式进入1级
*/
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
传统叫三级缓存里拿bean,其实就是仨map
严格意义上,只有single一级缓存,其他俩根本算不上是缓存
他们只是在生成bean的过程中,暂存过bean的半成品。
就那么称呼,不必较真
主流程图很重要!后面的debug会带着这张图走
getBean :
入口
doGetBean :
调getSingleton查一下缓存看看有没有,有就返回,没有给singleton一个lambda表达式,函数式编程
里调下面的createBean拿到新的bean,然后清除3级缓存,放入1级缓存
createBean :
调这里。一堆检查后,进入下面
doCreateBean :
真正创建bean的地方: 调构造函数初始化 - 放入3级缓存 - 解析属性赋值 - bean后置处理器
3)getSingleton
在DefaultSingletonBeanRegistry里,有三个,作用完全不一样
//啥也没干,调下面传了个true
public Object getSingleton(String beanName)
//从1级缓存拿,1级没有再看情况
//后面的参数如果true,就使用3级升2级返回,否则直接返回null
protected Object getSingleton(String beanName, boolean allowEarlyReference)
//1级没有,通过给的factory创建并放入1级里,清除2、3
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)
4)bean实例化
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#cre ateBeanInstance
5)放入三级缓存
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#add SingletonFactory
6)注入属性
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#pop ulateBean
真正给bean设置属性的地方!
7)bean前后置
还记得上面我们自定义的 Bean后置处理器吗
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#ini
tializeBean
前、后置的调用,在这里
详细见下图第3步,很多,了解即可,需要时查一下在相关地方扩展
8)小结
伪代码,无循环依赖时,生成bean流程一览
getBean("A"){
doGetBean("A"){
a = getSingleton("A"){
a = singletonObjects(); //查1级缓存,null
if("创建过3级缓存"){ //不成立
//忽略
}
return a;
}; // null
if(a == null){
a = getSingleton("A" , ObjectFactory of){
a = of.getObject() -> { //lambda表达式
createBean("A"){
doCreateBean("A"){
createBeanInstance("A"); // A 实例化
addSingletonFactory("A"); // A 放入3级缓存
populateBean("A"); // A 注入属性
initializeBean("A"); // A 后置处理器
} //end doCreateBean("A")
} //end crateBean("A")
} // end lambda A
addSingleton("A" , a) // 清除2、3级,放入1级
} // end getSingleton("A",factory)
} // end if(a == null)
return a;
} //end doGetBean("A")
}//end getBean("A")
3 Spring的循环依赖
引言
在上面,我们剖析了bean实例化的整个过程
也就是我们的Bean他是单独存在的,和其他Bean没有交集和引用
而我们在业务开发中,肯定会有多个Bean相互引用的情况
也就是所谓的循环依赖
3.1 什么是循环依赖
通俗的讲就是N个Bean互相引用对方,最终形成闭环。
项目代码介绍如下(测试类入口: CircleTest.java)
配置文件
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--注册bean后置处理器 -->
<bean class="com.spring.test.config.BeanPostProcessorTest"></bean>
<!--循环依赖BeanA依赖BeanB -->
<bean id="userServiceImplA" class="com.spring.test.impl.UserServiceImplA">
<property name="userServiceImplB" ref="userServiceImplB"/>
</bean>
<!--循环依赖BeanB依赖BeanA -->
<bean id="userServiceImplB" class="com.spring.test.impl.UserServiceImplB">
<property name="userServiceImplA" ref="userServiceImplA"/>
</bean>
</beans>
userServiceImplA代码如下
//实现类
public class UserServiceImplA implements UserService {
private UserServiceImplB userServiceImplB;
public void setUserServiceImplB(UserServiceImplB userServiceImplB) {
this.userServiceImplB = userServiceImplB;
}
@Override
public String getName() {
return "在UserServiceImplA的Bean中" +
"userServiceImplB注入成功>>>>>>>>>"+userServiceImplB;
}
}
userServiceImplB代码如下
//实现类
public class UserServiceImplB implements UserService {
private UserServiceImplA userServiceImplA;
public void setUserServiceImplA(UserServiceImplA userServiceImplA) {
this.userServiceImplA = userServiceImplA;
}
@Override
public String getName() {
return "在UserServiceImplB的Bean中" +
"userServiceImplA注入成功>>>>>>>>>"+userServiceImplA;
}
}
入口Main
public static void main(String[] args) {
//=====================================循环依赖工程 Run================================================
ApplicationContext context =
new ClassPathXmlApplicationContext("classpath*:application-circle.xml");
UserService userService = context.getBean("userServiceImplA",UserService.class);
System.out.println(userService.getName());
}
输出如下
3.2 Spring如何解决循环依赖
假如无法解决循环依赖
1、Bean无法成功注入,导致业务无法进行
2、产生死循环(一种假设情景)
1)三级缓存变化过程
目标:
只有明白三级缓存变化过程,才能知道是如何解决循环依赖的
略去其他步骤,只看缓存变化
变化过程3-1:如下图:
步骤:
A :... - 走到doCreateBean: 初始化 - 进3级缓存 - 注入属性,发现需要B
B :... - 走到doCreateBean: 初始化 - 进3级缓存
1、BeanA经历gdcd四个方法,走到doCreatebean里在实例化后、注入前放到三级缓存
2、放到三级缓存后;BeanA在正式的注入的时候,发现有循环依赖,重复上【1】的步骤
3、最终:BeanA和BeanB都放到了三级缓存
变化过程3-2:如下图:
步骤:
1、BeanB放到三级缓存后,这个时候BeanB要开始注入了;
于是,BeanB找到了循环依赖BeanA后,再从头执行A的getBean和doGetBean方法;
此处在getSingleton里面(这货第一次是必经的,但第二次来行为不一样了)将BeanA设置到了
二级缓存,并且把BeanA从三级缓存移除走了
2、BeanB如愿以偿的拿到了A,注入,此时,完成了注入过程;一直到DefaultSingletonBeanRegistry#addSingleton方法后;BeanB从三级缓存直接进入一级缓存,完
成它的使命
3、目前,一级缓存有BeanB(里面的BeanA属性还是空)、二级缓存有BeanA 三级缓存为空
核心代码
//循环依赖问题解决点!【关键点】 在A-B-A的doGetBean里多次调用这个方法每次行为不一样
// allowEarlyReference:要不要生成2级缓存,
// 如果true,就从3级的getObject生成,放入2级缓存,并清除3级,循环依赖的时候会触发
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//先从一级缓存中拿
Object singletonObject = this.singletonObjects.get(beanName);
// 后面if的行为很重要,有多种触发时机,以循环依赖A-B-A为例
// 1、重点看isSingletonCurrentlyInCreation的值,这里面A第一次路过肯定是空的
// 2、A到getSingleton(Factory{createBean})方法里的时候,这个值会放入A
// 3、A发现需要B,B走到这里,依然是空的
// 4、B发现需要A,A的getBean再次走到这里,第2步里放进了A,不再空,会进入这个if
// 5、A进入if,发现2级缓存为null,会触发3级缓存升2级,升完返回给B,B就完整了。
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//在从二级缓存拿
singletonObject = this.earlySingletonObjects.get(beanName);
//allowEarlyReference是否允许循环依赖,
if (singletonObject == null && allowEarlyReference) {
// 注意!循环依赖A-B-A , 在B里面设置A,触发getBean(A)的时候会进这里
//在从三级缓存拿,发现三级缓存有了,此处来结束这个死循环A--B--A
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//调用早期对象方法AbstractAutowireCapableBeanFactory.getEarlyBeanReference
// 这货是在doCreateBean时放入三级缓存的一个lambda表达式,记得不?
singletonObject = singletonFactory.getObject();
//三级缓存返回的早期对象放到了二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
//同时移除三级缓存
this.singletonFactories.remove(beanName);
}
}
}
}
//返回这个单例对象,如果上面if不满足,那就是个null
return singletonObject;
}
效果如下
走到这一步,B里面有A,它已完成。
但是很不幸,A里面的B还是null,我们第三步会继续完成这个设置
思考一下:
如果不用三级,我们直接用2级也能实现,但是3级我们说它是一个Factory,里面可以在创建的前
后嵌入我们的代码,和前后置处理器,Aop之类的操作就发生在这里
而2级存放的是bean实例,没这么多扩展的可能性,如果仅仅用于bean循环创建,倒是可以
总结:
1、如果不调用后置,返回的bean和三级缓存一样
2、如果调用后置,返回的就是代理对象
3、这就是三级缓存设计的巧妙之处!!!!Map<String, ObjectFactory<?>>
变化过程3-3:如下图:
步骤:
此时, BeanB里面已经注入了BeanA,它自己完成并进入了一级缓存
要注意,它的完成是被动的结果,也就是A需要它,临时先腾出时间创建了它
接下来,BeanA 还要继续自己的流程,然后populateBean方法将BeanB注入到自己里
最后,BeanA 进一级缓存,删除之前的二级
整个流程完成!
2)三级缓存解决方案总结
简化版
序列图
三级缓存解决循环依赖过程(回顾)
1、BeanA经过gdcd方法、放入到3级缓存、如果有循环依赖BeanB,重复执行gdcd方法
2、直到发现了它也需要A,此时再调用A初始化,A发现三级缓存有,拿A用工厂创建临时对象(半成品 没有属性),并且清楚三级缓存,并把这个半成品放到二级缓存中
3、然后半成品A注入进BeanB, BeanB完事进一级缓存,此时BeanB持有BeanA
4、接下来,继续完成BeanA剩下的操作,取BeanB填充进BeanA,将BeanA放到一级缓存,完成!
伪代码,循环依赖流程一览,都是关键步骤,不能再简化了
建议粘贴到vscode等编辑器里查看,因为……它层级太tmd深了!
getBean("A"){
doGetBean("A"){
a = getSingleton("A"){
a = singletonObjects(); //查1级缓存,null
if("创建过3级缓存"){ //不成立
//忽略
}
return a;
}; // A第一次,null
if(a == null){
a = getSingleton("A" , ObjectFactory of){
a = of.getObject() -> { //lambda表达式
createBean("A"){
doCreateBean("A"){
createBeanInstance("A"); // A 实例化
addSingletonFactory("A"); // A 放入3级缓存
populateBean("A"){
//A 需要B,进入B的getBean
b = getBean("B"){
doGetBean("B"){
b = getSingleton("B"); // B第一次,null
if(b == null){
b = getSingleton("B", ObjectFactory of){
b = of.getObject() -> {
createBean("B"){
doCreateBean("B"){
createBeanInstance("B"); // B 实例化
addSingletonFactory("B"); // B 放入3级缓存
populateBean("B"){
//B 需要A,2次进入A的getBean
a = getBean("A"){
doGetBean("A"){
a = getSingleton("A"){
a = singletonObjects(); //查1级缓存,null
if("创建过3级缓存"){ //成立!
a = singletonFactory.getObject("A"); // 取3级缓存,生成a
earlySingletonObjects.put("A", a); //放入 2级缓存
singletonFactories.remove("A"); //移除3级缓存
return a;
}
}; // A第二次,不是null,但是半成品,还待在2级缓存里
} // end doGetBean("A")
} // end getBean("A")
} // end populate B
initializeBean("B",b); // B后置处理器
} // end doCreateBean B
} // end createBean B
} // end lambda B
// B 创建完成,并且是完整的,虽然它里面的A还是半成品,但不影响它进入1级
addSingleton("B",b) ; // 清除3级缓存,进入1级
); // end getSingleton("B",factory)
} // end if(b==null);
return b;
} // end doGetBean("B")
} // end getBean("B")
} // end populateBean("A")
initializeBean("A"); // A 后置处理器
} //end doCreateBean("A")
} //end crateBean("A")
} // end lambda A
addSingleton("A" , a) // 清除2、3级,放入1级
} // end getSingleton("A",factory)
} // end if(a == null)
return a;
} //end doGetBean("A")
}//end getBean("A")
总结
可以发现,通过spring的三级缓存完美解决了循环依赖
Spring处理机制很聪明;它先扫描一遍Bean,先放到一个容器(3级缓存待命)
此时也不知道是否存在循环依赖,先放到三级缓存再说
等到设置属性的时候,取对应的属性bean去(此时才发现有了循环依赖) ,在放到第二个容器(2级缓存)
继续,然后从二级缓存拿出进行填充(注入)
填充完毕,将自己放到一级缓存(这个bean是被动创建出来的,因为别人需要它,结果它先完成了)
然后不断循环外层,处理最原始要创建的那个bean
为什么设计三级?二级缓存能否解决循环依赖?
可以解决。
虽然二级缓存能解决循环依赖,但是使用不了aop了,也就是扩展点没有了
在上面的方法getEarlyBeanReference中我们做了详细的介绍
回顾下
AbstractAutowireCapableBeanFactory.getEarlyBeanReference
//获取早期引用对象,放到三级缓存,getObject的时候调用
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
//是否存在实现InstantiationAwareBeanPostProcessors接口的类
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//循环所有Bean后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
//重点:开始创建AOP代理,
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
//总结
//1、如果不调用后置,返回的bean和三级缓存一样
//2、如果调用后置,返回的就是代理对象
//3、这就是三级缓存设计的巧妙之处!!!!Map<String, ObjectFactory<?>>
// 结论:虽然二级缓存能解决循环依赖,但是使用不了aop了,也就是扩展点没有了
return exposedObject;
}
总结下:
1、如果不调用后置处理器,返回的Bean和三级缓存一样,都是实例化、普通的Bean
2、如果调用后置,返回的就是代理对象,不是普通的Bean了
其实;这就是三级缓存设计的巧妙之处
那为什么要2级呢? 不能直接放入1级吗?
不能!
A-B-A中,第二次A的时候,A还是个半成品,不能放入1级
以上面为例,A在进入2级缓存的时候,它里面的B还是个null !
如果放入1级,被其他使用的地方取走,会引发问题,比如空指针
4 IoC用到的那些设计模式
4.1 工厂
工厂模式(Factory Pattern)提供了一种创建对象的最佳方式。
工厂模式(Factory Pattern)分为三种
1、简单工厂
2、工厂方法
3、抽象工厂
- 简单工厂模式
ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:application.xml");\
UserService userService = context.getBean(UserService.class);
简单工厂模式对对象创建管理方式最为简单,因为其仅仅简单的对不同类对象的创建进行了一层简单的封装
定义接口IPhone
public interface Phone {
void make();
}
实现类
public class MiPhone implements Phone{
public MiPhone(){
this.make();
}
@Override
public void make() {
System.out.println("生成小米手机");
}
}
实现类
public class IPhone implements Phone{
public IPhone() {
this.make();
}
@Override
public void make() {
System.out.println("生成苹果手机");
}
}
定义工厂类并且测试
public class PhoneFactory {
public Phone makePhone(String phoneType){
if (phoneType.equalsIgnoreCase("MiPhone")){
return new MiPhone();
}else if(phoneType.equalsIgnoreCase("iPhone")){
return new IPhone();
}
return null;
}
public static void main(String[] args) {
PhoneFactory factory = new PhoneFactory();
Phone miPhone = factory.makePhone("MiPhone");
IPhone iPhone = (IPhone) factory.makePhone("iPhone");
}
}
4.2 模板
模板模式(Template Pattern):基于抽象类的,核心是封装算法
Spring核心方法refresh就是典型的模板方法
org.springframework.context.support.AbstractApplicationContext#refresh
模板设计模式—
模板方法定义了一个算法的步骤,并允许子类为一个或多个步骤提供具体实现
//模板模式
public abstract class TemplatePattern {
protected abstract void step1();
protected abstract void step2();
protected abstract void step3();
protected abstract void step4();
//模板方法
public final void refresh(){
//此处也可以加入当前类的一个方法实现,例如init()
step1();
step2();
step3();
step4();
}
}
定义子类
public class SubTemplatePattern extends TemplatePattern {
@Override
protected void step1() {
System.out.println("1111111111");
}
@Override
protected void step2() {
System.out.println("2222222222");
}
@Override
protected void step3() {
System.out.println("3333333333");
}
@Override
protected void step4() {
System.out.println("4444444444");
}
public static void main(String[] args) {
SubTemplatePattern subTemplatePattern = new SubTemplatePattern();
subTemplatePattern.refresh();
}
}
4.3 观察者
什么是观察者模式
观察者模式(Observer Pattern):当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知依赖它的对象。
Spring 的事件机制就是具体的观察者模式的实现
spring中的多播与事件 AbstractApplicationContext#initApplicationEventMulticaster
AbstractApplicationContext#registerListeners
观察者模式有哪些角色?
事件 ApplicationEvent 是所有事件对象的父类,继承JDK的EventObject
事件监听 ApplicationListener ,也就是观察者对象,继承自 JDK 的 EventListener ,可以监听到
事件;该类中只有一个方法 onApplicationEvent 。当监听的事件发生后该方法会被执行。
事件发布 ApplicationContext , 实现事件的发布。
(发布事件)
or=========
Spring中的多播
事件发布 ApplicationEventMulticaster ,用于事件监听器的注册和事件的广播。
//在Spring 中使用事件监听机制(事件、监听、发布)
//定义事件
//执行顺序
//1、进入到事件源的有参数构造器
//2、发布事件
//3、进入到监听器类---one
//4、进入到事件源的方法
//5、进入到监听器类---two
//6、进入到事件源的方法
public class MessageSourceEvent extends AppletEvent {
public MessageSourceEvent(Object source, int id, Object argument) {
super(source, id, argument);
System.out.println("进入到事件源的有参数构造器");
}
public void print(){
System.out.println("进入到事件源的方法");
}
}
有了事件之后还需要自定义一个监听用来接收监听到事件,自定义ApplicationContextListener监听 需要交给Spring容器管理, 实现ApplicationListener接口并且重写onApplicationEvent方法,
监听一
//在Spring 中使用事件监听机制(事件、监听、发布)
//监听类,在spring配置文件中,注册事件类和监听类
public class ApplicationContextListener implements ApplicationListener {
@Override
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof MessageSourceEvent) {
System.out.println("进入到监听器类---one");
MessageSourceEvent myEvent = (MessageSourceEvent) event;
myEvent.print();
}
}
}
监听二
//在Spring 中使用事件监听机制(事件、监听、发布)
//监听类,在spring配置文件中,注册事件类和监听类
public class ApplicationContextListener implements ApplicationListener {
@Override
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof MessageSourceEvent) {
System.out.println("进入到监听器类---two");
MessageSourceEvent myEvent = (MessageSourceEvent) event;
myEvent.print();
}
}
}
发布事件
//在Spring 中使用事件监听机制(事件、监听、发布)
//该类实现ApplicationContextAware接口,得到ApplicationContext对象
// 使用该对象的publishEvent方法发布事件
public class ApplicationContextListenerPubisher implements
ApplicationContextAware {
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext = applicationContext;
}
public void publishEvent(ApplicationEvent event) {
System.out.println("发布事件");
applicationContext.publishEvent(event);
}
}
配置文件
<!-- Spirng中的事件>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -->
<!--<bean id="messageSourceEvent"
class="com.spring.test.pattern.observer.MessageSourceEvent" />-->
<bean id="applicationContextListener"
class="com.spring.test.pattern.observer.ApplicationContextListener"/>
<bean id="applicationContextListenerTwo"
class="com.spring.test.pattern.observer.ApplicationContextListenerTwo"/>
<bean id="applicationContextListenerPubisher"
class="com.spring.test.pattern.observer.ApplicationContextListenerPubisher"/>
<!-- Spirng中的事件>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -->
测试
//总结 :使用bean工厂发布和使用多播器效果是一样的
public class Test {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("classpath*:application.xml");
//***************使用spring的多播器发布**********************
ApplicationEventMulticaster applicationEventMulticaster =
(ApplicationEventMulticaster) context.getBean("applicationEventMulticaster");
applicationEventMulticaster.multicastEvent(new MessageSourceEvent("测试..."));
//***************使用BeanFactory的publishEvent发布*********************
// ApplicationContextListenerPubisher myPubisher =(ApplicationContextListenerPubisher)
//context.getBean("applicationContextListenerPubisher");
//myPubisher.publishEvent(new MessageSourceEvent("测试..."));
}
}
多播发布
工厂发布
总结:
1、spring的事件驱动模型使用的是 观察者模式
2、通过ApplicationEvent抽象类和ApplicationListener接口,可以实现事件处理
3、ApplicationEventMulticaster事件广播器实现了监听器的注册,一般不需要我们实现,只需要显示的调用 applicationcontext.publisherEvent方法即可
4、使用bean工厂发布和使用多播器效果是一样的
总结
// 模板方法(抽象类下定义refresh模板),核心方法
//断点查看
@Override
public void refresh() throws BeansException, IllegalStateException {
// synchronized块锁(monitorenter --monitorexit)
// 不然 refresh() 还没结束,又来个启动或销毁容器的操作
// startupShutdownMonitor就是个空对象,锁
synchronized (this.startupShutdownMonitor) {
//1、【准备刷新】,设置了几个变量,也是准备工作
prepareRefresh(); // ===>
// 2、【获得新的bean工厂】关键步骤,重点!
//2.1、关闭旧的 BeanFactory
//2.2、创建新的 BeanFactory(DefaluListbaleBeanFactory)
//2.3、解析xml/加载 Bean 定义、注册 Bean定义到beanFactory(不初始化)
//2.4、返回全新的工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // ===> 好戏开始
//3、【bean工厂前置操作 】为BeanFactory配置容器特性
// 例如类加载器、表达式解析器、注册默认环境bean、后置管理器
prepareBeanFactory(beanFactory); // ===>
try {
// 4、【bean工厂后置操作】此处为空方法,如果子类需要,自己去实现
postProcessBeanFactory(beanFactory); // ===> 空的!
//5、【调用bean工厂后置处理器】,开始调用我们自己实现的接口
//目标:
//调用顺序一:先bean定义注册后置处理器
//调用顺序二:后bean工厂后置处理器
invokeBeanFactoryPostProcessors(beanFactory); // ===> 重头戏
//6、【注册bean后置处理器】只是注册,但是还不会调用
//逻辑:找出所有实现BeanPostProcessor接口的类,分类、排序、注册
registerBeanPostProcessors(beanFactory); // ===> 关键点
// Initialize message source for this context.
//7、【初始化消息源】国际化问题i18n,参照https://nacos.io/
initMessageSource(); // ===> 就是往factory加了个single bean
// Initialize event multicaster for this context.
//8、【初始化事件广播器】初始化自定义的事件监听多路广播器
// 如果需要发布事件,就调它的multicastEvent方法
// 把事件广播给listeners,其实就是起一个线程来处理,把Event扔给listener处理
// (可以通过 SimpleApplicationEventMulticaster的代码来验证)
initApplicationEventMulticaster(); // ===> 同样,加了个bean
// 9、【刷新】这是个protected空方法,交给具体的子类来实现
// 可以在这里初始化一些特殊的 Bean
// (在初始化 singleton beans 之前)
onRefresh(); // ===> 空的!一般没人管它
//10、【注册监听器】,监听器需要实现 ApplicationListener 接口
// 也就是扫描这些实现了接口的类,给他放进广播器的列表中
// 其实就是个观察者模式,广播器接到事件的调用时,去循环listeners列表,
// 挨个调它们的onApplicationEvent方法,把event扔给它们。
registerListeners(); // ===> 观察者模式
//11、 【结束bean工厂初始化操作】
//1、初始化所有的 singleton beans,反射生成对象/填充
//2、 调用Bean的前置处理器和后置处理器
// 关键点:getBean方法里完成
finishBeanFactoryInitialization(beanFactory); // ===> 关键点!
// 12、结束refresh操作
// 发布事件与清除上下文环境
finishRefresh();
} catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
// 销毁已创建的Bean、以免有些 bean 会一直占用资源
destroyBeans();
// Reset 'active' flag.
// 取消refresh操作,重置容器的同步标识。
cancelRefresh(ex);
// 把异常往外抛
throw ex;
} finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
prepareRefresh()
//1、记录启动时间/设置开始标志
//2、子类属性扩展
//3、校验xml配置文件
//4、初始化早期发布的应用程序事件对象(仅仅是创建setg对象)
protected void prepareRefresh() {
// 设置3个属性的值,没啥可说的,一个时间,两个标记位
this.startupDate = System.currentTimeMillis();
//AtomicBoolean 类型,当前context是否被关闭
this.closed.set(false);
//AtomicBoolean 类型,当前context是否被激活,
// refresh失败出现异常的时候,会再改成false,可以多次refresh尝试
this.active.set(true);
//打条日志,看控制台
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
//2、protected,交给子类实现:在上下文环境中初始化属性源,非重点
initPropertySources(); // ===> 默认情况下其实为空
//3、校验配置文件的属性,合法性, 否则终止加载流程
getEnvironment().validateRequiredProperties();
//4、初始化一个set,用于记录应用程序事件
this.earlyApplicationEvents = new LinkedHashSet<>();
}
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory() (核心)
先说结论:
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
// 将 BeanDefinition 放到这个 map 中,这个 map 保存了所有的 BeanDefinition (重点!)
this.beanDefinitionMap.put(beanName, beanDefinition);
// 这是个 ArrayList,所以会按照 bean 配置的顺序保存每一个注册的 Bean 的名字
// 下一步初始化bean实例的时候,会按这里的顺序实例化bean
// 意义:允许你xml里人为指定bean的先后顺序,来减少前后依赖顺序颠倒的可能性
this.beanDefinitionNames.add(beanName);
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
this.manualSingletonNames.remove(beanName); //手动编码加入的bean,一般不会有
解析xml并放入Map中 key是beanId,value是BeanDefinition(解析出来的属性)
//1、关闭旧的 BeanFactory
//2、创建新的 BeanFactory(DefaluListbaleBeanFactory)
//3、解析xml/加载 Bean 定义、注册 Bean定义到beanFactory(未初始化)
//4、返回全新的工厂
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// (c)关闭旧的 BeanFactory (如果有),创建新的 BeanFactory,加载 Bean 定义、注册 Bean 等
refreshBeanFactory(); // ===> 主方法,come on!
// 返回刚刚通过解析创建的 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
然后是重点了
//刷新bean工厂
//1、销毁bean
//2、关闭bean工厂
//3、创建一个新的bean(DefaultListableBeanFactory)
//4、加载 Bean 到 BeanFactory 中
@Override
protected final void refreshBeanFactory() throws BeansException {
// 如果 ApplicationContext中已经加载过 BeanFactory 了,销毁所有 Bean,关闭 BeanFactory
//这些操作都需要加sync锁
if (hasBeanFactory()) {
//销毁bean
destroyBeans();
//关闭bean工厂
closeBeanFactory();
}
try {
//初始化一个 DefaultListableBeanFactory(new一下)
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 设置标识
beanFactory.setSerializationId(getId());
// 设置两个选项:
//1、设置循环依赖
//2、设置Bean覆盖
customizeBeanFactory(beanFactory); // ===>
//*****************此处需要了解 BeanDefinition类具体干了哪些事情*************************
// 非常重要,目标如下
// 1、通过BeanDefinitionReader解析xml为Document
// 2、将Document注册到BeanFactory 中(这时候只是bean的一些定义,还未初始化)
// 在DefaultListableBeanFactory.registerBeanDefinition注册
//来回loadBeanDefinitions方法,debug容易调晕。直到看到doLoadBeanDefinition
loadBeanDefinitions(beanFactory); // ===>
synchronized (this.beanFactoryMonitor) {
//beanDefinitionMap有值了
//beanDefinitionNames有值了
//注册成功
this.beanFactory = beanFactory;
}
//********************************************************************************
} catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
跑到后面就是解析了
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
//skip,文件转换成DOM树,注意这里,只是一个xml,前面for循环在调用当前的方法
Document doc = doLoadDocument(inputSource, resource);
//进入: xml变成了Document!!!!!!!!!!!!
return registerBeanDefinitions(doc, resource); // ===>
} catch (BeanDefinitionStoreException ex) {
throw ex;
} catch (SAXParseException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
} catch (SAXException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
} catch (ParserConfigurationException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
} catch (IOException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
}
解析之前区分
//解析beans下的xml节点,调用不同的方法来处理不同的节点
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// default namespace 涉及到的就四个标签 <import />、<alias />、<bean /> 和 <beans />,
//这里从root取出来,比如默认的命名空间就是http://www.springframework.org/schema/beans
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
//下面有两个分支
if (delegate.isDefaultNamespace(ele)) {
//分支1:代表解析标准元素 <import />、<alias />、<bean />、<beans /> 这几个
//标准节点
parseDefaultElement(ele, delegate); // ===>
} else {
//分支2:代表解析 <mvc />、<task />、<context />、<aop /> 、<component-scan />等
//特殊节点,比如dubbo.xml里面自定义的xml节点、再比如 scan 扫包
// 找到对应的parser去加载对应的类ComponentScanBeanDefinitionParser
// 所以无论bean直接定义,还是component-scan,其实都是这里生效。
delegate.parseCustomElement(ele);
}
}
}
} else {
//其他namespace的xml,一般不往这里跑
delegate.parseCustomElement(root);
}
}
//标签解析
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
// 处理 <import /> 标签,<import resource="classpath:applicationContext-datasource.xml" />
importBeanDefinitionResource(ele);
} else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
// 处理 <alias /> 标签定义,其实就是给bean的id为abc的这个bean设置别名为af
// <alias name="abc" alias="af"/>
processAliasRegistration(ele);
} else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
// 处理 <bean /> 标签定义,beanDefinitionMap.put!!!!!!!!!!!!!!
processBeanDefinition(ele, delegate); // ===> 核心,也就是我们的bean标签
} else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// 如果碰到的是嵌套的 <beans /> 标签,需要递归
doRegisterBeanDefinitions(ele);
}
}
上面是解析,然后是注册到BeanFactory
// 返回从当前配置文件加载了多少数量的 Bean
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
//进入,将Document注册到BeanFactory!!!!!!!!!!!
documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); // ===> registerBeanDefinitions
return getRegistry().getBeanDefinitionCount() - countBefore;
}
prepareBeanFactory(beanFactory);
初始化BeanFactory的参数
//目标:
//1、设置 BeanFactory 的类加载器 - 下一步就要初始化类了!
//2、设置 BeanFactory 的表达式解析器
//3、设置 BeanFactory 的属性编辑器
//4、智能注册
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置 BeanFactory 的类加载器 BeanFactory 需要加载类,也就需要类加载器,
beanFactory.setBeanClassLoader(getClassLoader());
// 设置EL表达式解析器(Bean初始化完成后填充属性时会用到)
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//设置属性注册解析器PropertyEditor
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理
// 从而在Aware接口实现类中的注入applicationContext
// 我们写的一堆xxxAware就是依靠这里才能得以生效。
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//忽略依赖接口
// skip:下面几行的意思就是,如果某个 bean 依赖于以下几个接口的实现类,在自动装配的时候忽略它们,
// Spring 会通过其他方式来处理这些依赖。
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
//嵌入式值解析感知器
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
/**
* skip:下面几行就是为特殊的几个 bean 赋值,如果有 bean 依赖了以下几个接口,会注入这边相应的值,
*/
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 为监听器注册早期后置处理器;
// 如果是 ApplicationListener 的子类,
// 那么将其添加到 listener 列表中,可以理解成:注册事件监听器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
//*****************************智能注册***************************************************
//如果当前BeanFactory包含loadTimeWeaver Bean,说明存在类加载期织入AspectJ,
//则把当前BeanFactory交给类加载期BeanPostProcessor实现类LoadTimeWeaverAwareProcessor来处理
// 从而实现类加载期织入AspectJ的目的。
//代码织入是3种方式
//编译期织入(AspectJ)、类加载期(AspectJ)织入和运行期织入(Spring AOP)
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 如果没有定义 "environment" 这个 bean,那么 Spring 会 "手动" 注册一个
// Register default environment beans.
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
//进入
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); // ===>
}
// 同上!手动 systemProperties
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
//进入
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); // ===>
}
// 同上!手动 systemEnvironment
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
//进入
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
//断点到这里,可以查看debugger里的beanFactory设置了几个信息(就干了这么点事!)
// ignoreDependencyInterface , manualSingletonNames , registeredSingletons , singleObjects
}
invokeBeanFactoryPostProcessors(beanFactory)(核心)
spring的插件机制
Processors基本是处理器,提供扩展的
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//此处反射调用了BeanFctory后置处理器,近200 Line
//调用顺序一:bean定义注册后置处理器
//调用顺序二:bean工厂后置处理器
//也会调用getBean---doGetBean---createBean----doCreateBean
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); // ===>
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
调用invoke
//后置处理器注册委托类
class PostProcessorRegistrationDelegate {
//目标:
// 这里我们做两个简称:BF后置=BeanFactoryPostProcessor接口,BD后置=BeanDefinitionRegistryPostProcessor接口
// 其中 BD后置 extends BF后置,这个可以通过查看BD接口的源码得到验证!所以调用顺序如下
//1、查找顺序:参数传进来的 - Factory中的BD后置 - Factory中的BF后置
// 2、在调BD后置的时候,由于BD继承了BF,所以先调BD中子接口方法,后调继承的BF方法
// 3、无论factory中的BD还是BF,都有可能实现PriorityOrdered或者Ordered接口
// 那么优先级将是这样的:PriorityOrdered - Ordered - 没实现的
//
// 下面逐步debug来验证上述的执行顺序!
//
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
Set<String> processedBeans = new HashSet<>();
// 为true:
// beanFactory为DefaultListableBeanFactory,
// 而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口,因此这边为true
//通过查看接口的实现类,可以验证!
if (beanFactory instanceof BeanDefinitionRegistry) {
//进入
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
//定义俩临时变量集合,一个存放BF后置处理器,一个存放BD后置处理器
// 临时变量,用于存放BeanFactoryPostProcessor(工厂)
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
// 临时变量,用于存放BeanDefinitionRegistryPostProcessor
// (实际上BD接口继承了上面的BF接口,可以通过源码验证)
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();
// 2.首先处理入参中传进来的beanFactoryPostProcessors
// 这些Processer是直接add到Context的属性上的,这里为空,不管他
// 参考 AbstractApplicationContext.beanFactoryPostProcessors 属性
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
// 2.1 如果是BeanDefinitionRegistryPostProcessor的实现类,调子接口方法
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 2.1.1 先执行它实现的 postProcessBeanDefinitionRegistry方法(BD接口里定义,BF里没有)
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 2.1.2 然后添加到registryProcessors临时变量(用于最后执行BF的postProcessBeanFactory方法)
registryProcessors.add(registryProcessor);
} else {
// 2.2 否则,只是普通的BeanFactoryPostProcessor
// 2.2.1 那就直接添加到regularPostProcessors临时变量去(用于最后执行postProcessBeanFactory方法)
regularPostProcessors.add(postProcessor);
}
}
// 3.调用所有实现PriorityOrdered接口的BD后置实现类
// 临时变量用于保存找到的的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 3.1 先找出所有实现了BD后置接口的Bean的beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 3.2 遍历这些bean
for (String ppName : postProcessorNames) {
// 3.3 过滤实现了PriorityOrdered接口的,其他的不要
// PriorityOrdered接口是空的,继承了Ordered接口,Ordered里有个getOrder方法标识了顺序
// 这个接口的意义在于,可以允许你定义带优先级的BD后置处理器,spring会按你的顺序执行
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // ===> PriorityOrdered接口方法
//3.3 放到临时变量里去,只放实现了PriorityOrdered接口的
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 3.4 将要被执行的bean name加入processedBeans,避免后续重复执行
processedBeans.add(ppName);
}
}
// 3.6 进行排序(根据getOrder方法的返回值,从小到大排序。注意看控制台,看执行后current里的顺序)
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 3.7 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
registryProcessors.addAll(currentRegistryProcessors);
// 3.8 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
// 注意这货已经排过序,所以会按照排好的次序执行,这就实现了自定义后置的有序执行!!!
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 3.9 执行完毕后, 清空currentRegistryProcessors
currentRegistryProcessors.clear();
// 4.上面是实现了PriorityOrdered的,这步是Ordered接口的(过程跟上面的步骤3基本一样)
// 4.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类, 这边重复查找是因为执行完上面的
// 可能会有变动, 因此重新查一遍
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 校验是否还未执行过!关键点:上一步已经执行过的name放入了processedBeans
// 所以这一步不会发生重复执行行为,要知道,PriorityOrdered继承了Ordered,必须排重
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 一个德行,先执行完postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 5.最后, 调用所有剩下的BD,这些都没实现排序接口
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 5.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 5.2 跳过已经执行过的
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
// 5.3 如果有BeanDefinitionRegistryPostProcessor被执行, 则有可能会产生新的BeanDefinitionRegistryPostProcessor,
// 因此这边将reiterate赋值为true, 代表需要再循环查找一次
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 还是一个德行,先把子接口BD里的执行完
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// 6.调用所有BD后置处理器里的postProcessBeanFactory方法,其实这个方法是它从BF后置接口继承过来的
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 7.最后, 调用BF后置处理器的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
} else {
// Invoke factory processors registered with the context instance.
//在上下文中注册的BF后置处理器
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// 到这里 , 参数传进来的和容器中的所有BD后置处理器已经全部处理完毕,
// 下面开始处理容器中的所有BF后置处理器
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
//还是处理三类,从前到后。PriorityOrdered - Ordered - 普通的
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
} else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
执行顺序
BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
PriorityOrdered extends Ordered
1.BD先实现自己的postProcessBeanDefinitionRegistry方法
2.BD实现父类继承的postProcessBeanFactory方法
3.DF实现自己的postProcessBeanFactory方法
下面源码中也是一样先调用PriorityOrdered执行,再调用Ordered执行
order越小越是最先执行
带PriorityOrdered=99的BD后置,postProcessBeanDefinitionRegistry被调用
带Ordered=0的BD后置,postProcessBeanDefinitionRegistry被调用
带Ordered=99的BD后置,postProcessBeanDefinitionRegistry被调用
不带Order的BD后置,postProcessBeanDefinitionRegistry被调用
带PriorityOrdered=99的BD后置,postProcessBeanFactory被调用
带Ordered=0的BD后置,postProcessBeanFactory被调用
带Ordered=99的BD后置,postProcessBeanFactory被调用
不带Order的BD后置,postProcessBeanFactory被调用
BF后置处理器,postProcessBeanFactory被调用
initMessageSource()
往factory加了个single bean
//国际化,就是加了个bean到factory的single中:MessageSource
protected void initMessageSource() {
//获取Bean工厂,一般是DefaultListBeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//首先判断是否已有xml文件定义了id为messageSource的bean对象,一般不进这里
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
//如果有,则从Bean工厂得到这个bean对象
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
//当父类Bean工厂不为空,并且这个bean对象是HierarchicalMessageSource类型
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
//设置父类MessageSource,此处设置内部的parent messageSource
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isDebugEnabled()) {
logger.debug("Using MessageSource [" + this.messageSource + "]");
}
} else {
//如果不包含:创建一个新的DelegatingMessageSource(委托/授权消息源)
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
//将这个messageSource实例注册到Bean工厂中
//先去一级缓存去找,没有,直接放到一级缓存。移除二级三级缓存
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
"': using default [" + this.messageSource + "]");
}
}
}
initApplicationEventMulticaster()
//初始化自定义的事件监听多路广播器
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
/**
* 判断容器中是否存在beanName为applicationEventMulticaster的bd
* ==null
*/
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isDebugEnabled()) {
logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
} else {
/**
* 如果没有,则默认采用SimpleApplicationEventMulticaster行事件的广播
*/
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
//将多播注册到Bean工厂,bean的id是 applicationEventMulticaster,将来可以用这个来获取
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
"': using default [" + this.applicationEventMulticaster + "]");
}
}
}
registerListeners()
【注册监听器】,监听器需要实现 ApplicationListener 接口
//目标:查找所有实现了ApplicationListener,然后进行注册
//1、去集合applicationListeners查找
//2、去bean工厂找到实现ApplicationListener接口的bean
//3、去this.earlyApplicationEvents;准备刷新(启动第一步设置)
protected void registerListeners() {
// 去集合applicationListeners查找;找到实现ApplicationListener的bean
for (ApplicationListener<?> listener : getApplicationListeners()) {
//增加监听
getApplicationEventMulticaster().addApplicationListener(listener);
}
//在去bean工厂找到实现ApplicationListener接口的bean,debug一下看值!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
//增加监听
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
//this.earlyApplicationEvents在第一步prepareRefresh()初始化的那个集合
// 如果有事件被添加进了这集合的话,现在开始处理,将它们广播出去,这里是空的。
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null; //处理完后,清空
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent); // ===> 发布事件,观察者模式
}
}
}
finishBeanFactoryInitialization(beanFactory) (核心)
【结束bean工厂初始化操作】
1、初始化所有的 singleton beans,反射生成对象/填充
2、 调用Bean的前置处理器和后置处理器
关键点:getBean方法里完成
//1、设置辅助器:例如:解析器、转换器、类装载器
//2、实例化(反射)
//3、填充
//4、调用前置、后置处理器
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 1、类型转换器,不重要,往下
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// 2. 注册解析器
//这货用于读取配置文件的内容,就是 ${xxx} 那些符号,解析为properties文件里的值
// 不重要,继续往下
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 处理 @EnableLoadTimeWeaving 或 <context:load-time-weaver/> 标记的类
// 作用:jvm加载时织入某些类,空的,继续
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
//临时类加载器设置为空
beanFactory.setTempClassLoader(null);
// 【冻结配置】冻结所有bean定义,其实就是设置冻结属性变量为true
// 注册的bean定义不会被修改或进一步后处理,因为马上要创建 Bean 实例对象了
beanFactory.freezeConfiguration();
//备实例化所有的单例bean;
// 调用bean前置、后置处理器 , 【重点】
beanFactory.preInstantiateSingletons(); // ===>
}
调用preInstantiateSingletons()
//1、实例化(反射)
//2、填充
//3、调用前置、后置处理器
@Override
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// this.beanDefinitionNames! 创建factory时赋的值。
// 现在该拿出来用了,debug一下值,看看有没有我们前面的那些bean
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 触发所有的非懒加载的 singleton beans 的初始化操作
// 不是singleton的不需要一开始就初始化。比如request时候随用随时创建.
for (String beanName : beanNames) {
// 根据name返回BD
// 其实就是bean xml里配的各种属性定义。
// Merged意义在于处理bean之间的父子继承关系,处理属性继承和覆盖(如果有的话)。
// 重要!
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 接下来初始化
// 必须是非抽象、非懒加载的、和singletons。
// 如果配置了 'abstract = true',那是不需要初始化的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 处理 FactoryBean,此处不是工厂bean
if (isFactoryBean(beanName)) {
// FactoryBean 话,在 beanName 前面加上 ‘&’ 符号。
// 再调用 getBean,这是个约定
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
// 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现,此处忽略,直接跳过
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) () ->
((SmartFactoryBean<?>) factory).isEagerInit(),
getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName); //最终调的是 getBean
}
} else {
// 调用前置后置处理器、实例化、填充、反射,都藏在这个getBean里!
// 我们先返回,把factory的流程走完,这个过程后面拿出来详细讲【重点!】。
//getBean---doGetBean---createBean---doCreateBean
getBean(beanName); // ===> 工厂阶段留个尾巴,getBean小节详细讲
}
}
}
// 到这里说明所有的 singleton beans 已经完成了初始化
// 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的,
// 那么在这里得到回调它的afterSingletonsInstantiated方法,
// 一般没人用,忽略
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
getBean()
doGetBean createBean doCreateBean createBean
1.从缓存中取
2.没有创建bean
3.开始创建bean
4.创建bean
和redis类似,redis中查询不到从数据库中select查,放入缓存中
getBean()
//1、实例化(反射)
//2、填充
//3、调用前置、后置处理器
@Override
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// this.beanDefinitionNames! 创建factory时赋的值。
// 现在该拿出来用了,debug一下值,看看有没有我们前面的那些bean
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 触发所有的非懒加载的 singleton beans 的初始化操作
// 不是singleton的不需要一开始就初始化。比如request时候随用随时创建.
for (String beanName : beanNames) {
// 根据name返回BD
// 其实就是bean xml里配的各种属性定义。
// Merged意义在于处理bean之间的父子继承关系,处理属性继承和覆盖(如果有的话)。
// 重要!
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 接下来初始化
// 必须是非抽象、非懒加载的、和singletons。
// 如果配置了 'abstract = true',那是不需要初始化的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 处理 FactoryBean,此处不是工厂bean
if (isFactoryBean(beanName)) {
// FactoryBean 话,在 beanName 前面加上 ‘&’ 符号。
// 再调用 getBean,这是个约定
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
// 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现,此处忽略,直接跳过
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) () ->
((SmartFactoryBean<?>) factory).isEagerInit(),
getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName); //最终调的是 getBean
}
} else {
// 调用前置后置处理器、实例化、填充、反射,都藏在这个getBean里!
// 我们先返回,把factory的流程走完,这个过程后面拿出来详细讲【重点!】。
//getBean---doGetBean---createBean---doCreateBean
getBean(beanName); // ===> 工厂阶段留个尾巴,getBean小节详细讲
}
}
}
// 到这里说明所有的 singleton beans 已经完成了初始化
// 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的,
// 那么在这里得到回调它的afterSingletonsInstantiated方法,
// 一般没人用,忽略
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
doGetBean
//getBean---doGetBean---createBean---doCreateBean
//两大处调用:
// 1、从 BeanFactory 中获取一个 Bean
// 2、ioC容器初始化调用(先方法5:反射Bean工厂处理器;后方法11实例化)
//生成代理的时候是从方法11开始
// 已经初始化过了就从容器中直接返回,否则就先初始化再返回
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 转化beanname,是否&开头,skip
final String beanName = transformedBeanName(name);
// 临时变量,这个是返回值
Object bean;
//先拿--拿不到在创建, 循环依赖闭环可以拿到;1级 2级 3级都会过一遍
Object sharedInstance = getSingleton(beanName); // ===>
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
} else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 下面这个方法:如果是普通 Bean 的话,直接返回 sharedInstance,
// 如果是 FactoryBean 的话,返回它创建的那个实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
//没有创建过原型类型的bean
if (isPrototypeCurrentlyInCreation(beanName)) {
// 当前线程已经创建过了此 beanName 的 prototype 类型的 bean,那么抛异常
throw new BeanCurrentlyInCreationException(beanName);
}
// null,检查一下这个 BeanDefinition 在容器中是否存在(初始化不存在)
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 不进入.
// 如果当前容器不存在这个 BeanDefinition,试试父容器中有没有
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
} else if (args != null) {
// Delegation to parent with explicit args.
// 返回父容器的查询结果
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// typeCheckOnly :传过来的参数,看字面意思就行,是不是只检查一下
// false,所以那就创建吧,将当前 beanName 放入一个 alreadyCreated 的 Set 集合中标记一下。
if (!typeCheckOnly) {
//将当前的bean存入到set集合alreadyCreated中
markBeanAsCreated(beanName);
}
try {
// 还记得不?处理bean的父子关系,封装成RootBD对象
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//就检查一下这个RootBeanDefinition是否为抽象的,如果是抛异常
checkMergedBeanDefinition(mbd, beanName, args);
// 先初始化依赖的所有 Bean,这个很好理解。
// 注意,这里的依赖指的是 depends-on 中定义的依赖
//例如:<bean id="manager" class="CacheManager" depends-on="sysinit"/>
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 检查是不是有循环依赖,显然互相配置depends-on是一件作死的事情!
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 将依赖关系记录下来,其实就是放到一个map里
registerDependentBean(dep, beanName);
// 先初始化被依赖项,仔细看!调回了getBean,从头开始创建dep去
getBean(dep);
}
}
// Create bean instance.
// 创建 singleton 的实例
if (mbd.isSingleton()) {
//bean实例化完后放到一1级缓存!后面给了个lambda表达式,函数式编程
// 说到底,这个getSingleton所做的就是借用了后面的createBean生成bean,并将它放入singleton缓存集合
sharedInstance = getSingleton(beanName, () -> { // ===> getSingleton
try {
// 执行创建 Bean!
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;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
// 创建 prototype 的实例
} else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
// 执行创建 Bean
prototypeInstance = createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
// 如果不是 singleton 和 prototype 的话,需要委托给相应的实现类来处理
} else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
} catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
} catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
createBean
//重点
//1、处理方法覆写
//2、处理bean的前置、后置处理器
//3、doCreateBean调用
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 确保 BeanDefinition 中的 Class 被加载
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// <lookup-method/>和 <replaced-method />
// 方法复写,不重要,略过
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//实现了InstantiationAwareBeanPostProcessor接口的处理器
// 注意这还不是我们自己定义的Bean后置处理器,它是BeanPostProcessor的一个子接口(看源码)
// 我们定义的那个的执行时机在下面!(看控制台,并没有打印)
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 重点!真正创建 bean的操作藏在这里!!!
Object beanInstance = doCreateBean(beanName, mbdToUse, args); // ===> 真实的创建过程,进去
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException ex) {
// A previously detected exception with proper bean creation context already...
throw ex;
} catch (ImplicitlyAppearedSingletonException ex) {
// An IllegalStateException to be communicated up to DefaultSingletonBeanRegistry...
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
doCreateBean
//重点关注三个方法
//1、创建 Bean 实例的 createBeanInstance(反射实例化ctor.newInstance,未注入)
//2、依赖注入的 populateBean 方法(bean 属性注入)
//3、回调方法 initializeBean(前置、后置)
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// BeanWrapper是对Bean的包装
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 方法一:实例化! Bean的构造函数在这里被调用!【关键点】!!
instanceWrapper = createBeanInstance(beanName, mbd, args); // ===> 反射来创建实例
}
// 返回这个对象包装的bean实例
final Object bean = instanceWrapper.getWrappedInstance();
// 返回包装的bean实例的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// skip,涉及接口:MergedBeanDefinitionPostProcessor,一个处理器,不管他
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
//当前工厂是否支持循环引用!如果不支持跳过,一般肯定要支持!
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//实例化完毕;【关键点】:设置三级缓存
// 实际效果是:beanName做key,value放了一个对象工厂(lambda表达式,函数式编程)
// 在你将来调这工厂的getObject来获取实际bean的时候,实际调用getEarlyBeanReference返回bean
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
// ===> getEarlyBeanReference: 将来获取对象的实际代码
// ===> addSingletonFactory: 设置三级缓存,可以理解设置了一个创建的方法,还没创建呢,将来调的时候再说
// 知道这么回事就行,接着往下走!
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//方法二:注入相关的属性!【关键点】
populateBean(beanName, mbd, instanceWrapper); // ===>
//方法三:(回调Bean的前置处理器、后置处理器)!
// 我们自己写的处理器在这里,注意看控制台! 【关键点】
exposedObject = initializeBean(beanName, exposedObject, mbd); // ===>
} catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
} else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
//depends on设置,不管他
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
//不管他,跳过
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
反射创建
//1、使用jdk实例化(重点关注BeanUtils.instantiateClass()
//2、使用cglib实例化
// 重点关注BeanUtils.instantiateClass反射实例化
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
// (进入)如果不存在方法覆写,那就使用 java 反射进行实例化,否则使用 CGLIB
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
//获取对象构造方法或者工厂方法(null)(xml中没配置)
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
//为null
if (constructorToUse == null) {
//使用jdk反射class com.spring.test.impl.UserServiceImpl
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
//通过匿名内部类使用反射获取构造方法
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) () -> clazz.getDeclaredConstructor());
}
else {
//返回构造函数,class com.spring.test.impl.UserServiceImpl()
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
// 【关键点】;利用构造方法进行实例化,ctor.newInstance(args)进行反射生成对象
return BeanUtils.instantiateClass(constructorToUse); // 往后追会追到 Reflection
}
else {
// Must generate CGLIB subclass.
// 存在方法覆写,利用 CGLIB 来完成实例化,需要依赖于 CGLIB 生成子类
return instantiateWithMethodInjection(bd, beanName, owner); // 往后追会追到CGlib
}
}
实例化完毕;【关键点】:设置三级缓存
实际效果是:beanName做key,value放了一个对象工厂(lambda表达式,函数式编程)
在你将来调这工厂的getObject来获取实际bean的时候,实际调用getEarlyBeanReference返回bean
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
===> getEarlyBeanReference: 将来获取对象的实际代码
===> addSingletonFactory: 设置三级缓存,可以理解设置了一个创建的方法,还没创建呢,将来调的时候再说
addSingletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
//实例化后、注入之前;获取早期引用对象getEarlyBeanReference,
// 放到三级缓存,注意,放进去的只是个ObjectFactory,它封装了bean的创建方法
// 但是还没创建,在getObject调用的时候才会产出实际的bean
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
** getEarlyBeanReference**
//获取早期引用对象,放到三级缓存,getObject的时候调用
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
//是否存在实现InstantiationAwareBeanPostProcessors接口的类
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//循环所有Bean后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
//重点:开始创建AOP代理,
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
//总结
//1、如果不调用后置,返回的bean和三级缓存一样
//2、如果调用后置,返回的就是代理对象
//3、这就是三级缓存设计的巧妙之处!!!!Map<String, ObjectFactory<?>>
// 结论:虽然二级缓存能解决循环依赖,但是使用不了aop了,也就是扩展点没有了
return exposedObject;
}
populateBean
注入属性
//属性注入目标
//1、注解注入
//2、set注入(xml--property)
//3、注入前的调InstantiationAwareBeanPostProcessor
//重点关注最后的:applyPropertyValues
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;
}
}
// 调用实现InstantiationAwareBeanPostProcessor接口的bean
// 这是最后的机会! 比如你要在属性注入前修改Bean的属性值
//再往下将会执行属性的注入,无法再修改了
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;
}
}
}
}
//如果不需要注入,直接return回去
if (!continueWithPropertyPopulation) {
return;
}
//下面开始注入……【关键点】
// 两种方式,byName , 或者 byType
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//是否通过名称注入
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 通过名字找到所有属性值
// 如果是 bean 依赖,先初始化依赖的 bean。【关键点!要理解循环依赖的操作先后】
// 注意这个方法只是把依赖关系捋一遍,并没有设置相关的值。赋值在最后!
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs); // ===> 可以找一下,里面藏着个getBean
}
// Add property values based on autowire by type if applicable.
// 通过类型装配
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs); // 和上面没多大差别,不管他,往下
}
pvs = newPvs;
}
//是否有InstantiationAwareBeanPostProcessor的bean,有的话执行
// 又是一个处理器,不管他,往下看关键点。
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 对采用 @Autowired、@Value 注解的依赖进行设值
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
//检查依赖关系
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
if (pvs != null) {
// 这里!!将属性注入到bean实例当中,这才是真正的属性赋值的地方【关键点】
//PVS:如果这个pvs在一级缓存,后续通过深度拷贝进行注入填充
applyPropertyValues(beanName, mbd, bw, pvs); // ===>
}
}
//正式注入
//目标
//1、创建列表梳理属性和值
//2、最后统一bw.setPropertyValues设置值
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
//巴拉巴拉一堆判断,不用管它,往下看!
if (pvs.isEmpty()) {
return;
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (System.getSecurityManager() != null) {
if (bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
}
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
bw.setPropertyValues(mpvs);
return;
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
} else {
original = Arrays.asList(pvs.getPropertyValues());
}
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// 创建一个列表,解析值的任何引用先放在这个列表里,下面统一赋值
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
} else {
//获取属性名称
String propertyName = pv.getName();
//获取属性值,通过debug查看属性值
Object originalValue = pv.getValue();
//是否有引用!有?调用getbean,这里没有,只是一个 name 的string 【关键点!】
// 循环依赖的时候肯定会经过这里,点进去debug,普通bean不需要!
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); // ===> 有bean引用的话,从头getBean创建引用的
//a有b (b有a)
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) { // 属性类型转换器,如果有定义的类型转换,就发生在这里 convertForProperty
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
} else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
} else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// 最后通过反射setXXXX()来设置属性值!!!【关键点】
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy)); // ===> 可以点进去试试,隐藏极深
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
回调Bean的前置处理器、后置处理器
//注意:
//1、调用实现Aware接口
//2、先调用bean的前置处理器
//3中间过程:调用bean(UserServiceImpl)的init方法
// 或者实现了 InitializingBean 接口的话调用 afterPropertiesSet() 方法
//4、后调用bean的后置处理器
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
} else {
// 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口
//设置下bean工厂和加载器
invokeAwareMethods(beanName, bean); // ===> 一堆set
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//调用Bean的前置处理器!我们自己实现的bean的processer在这里!
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); // ===>
}
try {
// 1、调用初始化方法, 处理 bean 中定义的 init-method,
// /2、如果 bean 实现了 InitializingBean 接口,调用 afterPropertiesSet() 方法
invokeInitMethods(beanName, wrappedBean, mbd); // ===>
} catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 调用Bean的后置管理器!aop也在这里偷偷做了手脚……注意aop调试时,看这句后wrappedBean的变化!
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); // ===> aop 进!ioc暂时跳过
}
return wrappedBean;
}