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;
}
543
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
