爱上源码，重学 Spring 之 IoC 深入源码

水深无声 2024-04-01 11:17 96阅读 0赞

回答：
    我们为什么要学习源码？
    1、知其然知其所以然
    2、站在巨人的肩膀上，提高自己的编码水平
    3、应付面试

### ![00934c84575d48439f616dd449f6b86d.jpeg][] ###

### 1.1 Spring 源码阅读小技巧 ###

1、类层次藏得太深，不要一个类一个类的去看，遇到方法该进就大胆的进

2、更不要一行一行的去看，看核心点，有些方法并不重要，不要跟它纠缠

3、看不懂的先不看，根据语义和返回值能知道这个方法达到了啥目的即可

4、只看核心接口（下面标注了重点的地方）和核心代码，有些地方也许你使用 spring 以来都没触发过

5、debug 跟步走，源码中给大家标注好了，见到 ”===>“ 就进去

进去之前，下一行打个断点，方便快速回到岔路口

进去之前，可以先点方法看源码，再 debug 跟进

6、广度优先，而非深度优先。先沿着主流程走，了解大概，再细化某些方法

7、认命。spring 里多少万行的代码，一部书都写不完。只能学关键点

**阅读源码目的**

加深理解 spring 的 bean 加载过程

面试吹牛 x

**江湖传说，spring 的类关系是这样的……**

### 1.2 IoC 初始化流程与继承关系 ###

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

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 流程简化图：**

> tips：
> 
> 下面的流转记不住没有关系
> 
> 在剖析源码的整个过程中，我们一直会拿着这个图和源码对照

**初始化：**

1、容器环境的初始化

2、Bean 工厂的初始化（IoC 容器启动首先会销毁旧工厂、旧 Bean、创建新的工厂）

**读取与定义**

读取：通过 BeanDefinitonReader 读取我们项目中的配置（application.xml）

定义：通过解析 xml 文件内容，将里面的 Bean 解析成 BeanDefinition（未实例化、未初始化）

**实例化与销毁**

Bean 实例化、初始化（注入）

销毁缓存等

**扩展点**

事件与多播、后置处理器

**复杂的流程关键点：**

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

2) 容器与工厂继承关系

> tips：
> 
> 别紧张，下面的继承记不住没有关系
> 
> 关注颜色标注的几个就可以

\*\* 目标：\*\* 简单理解 ioC 容器继承关系

**继承关系理解：**

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

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

3、**AnnotationConfigApplicationContext** 的构造函数扫描 classpath 中相关注解的类，主流程一样

课程中我们以最经典的 classpathXml 为例。

> Bean 工厂继承关系

**目标：**

ApplicationContext 和 BeanFactory 啥关系？

BeanFactory 和 FactoryBean 呢？

**总结：**

别害怕，上面的继承关系不用刻意去记住它

其实接触到的就最下面这个！

### 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();
    }

实现类

package com.spring.test.impl;
    
    import com.spring.test.service.UserService;
    
    public class UserServiceImpl implements UserService {
    	@Override
    	public String getName() {
    		return "Hello World";
    	}
    }

Main 代码如下

public class Test {
    	public static void main(String[] args) {
    		ApplicationContext context =
    				new ClassPathXmlApplicationContext("classpath*:application.xml");
    
    		UserService userService = context.getBean(UserService.class);
    		System.out.println(userService);
    		// 这句将输出: hello world
    		System.out.println(userService.getName());
    
    	}
    }

配置文件 application.xml（在 resources 中）配置如下：

<?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 id="userService" class="com.spring.test.impl.UserServiceImpl"/>
    </beans>

运行

输出如下
    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、获取环境（系统环境、jvm环境）
    		// 2、设置Placeholder占位符解析器
    		// 2、将xml的路径解析完存储到数组
    		setConfigLocations(configLocations);
    		//默认为true
    		if (refresh) {
    			//核心方法（模板）
    			refresh();
    		}
    	}

**重点步骤解析（断点跟踪讲解）**

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

2）预刷新

prepareRefresh ()【准备刷新】

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

**讲解重点（断点跟踪、类继承关系、架构图讲解）**

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

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、智能注册

> tips
> 
> 当前代码逻辑简单、且非核心

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 ();

> tips：
> 
> 就加了个 bean 进去，非核心步骤，跳过

9）初始化事件广播器

【初始化应用程序事件多路广播】initApplicationEventMulticaster ();

> tips：
> 
> 需要讲解观察者设计模式
> 
> 重点：就放了个 bean 进去， 到下面的 listener 再联调。

10）刷新

**【刷新】** onRefresh();

空的，交给子类实现：默认情况下不执行任何操作

// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
    onRefresh();
    
    不重要，跳过

11）注册监听器【重点】

\*\*【注册所有监听器】\*\*registerListeners ();

测试代码参考：MulticastTest

//获取所有实现了ApplicationListener，然后进行注册
    	//1、集合applicationListeners查找
    	//2、bean工厂找到实现ApplicationListener接口的bean
    	//3、this.earlyApplicationEvents；

> tips：
> 
> 需要讲解观察者设计模式
> 
> 重点：演示多播和容器发布

12）完成 bean 工厂【重点】

【完成 bean 工厂初始化操作】finishBeanFactoryInitialization (beanFactory);

//【完成bean工厂初始化操作】负责初始化所有的 singleton beans
    //此处开始调用Bean的前置处理器和后置处理器
    finishBeanFactoryInitialization(beanFactory);

**讲解重点（断点跟踪、类继承关系、架构图讲解）**

//1、设置辅助器：例如：解析器、转换器、类装载器
    	//2、实例化
    	//3、填充
    	//4、调用前置、后置处理器

//核心代码在  getBean() , 下面单独讲解

13）完成刷新

【完成刷新】

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

> tips:
> 
> 非核心步骤

## 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#createBeanInstance

5）放入三级缓存

循环依赖和 aop

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#addSingletonFactory

**4）注入属性**

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
    真正给bean设置属性的地方！

**7）bean 前后置**

还记得上面我们自定义的 Bean 后置处理器吗

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean
    前、后置的调用，在这里

详细见下图第 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）

**配置文件**

<bean id="userServiceImplA" class="com.spring.test.impl.UserServiceImplA">
    		<property name="userServiceImplB" ref="userServiceImplB"/>
    	</bean>
    
    	
    	<bean id="userServiceImplB" class="com.spring.test.impl.UserServiceImplB">
    		<property name="userServiceImplA" ref="userServiceImplA"/>
    	</bean>

**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**

ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:application.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 三级缓存为空

**效果如下**

走到这一步，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 前面经历了一次 get 操作，将 3 级缓存的 BeanA 放到 2 级缓存

3、然后 2 级缓存的 A 注入进 BeanB, BeanB 完事进一级缓存，此时 BeanB 持有 BeanA

3、接下来，继续完成 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

**为什么设计三级？二级缓存能否解决循环依赖？**

可以解决。别说 2 级，1 级都行

虽然二级缓存能解决循环依赖，但是 aop 时会可能会引发问题，三级是一个 factory，在里面配备了对应的后置处理器，其中就有我们的 aop （后面会讲到），如果有人要用它，会在调用 factory 的 getObject 时生效，生成代理 bean 而不是原始 bean。

如果不这么做，直接创建原始对象注入，可能引发 aop 失效。

所以 spring 的 3 级各有意义：

1 级：最终成品

2 级：半成品

3 级：工厂，备用

在上面的方法 getEarlyBeanReference（提前暴露的引用）

**回顾下**

AbstractAutowireCapableBeanFactory.getEarlyBeanReference

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 和三级缓存一样，都是实例化、普通的 Bean

2、如果调用后置，返回的就是代理对象，不是普通的 Bean 了

其实；这就是三级缓存设计的巧妙之处

**那为什么要 2 级呢？ 不能直接放入 1 级吗？**

不能！

A-B-A 中，第二次 A 的时候，A 还是个半成品，不能放入 1 级

以上面为例，A 在进入 2 级缓存的时候，它里面的 B 还是个 null ！

如果放入 1 级，被其他使用的地方取走，会引发问题，比如空指针

## **4 IoC 用到的那些设计模式** ##

引言：
    
    Spring中使用了大量的设计模式（面试）

### 4.1 工厂 ###

\*\* 工厂模式（Factory Pattern）\*\* 提供了一种创建对象的最佳方式。

**工厂模式（Factory Pattern）分为三种**

1、简单工厂

2、工厂方法

3、抽象工厂

**1. 简单工厂模式**

ApplicationContext context =
    	new ClassPathXmlApplicationContext("classpath*:application.xml");\
    UserService userService = context.getBean(UserService.class);

简单工厂模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层简单的封装

定义接口 IPhone

public interface Phone {
    	void make();
    }

实现类

public class IPhone implements Phone {
    	public IPhone() {
    		this.make();
    	}
    
    	@Override
    	public void make() {
    		// TODO Auto-generated method stub
    		System.out.println("生产苹果手机!");
    	}
    }

实现类

public class MiPhone implements Phone {
    	public MiPhone() {
    		this.make();
    	}
    	@Override
    	public void make() {
    		// TODO Auto-generated method stub
    		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[] arg) {
    		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
    	public void step1() {
    		System.out.println(">>>>>>>>>>>>>>1");
    	}
    
    	@Override
    	public void step2() {
    		System.out.println(">>>>>>>>>>>>>>2");
    
    	}
    
    	@Override
    	public void step3() {
    		System.out.println(">>>>>>>>>>>>>>3");
    
    	}
    
    	@Override
    	public void step4() {
    		System.out.println(">>>>>>>>>>>>>>4");
    	}
        
        //测试
    	public static void main(String[] args) {
    		TemplatePattern tp = new SubTemplatePattern();
    		tp.refresh();
    	}
    }

输出

### 4.3 观察者 ###

**什么是观察者模式**

观察者模式 (Observer Pattern)：当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。

Spring 的事件机制就是具体的观察者模式的实现

spring中的多播与事件
    AbstractApplicationContext#initApplicationEventMulticaster
        
    AbstractApplicationContext#registerListeners

**观察者模式有哪些角色？**

**事件 `ApplicationEvent`** 是所有事件对象的父类，继承 JDK 的 EventObject

**事件监听 `ApplicationListener`**，也就是**观察者对象**，继承自 JDK 的 `EventListener`, 可以监听到事件；该类中只有一个方法 `onApplicationEvent`。当监听的事件发生后该方法会被执行。

**事件发布 `ApplicationContext`**， 实现事件的发布。

（发布事件）

========================or=================================

Spring 中的多播

**事件发布 `ApplicationEventMulticaster`**，用于事件监听器的注册和事件的广播。

自定义一个事件 MessageSourceEvent 并且实现 ApplicationEvent 接口

//在Spring 中使用事件监听机制(事件、监听、发布)
    //定义事件
    //执行顺序
    //1、进入到事件源的有参数构造器
    //2、发布事件
    //3、进入到监听器类---one
    //4、进入到事件源的方法
    //5、进入到监听器类---two
    //6、进入到事件源的方法
    public class MessageSourceEvent extends ApplicationEvent {
    	public MessageSourceEvent(Object source) {
    		super(source);
    		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 ApplicationContextListenerTwo 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);
    	}
    
    }

配置文件

<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"/>

测试

//总结 ：使用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 工厂发布和使用多播器效果是一样的

[00934c84575d48439f616dd449f6b86d.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/4b13b4de4c6e4763851278bb2ddacb10.jpeg