第 4 章 Spring

╰半夏微凉° 2022-10-29 09:21 192阅读 0赞

# 第 4 章 Spring #

## 1、Spring Aop 顺序 ##

### 1.1、Aop 常用注解 ###

> **Spring 中的 5 个通知**

1.  `@Before` 前置通知: 目标方法之前执行
2.  `@After` 后置通知: 目标方法之后执行（始终执行）
3.  `@AfterReturning` 返回后通知: 执行方法结束前执行(异常不执行)
4.  `@AfterThrowing` 异常通知: 出现异常时候执行
5.  `@Around` 环绕通知: 环绕目标方法执行

### 1.2、Spring Aop 面试题 ###

> **面试官对线环节**

1.  你肯定知道 Spring，那说说 Aop 的全部通知顺序 Springboot 或 Springboot2 对 Aop 的执行顺序影响？
2.  说说你使用 Aop 中碰到的坑

### 1.3、测试前的准备工作 ###

#### 1.3.1、业务类 ####

> **创建业务接口类：`CalcService`**

/**
     * @InterfaceName CalService
     * @Description TODO
     * @Author Oneby
     * @Date 2021/1/22 11:20
     * @Version 1.0
     */
    public interface CalcService {
        
        public int div(int x, int y);
    }

> **创建业务接口的实现类：`CalcServiceImpl`**

/**
     * @ClassName CalcServiceImpl
     * @Description TODO
     * @Author Oneby
     * @Date 2021/1/22 11:15
     * @Version 1.0
     */
    @Service
    public class CalcServiceImpl implements CalcService {
        
        @Override
        public int div(int x, int y) {
        
            int result = x / y;
            System.out.println("=========>CalcServiceImpl被调用了,我们的计算结果：" + result);
            return result;
        }
    }

#### 1.3.2、切面类 ####

> **想在除法方法前后各种通知，引入切面编程**

1.  `@Aspect`：指定一个类为切面类
2.  `@Component`：纳入 Spring 容器管理

> **创建切面类 `MyAspect`**

/**
     * @ClassName MyAspect
     * @Description TODO
     * @Author Oneby
     * @Date 2021/1/22 11:27
     * @Version 1.0
     */
    @Aspect
    @Component
    public class MyAspect {
        
        @Before("execution(public int com.heygo.spring.aop.CalcServiceImpl.*(..))")
        public void beforeNotify() {
        
            System.out.println("******** @Before我是前置通知MyAspect");
        }
    
        @After("execution(public int com.heygo.spring.aop.CalcServiceImpl.*(..))")
        public void afterNotify() {
        
            System.out.println("******** @After我是后置通知");
        }
    
        @AfterReturning("execution(public int com.heygo.spring.aop.CalcServiceImpl.*(..))")
        public void afterReturningNotify() {
        
            System.out.println("********@AfterReturning我是返回后通知");
        }
    
        @AfterThrowing("execution(public int com.heygo.spring.aop.CalcServiceImpl.*(..))")
        public void afterThrowingNotify() {
        
            System.out.println("********@AfterThrowing我是异常通知");
        }
    
        @Around("execution(public int com.heygo.spring.aop.CalcServiceImpl.*(..))")
        public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        
            Object retValue = null;
            System.out.println("我是环绕通知之前AAA");
            retValue = proceedingJoinPoint.proceed();
            System.out.println("我是环绕通知之后BBB");
            return retValue;
        }
    }

### 1.4、Spring4 下的测试 ###

#### 1.4.1、POM 文件 ####

> **在 POM 文件中导入 SpringBoot 1.5.9.RELEASE 版本**

SpringBoot 1.5.9.RELEASE 版本的对应的 Spring 版本为 4.3.13 Release

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            
            <version>1.5.9.RELEASE</version>
            <relativePath/>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.heygo</groupId>
        <artifactId>interview1024</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.1.3</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-access</artifactId>
                <version>1.1.3</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>1.1.3</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
            
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-captcha</artifactId>
                <version>4.6.8</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

#### 1.4.2、创建主启动类 ####

> **在主包名下创建启动类**

为何要在主包名下创建启动类？其他子包均在主包下面，这样我们就不用使用 `@ComponentScan` 扫扫描包啦~

![image-20210122153117395][]

Springboot 启动类带上 `@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})`，至于为啥，等到我复习 SpringBoot 的时候再说吧~

/**
     * @ClassName AopStudyApplication
     * @Description TODO
     * @Author Oneby
     * @Date 2021/1/22 11:53
     * @Version 1.0
     */
    @SpringBootApplication(exclude = {
        DataSourceAutoConfiguration.class})
    public class AopStudyApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(AopStudyApplication.class, args);
        }
    }

#### 1.4.3、创建测试类 ####

> **在主启动类所在包下创建子包与测试类**

![image-20210122153554824][]

**注意**：SpringBoot 1.5.9 版本在测试类上需要加上 `@RunWith(SpringRunner.class)` 注解，单元测试需要导入的包名为 `import org.junit.Test;`

@SpringBootTest
    @RunWith(SpringRunner.class)  //1.5.9
    public class AopTest {
        
        @Autowired
        private CalcService calcService;
    
        @Test
        public void testAop4() {
        
            System.out.println("spring版本：" + SpringVersion.getVersion() + "\t" + "SpringBoot版本：" + SpringBootVersion.getVersion());
            System.out.println();
            calcService.div(10, 2);
            // calcService.div(10, 0);
        }
    }

#### 1.4.4、Aop 测试结果 ####

> **正常执行的结果**

环绕通知将前置通知与目标方法包裹住，执行完 `@After` 才执行 `@AfterReturning`

![image-20210122154310364][]

> **异常执行的结果**

由于抛出了异常，因此环绕通知后半部分没有执行，执行完 `@After` 才执行 `@AfterThrowing`

![image-20210122154314389][]

**注**：Spring4 默认用的是 JDK 的动态代理

### 1.5、Spring 5 下的测试 ###

#### 1.5.1、POM 文件 ####

> **在 POM 文件中导入 SpringBoot 1.5.9.RELEASE 版本**

SpringBoot 2.3.3.RELEASE 版本的对应的 Spring 版本为 5.2.8 Release

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.3.RELEASE</version>
            
            <relativePath/>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.heygo</groupId>
        <artifactId>interview1024</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
            
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-captcha</artifactId>
                <version>4.6.8</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

#### 1.5.2、创建主启动类 ####

> **沿用 Spring4 的主启动类**

同样也需要在主启动类上添加 `@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})` 注解

#### 1.5.3、创建测试类 ####

> **在 Spring4 的测试类下修改代码**

**注意**：SpringBoot 2.3.3 版本下，不需要在测试类上面添加 `@RunWith(SpringRunner.class)` 直接，单元测试需要导入的包名为 `import org.junit.jupiter.api.Test;`，不再使用 `import org.junit.Test;`

@SpringBootTest
    public class AopTest {
        
        @Autowired
        private CalcService calcService;
    
        @Test
        public void testAop4() {
        
            System.out.println("spring版本：" + SpringVersion.getVersion() + "\t" + "SpringBoot版本：" + SpringBootVersion.getVersion());
            System.out.println();
            calcService.div(10, 0);
        }
    
        @Test
        public void testAop5() {
        
            System.out.println("spring版本：" + SpringVersion.getVersion() + "\t" + "SpringBoot版本：" + SpringBootVersion.getVersion());
            System.out.println();
            calcService.div(10, 5);
        }
    }

#### 1.5.4、Aop 测试结果 ####

> **正常执行的结果**

感觉 Spring5 的环绕通知才是真正意义上的华绕通知，它将其他通知和方法都包裹起来了，而且 `@AfterReturning` 和 `@After` 之前，合乎逻辑！

![image-20210122160308629][]

> **异常执行的结果**

由于方法抛出了异常，因此环绕通知后半部分没有执行，并且 `@AfterThrowing` 和 `@After` 之前

![image-20210122160313858][]

### 1.6、Aop 执行顺序总结 ###

> **呐呐呐~~~**

![image-20210122160250883][]

## 2、Spring 循环依赖 ##

### 2.1、恶心的大厂面试题 ###

> **被面试官暴打**

1.  你解释下spring中的三级缓存？
2.  三级缓存分别是什么？三个Map有什么异同？
3.  什么是循环依赖？请你谈谈？看过 Spring源码吗？一般我们说的 Spring容器是什么？
4.  如何检测是否存在循环依赖？实际开发中见过循环依赖的异常吗？
5.  多例的情况下，循环依赖问题为什么无法解决？
6.  。。。。。。

### 2.2、什么是循环依赖？ ###

> **多个 bean 之间相互依赖，形成了一个闭环**

比如：A 依赖于 B、B 依赖于 C、C 依赖于 A

public class CircularDependency {
        
        class A {
        
            B b;
        }
        
        class B {
        
            C c;
        }
        
        class C {
        
            A a;
        }
    }

通常来说，如果问 Spring 容器内部如何解决循环依赖， 一定是指默认的单例 Bean 中，属性互相引用的场景。也就是说，Spring 的循环依赖，是 Spring 容器注入时候出现的问题

![image-20210122181643319][]

### 2.3、两种注入方式对循环依赖的影响 ###

> **[官网对循环依赖的说明][Link 1]**

![image-20210122182003990][]

> **两种注入方式对循环依赖的影响**

**构造器注入**：容易造成无法解决的循环依赖，不推荐使用（If you use predominantly constructor injection, it is possible to create an unresolvable circular dependency scenario.）

**Setter 注入**：推荐使用 setter 方式注入单例 bean

--------------------

**结论**：我们 AB 循环依赖问题只要 A 的注入方式是 setter 且 singleton，就不会有循环依赖问题

### 2.4、Spring容器循环依赖异常 ###

#### 2.4.1、通过代码理解循环依赖 ####

循环依赖现象在 Spring 容器中 注入依赖的对象，有 2 种情况

> **构造器方式注入依赖**

**代码**

1、`ServiceA`

@Component
    public class ServiceA {
        
    
        private ServiceB serviceB;
    
        public ServiceA(ServiceB serviceB) {
        
            this.serviceB = serviceB;
        }
    }

2、`ServiceB`

@Component
    public class ServiceB {
        
    
        private ServiceA serviceA;
    
        public ServiceB(ServiceA serviceA) {
        
            this.serviceA = serviceA;
        }
    }

3、`ClientConstructor`

/**
     * 通过构造器的方式注入依赖，构造器的方式注入依赖的bean，下面两个bean循环依赖
     *
     * 测试后发现，构造器循环依赖是无法解决的
     */
    public class ClientConstructor {
        
        public static void main(String[] args) {
        
            new ServiceA(new ServiceB(new ServiceA(new ServiceB()))); ....
        }
    }

--------------------

**结论**：构造器注入没有办法解决循环依赖， 你想让构造器注入支持循环依赖，是不存在的。如果构造器能够解决循环依赖问题，那么我就可以无限套娃~

**形象理解**：各自实例化时都需要对方实例，这就类似于死锁，如果不采取一种办法解决，那么它们将永远互相等待下去

> **Setter 方式注入**

**代码**

1、`ServiceA`

@Component
    public class ServiceA {
        
    
        private ServiceB serviceB;
    
        public void setServiceB(ServiceB serviceB) {
        
            this.serviceB = serviceB;
            System.out.println("A 里面设置了B");
        }
    }

2、`ServiceB`

@Component
    public class ServiceB {
        
    
        private ServiceA serviceA;
    
        public void setServiceA(ServiceA serviceA) {
        
            this.serviceA = serviceA;
            System.out.println("B 里面设置了A");
        }
    }

3、`ClientConstructor`

public class ClientSet {
        
        public static void main(String[] args) {
        
    
            //创建serviceA
            ServiceA serviceA = new ServiceA();
    
            //创建serviceB
            ServiceB serviceB = new ServiceB();
    
            //将serviceA注入到serviceB中
            serviceB.setServiceA(serviceA);
    
            //将serviceB注入到serviceA中
            serviceA.setServiceB(serviceB);
    
        }
    }

--------------------

**结论**：setter 方式可以解决循环依赖问题

#### 2.4.2、演示循环依赖异常 ####

> **环境搭建**

1.  `A` 类
    
        /**
         * @ClassName A
         * @Description TODO
         * @Author Oneby
         * @Date 2021/1/22 18:44
         * @Version 1.0
         */
        public class A {
              
            private B b;
        
            public B getB() {
              
                return b;
            }
        
            public void setB(B b) {
              
                this.b = b;
            }
        
            public A() {
              
                System.out.println("---A created success");
            }
        }
2.  `B` 类
    
        /**
         * @ClassName B
         * @Description TODO
         * @Author Oneby
         * @Date 2021/1/22 18:44
         * @Version 1.0
         */
        public class B {
              
            private A a;
        
            public A getA() {
              
                return a;
            }
        
            public void setA(A a) {
              
                this.a = a;
            }
            
            public B() {
              
                System.out.println("---B created success");
        
            }
        }
3.  `ClientSpringContainer` 类
    
        /**
         * @ClassName ClientSpringContainer
         * @Description 只有单例的bean会通过三级缓存提前暴露来解决循环依赖的问题，因为单例的时候只有一份，随时复用，那么就放到缓存里面
         * 而多例的bean，每次从容器中荻取都是—个新的对象，都会重B新创建，所以非单例的bean是没有缓存的，不会将其放到三级缓存中。
         * @Author Oneby
         * @Date 2021/1/22 18:44
         * @Version 1.0
         */
        public class ClientSpringContainer {
              
            public static void main(String[] args) {
              
                ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
                A a = context.getBean("a", A.class);
                B b = context.getBean("b", B.class);
            }
        }
4.  在 resources 文件夹下创建 applicationContext.xml 文件，对 bean 中的属性进行注入
    
        <?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
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop.xsd
                http://www.springframework.org/schema/tx
                http://www.springframework.org/schema/tx/spring-tx.xsd">
        
            
        
            
            
            
            <bean id="a" class="com.heygo.spring.circulardependency.A">
                <property name="b" ref="b"/>
            </bean>
        
            <bean id="b" class="com.heygo.spring.circulardependency.B">
                <property name="a" ref="a"/>
            </bean>
        
        </beans>

> **scope = “singleton”，默认的单例(Singleton)的场景是支持循环依赖的，不报错**

每个 bean 的 `scope` 实行默认不写就是 `singleton`，

![image-20210122190515257][]

beanA 和 beanB 都创建成功了，程序没有抛异常

![image-20210122185345801][]

> **scope = “prototype”，原型(Prototype)的场景是不支持循环依赖的，报错**

将 bean 的生命周期改为 `prototype`

![image-20210122190613296][]

啊哦，抛异常了：`Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'a' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'b' while setting bean property 'b'; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'b' defined in class path resource [applicationContext.xml]: Cannot resolve reference to bean 'a' while setting bean property 'a'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?`

![image-20210122190652176][]

#### 2.4.3、循环依赖的解决办法 ####

> **重要结论：Spring 内部通过 3 级缓存来解决循环依赖**

所谓的三级缓存其实就是 Spring 容器内部用来解决循环依赖问题的三个 Map，这三个 Map 在 `DefaultSingletonBeanRegistry` 类中

![image-20210122190910426][]

**第一级缓存**：`Map<String, Object> singletonObjects`，我愿称之为成品单例池，常说的 Spring 容器就是指它，我们获取单例 bean 就是在这里面获取的，存放已经经历了完整生命周期的Bean对象

**第二级缓存**：`Map<String, Object> earlySingletonObjects`，存放早期暴露出来的Bean对象，Bean的生命周期未结束（属性还未填充完整，可以认为是半成品的 bean）

**第三级缓存**：`Map<String, ObiectFactory<?>> singletonFactories`，存放可以生成Bean的工厂，用于生产（创建）对象

### 2.5、源码 Deug 前置知识 ###

#### 2.5.1、实例化 & 初始化 ####

> **实例化和初始化的区别**

1.  实例化：堆内存中申请一块内存空间
    
    ![image-20210123101131093][]
2.  初始化：完成属性的填充
    
    ![image-20210123101143372][]

#### 2.5.2、3个Map & 4个方法 ####

> **三级缓存 + 四大方法**

![image-20210122223932721][]

--------------------

**三级缓存**

第一级缓存：存放的是已经初始化好了的Bean，bean名称与bean实例相对应，即所谓的单例池。表示已经经历了完整生命周期的Bean对象

第一级缓存：存放的是实例化了，但是未初始化的Bean，bean名称与bean实例相对应。表示Bean的生命周期还没走完（Bean的属性还未填充）就把这个Bean存入该缓存中。也就是实例化但未初始化的bean放入该缓存里

第三级缓存：表示存放生成bean的工厂，存放的是FactoryBean，bean名称与bean工厂对应。假如A类实现了FactoryBean，那么依赖注入的时候不是A类，而是A类产生的Bean

--------------------

**四大方法**

1.  `getSingleton()`：从容器里面获得单例的bean，没有的话则会创建 bean
2.  `doCreateBean()`：执行创建 bean 的操作（在 Spring 中以 do 开头的方法都是干实事的方法）
3.  `populateBean()`：创建完 bean 之后，对 bean 的属性进行填充
4.  `addSingleton()`：bean 初始化完成之后，添加到单例容器池中，下次执行 `getSingleton()` 方法时就能获取到

--------------------

**注**：关于三级缓存 `Map<String, ObjectFactory<?>> singletonFactories`的说明，`singletonFactories` 的 `value` 为 `ObjectFactory` 接口实现类的实例。`ObjectFactory` 为函数式接口，在该接口中定义了一个 `getObject()` 方法用于获取 `bean`，这也正是工厂思想的体现（工厂设计模式）

![image-20210122224954341][]

#### 2.5.3、 对象在三级缓存中的迁移 ####

> **A/B 两对象在三级缓存中的迁移说明**

1.  A创建过程中需要B，于是A将自己放到三级缓存里面，去实例化B
2.  B实例化的时候发现需要A，于是B先查一级缓存，没有，再查二级缓存，还是没有，再查三级缓存，找到了A，然后把三级缓存里面的这个A放到二级缓存里面，并删除三级缓存里面的A
3.  B顺利初始化完毕，将自己放到一级缓存里面（此时B里面的A依然是创建中状态），然后回来接着创建A，此时B已经创建结束，直接从一级缓存里面拿到B，然后完成创建，并将A自己放到一级缓存里面。

### 2.6、详细 Debug 流程 ###

#### 2.6.1、beanA 的实例化 ####

> **技巧：如何阅读框架源码？答：打断点 + 看日志**

在 `ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");` 代码处打上断点，逐步执行（Step Over），发现执行 `new ClassPathXmlApplicationContext("applicationContext.xml")` 操作时，beanA 和 beanB 都已经被创建好了，因此我们需要进入 `new ClassPathXmlApplicationContext("applicationContext.xml")` 中

![image-20210122230104635][]

> **进入 `new ClassPathXmlApplicationContext("applicationContext.xml")` 中**

点击 Step Into，首先进入了静态代码块中，不管我们的事，使用 Step Out 退出此方法

![image-20210122230423326][]

再次 Step Into，进入 `ClassPathXmlApplicationContext` 类的构造函数，该构造函数使用 this 调用了另一个重载构造函数

![image-20210122230632877][]

继续 Step Into，进入重载构造函数后单步 Step Over，发现执行完 `refresh()` 方法后输出如下日志，于是我们将断点打在 `refresh()` 那一行

![image-20210122230823849][]

> **进入 `refresh()` 方法**

Step Into 进入 `refresh()` 方法，发现执行完 `finishBeanFactoryInitialization(beanFactory)` 方法后输出日志，于是我们将断点打在 `finishBeanFactoryInitialization(beanFactory)` 那一行

从注释也可以看出本方法完成了非懒加载单例 bean的初始化（Instantiate all remaining (non-lazy-init) singletons.）

![image-20210122231301414][]

> **进入 `finishBeanFactoryInitialization(beanFactory)` 方法**

Step Into 进入 `finishBeanFactoryInitialization(beanFactory)` 方法，发现执行完 `beanFactory.preInstantiateSingletons()` 方法后输出日志，于是我们将断点打在 `beanFactory.preInstantiateSingletons()` 那一行

从注释也可以看出本方法完成了非懒加载单例 bean的初始化（Instantiate all remaining (non-lazy-init) singletons.）

![image-20210122231617225][]

> **进入 `beanFactory.preInstantiateSingletons()` 方法**

Step Into 进入 `beanFactory.preInstantiateSingletons()` 方法，发现执行完 `getBean(beanName)` 方法后输出日志，于是我们将断点打在 `getBean(beanName)` 那一行

![image-20210122231902178][]

> **进入 `getBean(beanName)` 方法**

`getBean(beanName)` 调用了 `doGetBean(name, null, null, false)` 方法，也就是前面说过的：在 Spring 里面，以do 开头的方法都是干实事的方法

![image-20210122232111871][]

> **进入 `doGetBean(name, null, null, false)` 方法**

我们可以给 bean 配置别名，这里的 `transformedBeanName(name)` 方法就是将用户别名转换为 bean 的真实名称

![image-20210122232301105][]

> **进入 `getSingleton(beanName)` 方法**

有必要讲一下 `getSingleton(beanName)` 方法

![image-20210122232610296][]

调用了其重载的方法，`allowEarlyReference == true` 表示可以从三级缓存 `earlySingletonObjects` 中获取 bean，`allowEarlyReference == false` 表示不可以从三级缓存 `earlySingletonObjects` 中获取 bean，

![image-20210122232708127][]

`getSingleton(beanName, true)` 方法尝试从一级缓存 `singletonObjects` 中获取 beanA，beanA 现在还没有开始造呢（`isSingletonCurrentlyInCreation(beanName)` 返回 `false`），获取不到返回 `null`

![image-20210122232923347][]

> **回到 `doGetBean(name, null, null, false)` 方法中**

`getSingleton(beanName)` 方法返回 `null`

![image-20210122233201164][]

我们所说的 bean 对于 Spring 来说就是一个个的 `RootBeanDefinition` 实例

![image-20210122233255044][]

这个 `dependsOn` 变量对应于 bean 的 `depends-on=""` 属性，我们没有配置过，因此为 `null`

![image-20210122233409563][]

转了一圈发现并没有 beanA，终于要开始准备创建 beanA 啦

![image-20210122233943061][]

> **进入 `getSingleton(beanName, () -> {... }` 方法**

在 IDEA 2020 中，点击 Step Into 可以手动选择要进入的方法，因此我们需要使用鼠标左键点击 `getSingleton()` 方法

![image-20210123111611168][]

首先尝试从一级缓存 `singletonObjects` 获取 beanA，那肯定是获取不到的啦，因此 `singletonObject == null`，那么就需要创建 beanA，此时日志会输出：【Creating shared instance of singleton bean ‘a’】

![image-20210123112301014][]

当执行完 `singletonObject = singletonFactory.getObject();` 时，会输出【—A created success】，这说明执行 `singletonFactory.getObject()` 方法时将会实例化 beanA，并且根据代码变量名可得知单例工厂创建的，这个单例工厂就是我们传入的 Lambda 表达式

![image-20210123112653528][]

> **进入 `createBean(beanName, mbd, args)` 方法**

我们 Step Into 进入 `createBean(beanName, mbd, args)` 方法中，`mbdToUse` 将用于创建 beanA

![image-20210123113109315][]

来了，终于要执行 `doCreateBean(beanName, mbdToUse, args)` 实例化 beanA 啦

![image-20210123113439196][]

> **进入 `doCreateBean(beanName, mbdToUse, args)` 方法**

Step Into 进入 `doCreateBean(beanName, mbdToUse, args)` 方法，在 `factoryBeanInstanceCache` 中并不存在 beanA 对应的 Wrapper 缓存，`instanceWrapper == null`，因此我们要去创建 beanA 对应的 `instanceWrapper`，Wrapper 由包裹之意思，`instanceWrapper` 翻译过来为实例包裹器的意思，形象理解为：beanA 实例化需要经过 `instanceWrapper` 之手，beanA 实例被 `instanceWrapper` 包裹在其中

![image-20210123113721708][]

> **进入 `createBeanInstance(beanName, mbd, args)` 方法**

这一看就是反射的操作啊

![image-20210123114509257][]

这里有个 `resolved` 变量，写着注释：Shortcut when re-creating the same bean…，我个人理解是 `resolved` 标志该 bean 是否已经被实例化了，如果已经被实例化了，那么 `resolved == true`，这样就不用重复创建同一个 bean 了

![image-20210123114722004][]

Candidate constructors for autowiring? 难道是构造器自动注入？在 return 的时候调用 `instantiateBean(beanName, mbd)` 方法实例化 beanA，并将其返回

![image-20210123115049589][]

> **进入 `instantiateBean(beanName, mbd)` 方法**

`getInstantiationStrategy().instantiate(mbd, beanName, this)` 方法完成了 beanA 的实例化

![image-20210123115807740][]

> **进入 `getInstantiationStrategy().instantiate(mbd, beanName, this)` 方法**

首先获取已经解析好的构造器 `bd.resolvedConstructorOrFactoryMethod`，这是第一次创建，当然还没有啦，因此 `constructorToUse == null`。然后获取 A 的类型，如果发现是接口则直接抛异常。最后获取 A 的公开构造器，并将其赋值给 `bd.resolvedConstructorOrFactoryMethod`

![image-20210123120436544][]

获取构造器的目的当然是为了实例化 beanA 啦

![image-20210123120804415][]

> **进入 `BeanUtils.instantiateClass(constructorToUse)` 方法**

通过构造器创建 beanA 实例，Step Over 后会输出：【—A created success】，并且会回到 `getInstantiationStrategy().instantiate(mbd, beanName, this)` 方法中

![image-20210123120941726][]

> **回到 `getInstantiationStrategy().instantiate(mbd, beanName, this)` 方法中**

在 `BeanUtils.instantiateClass(constructorToUse)` 方法中创建好了 beanA 实例，不过还没有进行初始化，可以看到属性 `b = null`，Step Over 后会回到 `instantiateBean(beanName, mbd)` 方法中

![image-20210123163945288][]

> **回到 `instantiateBean(beanName, mbd)` 方法中**

得到刚才创建的 beanA 实例，但其属性并未被初始化

![image-20210123164916170][]

将实例化的 beanA 装进 BeanWrapper 中并返回 `bw`

![image-20210123165203819][]

> **回到 `createBeanInstance(beanName, mbd, args)` 方法中**

得到刚才创建的 `beanWrapper` 实例，该 `beanWrapper` 包裹（封装）了刚才创建的 beanA 实例

![image-20210123165447074][]

> **回到 `doCreateBean(beanName, mbdToUse, args)` 方法中**

在 `doCreateBean(beanName, mbdToUse, args)` 方法获得 `BeanWrapper instanceWrapper`，用于封装 beanA 实例

![image-20210123165629641][]

获取并记录 A 的全类名

![image-20210123170700410][]

执行 `BeanPostProcessor`

![image-20210123170837080][]

如果该 bean 是单例 bean（`mbd.isSingleton()`），并且允许循环依赖（`this.allowCircularReferences`），并且当前 bean 正在创建过程中（`isSingletonCurrentlyInCreation(beanName)`），那么就就允许提前暴露该单例 bean（`earlySingletonExposure = true`），则会执行 `addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))` 方法将该 bean 放到三级缓存 `singletonFactories` 中

![image-20210123170940500][]

> **进入 `addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))` 方法**

首先去一级缓存 `singletonObjects` 中找一下有没有 beanA，肯定没有啦~然后将 beanA 添加到三级缓存 `singletonFactories` 中，并将 beanA 从二级缓存 `earlySingletonObjects` 中移除，最后将 beanName 添加至 `registeredSingletons` 中，表示该 bean 实例已经被注册

![image-20210123171328459][]

#### 2.6.2、beanA 的属性填充 ####

> **回到 `doCreateBean(beanName, mbdToUse, args)` 方法中**

接着回到 `doCreateBean(beanName, mbdToUse, args)` 方法中，需要执行 `populateBean(beanName, mbd, instanceWrapper)` 方法对 beanA 中的属性进行填充

![image-20210123171726753][]

> **进入 `populateBean(beanName, mbd, instanceWrapper)` 方法**

获取 beanA 的属性列表

![image-20210123171917156][]

执行 `applyPropertyValues(beanName, mbd, bw, pvs)` 方法完成 beanA 属性的填充

![image-20210123172048186][]

> **进入 `applyPropertyValues(beanName, mbd, bw, pvs)` 方法**

获取到 beanA 的属性列表，发现有个属性为 `b`

![image-20210123172426598][]

遍历每一个属性，并对每一个属性进行注入，`valueResolver.resolveValueIfNecessary(pv, originalValue)` 的作用：Given a PropertyValue, return a value, resolving any references to other beans in the factory if necessary.

![image-20210123172613391][]

> **进入 `valueResolver.resolveValueIfNecessary(pv, originalValue)` 方法**

通过 `resolveReference(argName, ref)` 解决依赖注入的问题

![image-20210123173739270][]

> **进入 `resolveReference(argName, ref)` 方法**

先获得属性 `b` 的名称，再通过 `this.beanFactory.getBean(resolvedName)` 方法获取 beanB 的实例

![image-20210123174227557][]

#### 2.6.3、beanB 的实例化 ####

> **进入 `this.beanFactory.getBean(resolvedName)` 方法**

哦，这熟悉的 `doGetBean(name, null, null, false)` 方法，这就开始递归了呀

![image-20210123174510971][]

> **再次执行 `doGetBean(name, null, null, false)` 方法**

beanB 还没有实例化，因此 `getSingleton(beanName)` 方法返回 `null`

![image-20210123174631167][]

呐，又来到了这个熟悉的地方，先尝试获取 beanB 实例，获取不到就执行 `createBean()` 的操作

![image-20210123181159951][]

> **进入 `getSingleton(beanName, () -> {... }` 方法**

首先尝试从一级缓存 `singletonObjects` 中获取 beanB，那肯定是获取不到的呀

![image-20210123181540128][]

然后就调用 `singletonFactory.getObject()` 创建 beanB

![image-20210123230319469][]

> **进入 `createBean(beanName, mbd, args)` 方法**

获取到 beanB 的类型为 `com.heygo.spring.circulardependency.B`

![image-20210123230722139][]

之前创建 beanA 的时候没有看到，现在看到挺有趣的：Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 也就是说我们可以通过 `BeanPostProcessors` 返回 bean 的代理，而非 bean 本身。然后喜闻乐见，又来到了 `doCreateBean(beanName, mbdToUse, args)` 环节

![image-20210123231047179][]

> **进入 `doCreateBean(beanName, mbdToUse, args)` 方法**

老样子，创建 beanB 对应的 `BeanWrapper instanceWrapper`

![image-20210123231513068][]

> **进入 `createBeanInstance(beanName, mbd, args)` 方法**

调用 `instantiateBean(beanName, mbd)` 创建 `beanWrapper`

![image-20210123231659756][]

> **进入 `instantiateBean(beanName, mbd)` 方法**

调用 `getInstantiationStrategy().instantiate(mbd, beanName, this)` 创建 `beanWrapper`

![image-20210123231815848][]

> **进入 `getInstantiationStrategy().instantiate(mbd, beanName, this)` 方法**

获取 `com.heygo.spring.circulardependency.B` 的构造器，并将构造器信息记录在 `bd.resolvedConstructorOrFactoryMethod` 字段中

![image-20210123232017300][]

调用 `BeanUtils.instantiateClass(constructorToUse)` 方法创建 beanB 实例

![image-20210123232156728][]

> **进入 `BeanUtils.instantiateClass(constructorToUse)` 方法**

通过调用 `B` 类的构造器创建 beanB 实例，此时控制台会输出：【—B created success】

![image-20210123232344101][]

> **回到 `instantiateBean(beanName, mbd)` 方法中**

在 `instantiateBean(beanName, mbd)` 方法中得到创建好的 beanB 实例，并将其丢进 `beanWrapper` 中，封装为 `BeanWrapper bw` 对象

![image-20210123232617698][]

> **回到 `doCreateBean(beanName, mbdToUse, args)` 方法中**

`createBeanInstance(beanName, mbd, args)` 方法将返回包装着 beanB 的 `beanWrapper`

![image-20210123233026527][]

执行 `BeanPostProcessor` 的处理过程

![image-20210123233404820][]

beanB 由于满足单例并且正在被创建，因此 beanB 可以被提前暴露出去（在属性还未初始化的时候可以提前暴露出去），于是执行 `addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))` 方法将其添加至三级缓存 `singletonFactory` 中

![image-20210123233523439][]

> **进入 `addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))` 方法**

将 beanB 实例添加至三级缓存 `singletonFactory` 中，从二级缓存 `earlySingletonObjects` 中移除，并注册其 beanName

![image-20210123233916978][]

> **回到 `doCreateBean(beanName, mbdToUse, args)` 方法中**

执行 `populateBean(beanName,mbd,instancewrapper)` 方法填充 beanB 的属性

![image-20210123234133479][]

#### 2.6.4、beanB 的属性填充 ####

> **进入 `populateBean(beanName, mbd, instanceWrapper)` 方法**

执行 `mbd.getPropertyValues()` 方法获取 beanB 的属性列表

![image-20210123234301151][]

执行 `applyPropertyValues(beanName, mbd, bw, pvs)` 方法完成 beanB 属性的填充

![image-20210123234518400][]

> **进入 `applyPropertyValues(beanName, mbd, bw, pvs)` 方法**

执行 `mpvs.getPropertyValuelist()` 方法获取 beanB 的属性列表

![image-20210123234654991][]

![image-20210123234750025][]

> **进入 `valueResolver.resolveValueIfNecessary(pv, originalValue)` 方法**

执行 `resolveReference(argName, ref)` 方法为 beanB 注入名为 `a` 属性

![image-20210123234916337][]

> **进入 `resolveReference(argName, ref)` 方法**

执行 `this.beanFactory.getBean(resolvedName)` 方法获取 beanA 实例，其实就是执行 `doGetBean(name, null, null, false)` 方法

![image-20210123235249422][]

> **进入 `doGetBean(name, null, null, false)` 方法**

关键来了，这里执行 `getSingleton(beanName)` 是够能够获取到 beanA 实例呢？答案是可以

![image-20210123235540413][]

> **进入 `getSingleton(beanName, true)` 方法**

`getSingleton(beanName)` 调用了其重载方法 `getSingleton(beanName, true)`，接下来的逻辑很重要，让我们来唠嗑唠嗑

1.  beanA 并没有存放在一级缓存 `singletonObjects` 中，因此执行 `Object singletonObject = this.singletonObjects.get(beanName)` 后，`singletonObject == null`，再加上 beanA 正在满足创建的条件（`isSingletonCurrentlyInCreation(beanName) == true`），因此可以进入第一层 `if` 判断
    
    ![image-20210124000622676][]
2.  beanA 被存放在三级缓存 `singletonFactories` 中，从二级缓存 `earlySingletonObjects` 中获取也是 `null`，因此可以进入第二层 `if` 判断
    
    ![image-20210124000702685][]
3.  从三级缓存中获取 beanA 肯定不为空啦~，因此可以进入第三层 `if` 判断
    
    ![image-20210124000956873][]
4.  ①从单例工厂 `singletonFactory` 中获取 beanA；②将 beanA 添加至二级缓存 `earlySingletonObjects` 中；③将 beanA 从三级缓存 `singletonFactories` 中移除
    
    ![image-20210124001103112][]

> **回到 `doGetBean(name, null, null, false)` 方法中**

执行 `Object sharedInstance = getSingleton(beanName)` 将获得之前存入三级缓存 `singletonFactories` 中的 beanA

![image-20210124001710344][]

好家伙，获取到 beanA 后就直接返回了

![image-20210124001902295][]

> **回到 `applyPropertyValues(beanName, mbd, bw, pvs)` 方法中**

执行 `valueResolver.resolveValueIfNecessary(pv, originalValue)` 方法获取到 beanA 实例

![image-20210124002251839][]

将属性 beanA 添加到 deepCopy 集合中（`List<PropertyValue> deepCopy = new ArrayList<>(original.size())`）

![image-20210124003102723][]

执行 `bw.setPropertyValues(new MutablePropertyValues(deepCopy))` 方法将会填充 beanB 中的 `a` 属性

![image-20210124113724764][]

> **进入 `bw.setPropertyValues(new MutablePropertyValues(deepCopy))` 方法**

调用了其重载方法 `setPropertyValues(pvs, false, false)`

![image-20210124113855809][]

> **进入 `setPropertyValues(pvs, false, false)` 方法**

在该方法中会对 bean 的每一个属性进行填充（通过 `setPropertyValues(pvs, false, false)` 方法对属性进行赋值）

![image-20210124114022056][]

> **回到 `applyPropertyValues(beanName, mbd, bw, pvs)` 方法中**

此时 `bw` 包裹着 beanB，执行 `bw.setPropertyValues(new MutablePropertyValues(deepCopy))` 方法会将 `deepCopy` 中的元素依次赋值给 beanB 的各个属性，此时 beanB 中的 `a` 属性已经赋值为 beanA

![image-20210124003407181][]

> **回到 `doCreateBean(beanName, mbdToUse, args)` 方法中**

因为 `instanceWrapper` 封装了 `beanB`，所以执行了 `populateBean(beanName, mbd, instanceWrapper)` 方法后，beanB 中的 `a` 属性就已经被填充啦~可以看到 beanB 中有 beanA，但 beanA 中没有 beanB

![image-20210124102307241][]

执行 `getSingleton(beanName, false)` 方法，传入的参数 `allowEarlyReference = false`，表示不允许从三级缓存 `singletonFactories` 中获取 beanB

![image-20210124102706141][]

> **进入 `getSingleton(beanName, false)` 方法**

由于传入的参数 `allowEarlyReference = false`，因此第三层 `if` 判断铁定进不去，而 beanB 在三级缓存 `singletonFactories` 中存着，因此返回的 `singletonObject` 为 `null`

![image-20210124102941902][]

> **回到 `doCreateBean(beanName, mbdToUse, args)` 方法中**

这里应该是执行 bean 的 `destroy-method` ，应该只会在工厂销毁的时候并且 bean 为单例的条件下，其内部逻辑才会执行。`registerDisposableBeanIfNecessary(beanName, bean, mbd)` 方法的注释如下：Add the given bean to the list of disposable beans in this factory, registering its DisposableBean interface and/or the given destroy method to be called on factory shutdown (if applicable). Only applies to singletons. 最后将 beanB 返回（属性 `a` 已经填充完毕）

![image-20210124103604267][]

> **回到 `createBean(beanName, mbd, args)` 方法**

执行 `doCreateBean(beanName, mbdToUse, args)` 方法得到包装 beanB 实例（属性 `a` 已经填充完毕），并将其返回

![image-20210124104113201][]

> **回到 `getSingleton(beanName, () -> { ... }` 方法中**

执行 `singletonFactory.getObject()` 方法获取到 beanB 实，这里的 `singletonFactory` 是之前调用 `getSingleton(beanName, () -> { ... }` 方法传入的 Lambda 表达式，然后将 `newSingleton` 设置为 `true`

![image-20210124104331897][]

执行 `addSingleton(beanName, singletonObject)` 方法将 beanB 实例添加到一级缓存 `singletonObjects` 中

![image-20210124105036099][]

> **进入 `addSingleton(beanName, singletonObject)` 方法**

① 将 beanB 放入一级缓存 `singletonObjects` 中

② 将 beanB 从三级缓存 `singletonFactories` 中删除（beanB 确实在三级缓存中）

③ 将 beanB 从二级缓存 `earlySingletonObjects` 中删除（beanB 并不在二级缓存中）

④ 将 beanB 的 beanName 注册到 `registeredSingletons` 中（之前添加至三级缓存的时候已经注册过啦~）

![image-20210124105602572][]

> **回到 `getSingleton(beanName, () -> { ... }` 方法中**

执行 `addSingleton(beanName, singletonObject)` 将 beanB 添加到一级缓存 `singletonObjects` 后，将 beanB 返回

![image-20210124105914335][]

> **回到 `doGetBean(name, null, null, false)` 方法中**

执行完 `getSingleton(beanName, () -> { ... }` 方法后，得到属性已经填充好的 beanB，并且已经将其添加至一级缓存 `singletonObjects` 中

![image-20210124110528798][]

将 beanB 返回，想想返回到哪儿去了呢？当初时因为 beanA 要填充其属性 `b`，才执行了创建 beanB 的操作，现在返回肯定是将 beanB 返回给 beanA

![image-20210124110743721][]

#### 2.6.5、beanA 的属性填充 ####

> **回到 `resolveReference(argName, ref)` 方法中**

执行完 `this.beanFactory.getBean(resolvedName)` 方法后，获得了属性填充好的 beanB 实例，并将其实例返回

![image-20210124112123075][]

> **回到 `applyPropertyValues(beanName, mbd, bw, pvs)` 方法中**

执行完 `valueResolver.resolveValueIfNecessary(pv, originalValue)` 方法后，将获得属性填充好的 beanB 实例

![image-20210124112327554][]

将 `b` 属性添加至 `deepCopy` 集合中

![image-20210124112557933][]

执行 `bw.setPropertyValues(new MutablePropertyValues(deepCopy))` 方法对 beanA 的 `b` 属性进行填充

![image-20210124112719836][]

> **进入 `setPropertyValues(pvs, false, false)` 方法**

在 `bw.setPropertyValues(new MutablePropertyValues(deepCopy))` 方法中调用了 `setPropertyValues(pvs, false, false)` 方法，在该方法中会对 bean 的每一个属性进行填充（通过 `setPropertyValues(pvs, false, false)` 方法对属性进行赋值）

![image-20210124113319078][]

> **回到 `applyPropertyValues(beanName, mbd, bw, pvs)` 方法中**

此时 `bw` 中包裹着 beanA，，执行 `bw.setPropertyValues(new MutablePropertyValues(deepCopy))` 方法会将 `deepCopy` 中的元素依次赋值给 beanA 的各个属性，此时 beanA 中的 `b` 属性已经赋值为 beanA，又加上之前 beanB 中的 `a` 属性已经赋值为 beanA，此时可开启无限套娃模式

![image-20210124114401647][]

> **回到 `doCreateBean(beanName, mbdToUse, args)` 方法中**

执行完 `populateBean(beanName, mbd, instanceWrapper)` 方法后，可以开启无限套娃模式

![image-20210124115239983][]

这次执行 `getSingleton(beanName, false)` 方法能获取到 beanA 吗？

![image-20210124115314625][]

> **进入 `getSingleton(beanName, false)` 方法**

之前 beanB 中注入 `a` 属性时，将 beanA 从三级缓存 `singletonFactories` 移动到了二级缓存 `earlySingletonObjects` 中，因此可以从二级缓存 `earlySingletonObjects` 中获取到 beanA

![image-20210124211309555][]

> **回到 `doCreateBean(beanName, mbdToUse, args)` 方法中**

最终将获取到的 beanA 返回

![image-20210124211546214][]

> **回到 `createBean(beanName, mbd, args)` 方法中**

执行 `doCreateBean(beanName, mbdToUse, args)` 方法后得到 beanA 实例，并将此实例返回

![image-20210124211750032][]

> **回到 `getSingleton(beanName, () -> { ... }` 方法**

执行 `singletonFactory.getObject()` 方法后将获得 beanA 实例，这里的 `singletonFactory` 是我们传入的 Lambda 表达式（专门用于创建 bean 实例）

![image-20210124212010249][]

执行 `addSingleton(beanName, singletonObject)` 方法将 beanA 添加到一级缓存 `singletonObjects` 中

![image-20210124212134609][]

> **进入 `addSingleton(beanName, singletonObject)` 方法**

① 将 beanA 放入一级缓存 `singletonObjects` 中

② 将 beanA 从三级缓存 `singletonFactories` 中删除（beanA 并不在三级缓存中）

③ 将 beanA 从二级缓存 `earlySingletonObjects` 中删除（beanA 确实在二级缓存中）

④ 将 beanA 的 beanName 注册到 `registeredSingletons` 中（之前添加至三级缓存的时候已经注册过啦~）

![image-20210124212338035][]

> **回到 `getSingleton(beanName, () -> { ... }` 方法中**

将 beanA 添加至一级缓存 `singletonObjects` 后，将其返回

![image-20210124212537559][]

> **回到 `doGetBean(name, null, null, false)` 方法中**

执行 `getSingleton(beanName, () -> { ... }` 方法得到 beanA 实例后，将其返回

![image-20210124212741165][]

> **回到 `preInstantiateSingletons()` 方法中**

终于要结束了。。。执行完 `getBean(beanName)` 方法后，将得到无限套娃版本的 beanA 和 beanB 实例

![image-20210124213019608][]

### 2.7、循环依赖总结 ###

#### 2.7.1、全部 Debug 断点 ####

> **导出 Debug 所有断点**

点击【View Breakpoints】

![image-20210124214526041][]

呐，所有断点~~~

![image-20210124214624664][]

#### 2.7.2、Debug 步骤总结 ####

> **循环依赖 Debug 的具体步骤**

1.  调用`doGetBean()`方法，想要获取beanA，于是调用`getSingleton()`方法从缓存中查找beanA
2.  在`getSingleton()`方法中，从一级缓存中查找，没有，返回`null`
3.  `doGetBean()`方法中获取到的beanA为`null`，于是走对应的处理逻辑，调用`getSingleton()`的重载方法（参数为`ObjectFactory`的)
4.  在`getSingleton()`方法中，先将`beanA_name`添加到一个集合中，用于标记该bean正在创建中。然后回调匿名内部类的`creatBean()`方法
5.  进入`AbstractAutowireCapableBeanFactory#doCreateBean()`，先反射调用构造器创建出beanA的实例，然后判断。是否为单例、是否允许提前暴露引用(对于单例一般为`true`)、是否正在创建中〈即是否在第四步的集合中)。判断为`true`则将beanA添加到【三级缓存】中
6.  对beanA进行属性填充，此时检测到beanA依赖于beanB，于是开始查找beanB
7.  调用`doGetBean()`方法，和上面beanA的过程一样，到缓存中查找beanB，没有则创建，然后给beanB填充属性
8.  此时beanB依赖于beanA，调用`getsingleton()`获取beanA，依次从一级、二级、三级缓存中找，此时从三级缓存中获取到beanA的创建工厂，通过创建工厂获取到`singletonObject`，此时这个`singletonObject`指向的就是上面在`doCreateBean()`方法中实例化的beanA
9.  这样beanB就获取到了beanA的依赖，于是beanB顺利完成实例化，并将beanA从三级缓存移动到二级缓存中
10. 随后beanA继续他的属性填充工作，此时也获取到了beanB，beanA也随之完成了创建，回到`getsingleton()`方法中继续向下执行，将beanA从二级缓存移动到一级缓存中

![image-20210124215934076][]

#### 2.7.3、三级缓存总结 ####

> **Spring 创建 Bean 的两大步骤**

**Spring创建bean主要分为两个步骤，创建原始bean对象，接着去填充对象属性和初始化**

每次创建bean之前，我们都会从缓存中查下有没有该bean，因为是单例，只能有一个。当我们创建 beanA的原始对象后，并把它放到三级缓存中，接下来就该填充对象属性了，这时候发现依赖了beanB，接着就又去创建beanB，同样的流程，创建完 beanB填充属性时又发现它依赖了beanA又是同样的流程。

不同的是：这时候可以在三级缓存中查到刚放进去的原始对象beanA，所以不需要继续创建，用它注入beanB，完成beanB的创建既然 beanB创建好了，所以beanA就可以完成填充属性的步骤了，接着执行剩下的逻辑，闭环完成

Spring解决循环依赖依靠的是Bean的“中间态"这个概念，而这个中间态指的是已经实例化但还没初始化的状态，也即半成品。

实例化的过程又是通过构造器创建的，如果A还没创建好出来怎么可能提前曝光，所以构造器的循环依赖无法解决。

> **Spring 的三级缓存**

Spring为了解决单例的循环依赖问题，使用了三级缓存：

1.  其中一级缓存为单例池〈 singletonObjects)
2.  二级缓存为提前曝光对象( earlySingletonObjects)
3.  三级缓存为提前曝光对象工厂( singletonFactories）

![image-20210124220433578][]

--------------------

假设A、B循环引用，实例化A的时候就将其放入三级缓存中，接着填充属性的时候，发现依赖了B，同样的流程也是实例化后放入三级缓存，接着去填充属性时又发现自己依赖A，这时候从缓存中查找到早期暴露的A，没有AOP代理的话，直接将A的原始对象注入B，完成B的初始化后，进行属性填充和初始化，这时候B完成后，就去完成剩下的A的步骤，如果有AOP代理，就进行AOP处理获取代理后的对象A，注入B，走剩下的流程。

#### 2.7.4、Debug 后记 ####

我吐了。。。这篇笔记我是记吐了，Debug 源码太累了，而且太麻烦，关键还要抓图，一不小心断点跑过去了，就得重来一遍，本来之前还兴致勃勃想写完笔记自己做个流程图呢，算了算了，赶下一场 Redis 派对去了，有机会再来补流程图吧~

## 3、后记 ##

由于代码做过迁移，编写本篇笔记时，代码版本为旧代码，因此 GitHub 仓库中的包名和项目名和笔记对应不上，这倒无伤大雅。

[image-20210122153117395]: /images/20221024/6689130f090345b88310f9ae954e0318.png
[image-20210122153554824]: /images/20221024/f3bae2478ff04582a91a28ff2b7b5e8e.png
[image-20210122154310364]: /images/20221024/7755dd14436d48db93fa414bae8a0dac.png
[image-20210122154314389]: /images/20221024/d06a3a5d09644ed8a0894bdbe99af2fe.png
[image-20210122160308629]: /images/20221024/c8555a5d97ee4eff8d6141dbc4fca478.png
[image-20210122160313858]: /images/20221024/aaaf366882d14d3095a457e727bbb7c3.png
[image-20210122160250883]: /images/20221024/951d3c2a5ea74ae7ad6f59c526c95c81.png
[image-20210122181643319]: /images/20221024/e6c2431e398b4b5893934059169f3393.png
[Link 1]: https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-dependencies
[image-20210122182003990]: /images/20221024/aabd26bcd6b94d0b964d7c0ae9d06cec.png
[image-20210122190515257]: /images/20221024/312cfca4763149968fcbc28ac64dd78b.png
[image-20210122185345801]: /images/20221024/add99c4ea97e4618847aaf5dba970791.png
[image-20210122190613296]: /images/20221024/bac795935b6a48339291f2aff2ba6212.png
[image-20210122190652176]: /images/20221024/31a950dfe2fa4e94b793b1c2b855b62f.png
[image-20210122190910426]: /images/20221024/07caf911dc0b4104a10fcf647136eb3a.png
[image-20210123101131093]: /images/20221024/dd8d774fb3514e85aa19d7d4834cbfbc.png
[image-20210123101143372]: /images/20221024/a2dc76891dd5463c83c5f2004343143d.png
[image-20210122223932721]: /images/20221024/22e1c91e6ec44a9387375469c5e76d9a.png
[image-20210122224954341]: /images/20221024/3e5f1bc3804d40529cebd2a2930ca803.png
[image-20210122230104635]: /images/20221024/d1c764c68a5c4a3bad67ea1d660ca8cc.png
[image-20210122230423326]: /images/20221024/a9610cdeda9942ac80f64ea61f390786.png
[image-20210122230632877]: /images/20221024/52f0353946a447848ae9fdbf19eb839e.png
[image-20210122230823849]: /images/20221024/26f477edffc04d03a24227de12192f2b.png
[image-20210122231301414]: /images/20221024/5b3da4ccc94943048195edb8c757a90f.png
[image-20210122231617225]: /images/20221024/5598762b409d496dbcd07b1c550a842a.png
[image-20210122231902178]: /images/20221024/4f1945e9c94142569cf816ba5c512570.png
[image-20210122232111871]: /images/20221024/6500b70253844bd78a8600f331fcadea.png
[image-20210122232301105]: /images/20221024/9c7f1bc408464974b52d9aa861d23743.png
[image-20210122232610296]: /images/20221024/d4a0b2043a94479a80f4d0f254b69a36.png
[image-20210122232708127]: /images/20221024/490043e652a544ad8afb5d393c3279d4.png
[image-20210122232923347]: /images/20221024/2e91da90192c48459e684f46b881cbbe.png
[image-20210122233201164]: /images/20221024/994acf5b407a4761a092ca0b0e975584.png
[image-20210122233255044]: /images/20221024/6e867f35e9254b7d85034fe2a8f1ee2e.png
[image-20210122233409563]: /images/20221024/c7d3231200a9496e83893c8c77471c6c.png
[image-20210122233943061]: /images/20221024/a95b524c6e3f4b638e6c920ac4f60719.png
[image-20210123111611168]: /images/20221024/c731e1e21421406d8017abdf82d2615d.png
[image-20210123112301014]: /images/20221024/24f838cdf41e42edab2e0c3997e7f56f.png
[image-20210123112653528]: /images/20221024/991042dfc16b440c879a17d239b0ccaa.png
[image-20210123113109315]: /images/20221024/67e732dc930848dca4dd73f3227e69b6.png
[image-20210123113439196]: /images/20221024/4084ac0dc8af4f2288010a5e3c4195d1.png
[image-20210123113721708]: /images/20221024/5ee8ee168c7d49b288eca2eac607707d.png
[image-20210123114509257]: /images/20221024/93846619d77a4960a1c28acd408ca613.png
[image-20210123114722004]: /images/20221024/2e14da50ce4844388a5e86894d96e97e.png
[image-20210123115049589]: /images/20221024/478ea3ba644c46918f1c2d91a1271e2d.png
[image-20210123115807740]: /images/20221024/1fdd20f6768d4a3fa5435213f9a670a1.png
[image-20210123120436544]: /images/20221024/28d5f48db91d4c08b465701d19cee4a5.png
[image-20210123120804415]: /images/20221024/fcd09bdd06594d648094aeab6e408dea.png
[image-20210123120941726]: /images/20221024/ee9b1b14836a48a39a30ee2157d12ab0.png
[image-20210123163945288]: /images/20221024/1b5adbc3ac58456799ee55613c65901f.png
[image-20210123164916170]: /images/20221024/c31e9384e938415faf1e8d20a00ea79d.png
[image-20210123165203819]: /images/20221024/290c403df21d417d9e38b3dffe0fa0dd.png
[image-20210123165447074]: /images/20221024/6765658e2953403bacb3845d6c8c91f7.png
[image-20210123165629641]: /images/20221024/1e74ed62bf6f41ed8b861b3ea5bd7cb1.png
[image-20210123170700410]: /images/20221024/447c97e80e9643c2ad55044e1d3dd09d.png
[image-20210123170837080]: /images/20221024/48bd65477d5a47938cdbf83a72d8362b.png
[image-20210123170940500]: /images/20221024/88467d627c6b4952b71ffc439eeb4ce3.png
[image-20210123171328459]: /images/20221024/1281ad47ec7043d9aaaa030f47a220ac.png
[image-20210123171726753]: /images/20221024/31ead2869b7440599cf8f0f7e92ab975.png
[image-20210123171917156]: /images/20221024/9d159f8822d64ec0b62b6e3f64d7f3b5.png
[image-20210123172048186]: /images/20221024/58ac0266531c49b28c0cda8c0e864a3e.png
[image-20210123172426598]: /images/20221024/4e25386e8f6a4d809fad037b2f7eaedc.png
[image-20210123172613391]: /images/20221024/51222ca8003949b6aa6023dae44a3e29.png
[image-20210123173739270]: /images/20221024/1fea9bd4f43a4a87a3bb9ea0e5e22c1a.png
[image-20210123174227557]: /images/20221024/b5f6c650c186402ea14653bd3da774db.png
[image-20210123174510971]: /images/20221024/ab4f29ac809f4affa3c6a1a57995d71f.png
[image-20210123174631167]: /images/20221024/9ced5a3585dd4e8ba0765fa53975b2d1.png
[image-20210123181159951]: /images/20221024/50919eb895154ac39afdb898d1b085da.png
[image-20210123181540128]: /images/20221024/208eea3d25b54f258c843bf345243052.png
[image-20210123230319469]: /images/20221024/eeb37a1ece294004969320948f800bb5.png
[image-20210123230722139]: /images/20221024/d8e2d9ef742940a291fd38ea30697640.png
[image-20210123231047179]: /images/20221024/e5133a8604134f8192599e4473bf62b0.png
[image-20210123231513068]: /images/20221024/5195c06e27ef4a29870a70bbe2adfd41.png
[image-20210123231659756]: /images/20221024/117e1a12e8c94b0ba851ee38cf0bed4c.png
[image-20210123231815848]: /images/20221024/65089d7d51a64fdc8e42a63182c592a5.png
[image-20210123232017300]: /images/20221024/c7f98d3cd93146829161dcce181788aa.png
[image-20210123232156728]: /images/20221024/b6e58942babe4eceadab6144f5ab45be.png
[image-20210123232344101]: /images/20221024/dc2318dcf68e42c4b1f7ff3b16818fc8.png
[image-20210123232617698]: /images/20221024/759c4a1d5ffb4a179a7e64bef66dfa8f.png
[image-20210123233026527]: /images/20221024/2c72021b915148dba8148ba68d8cedb4.png
[image-20210123233404820]: /images/20221024/f401c227abd7440ea82399b130c91231.png
[image-20210123233523439]: /images/20221024/1e20a434d32e427f890f46851583fc1f.png
[image-20210123233916978]: /images/20221024/42f291eaba9946bd992e9157cdf0d39c.png
[image-20210123234133479]: /images/20221024/459bf945c5c14e99aa392176ef8f6bdc.png
[image-20210123234301151]: /images/20221024/e39d73e68a3c45a5af1d79d134c5c85d.png
[image-20210123234518400]: /images/20221024/12ccf106ba804ade85305670cfda41b4.png
[image-20210123234654991]: /images/20221024/852ba6178cc74ff496b314d4563f43c8.png
[image-20210123234750025]: /images/20221024/11008d7260ea42648821c9128429c3ee.png
[image-20210123234916337]: /images/20221024/512bd96c2ffc408bb1dc45f4866bca09.png
[image-20210123235249422]: /images/20221024/19998c18900d484b8cf14c3f21a2cd20.png
[image-20210123235540413]: /images/20221024/e099884c2b92450189575cdf65dd7604.png
[image-20210124000622676]: /images/20221024/d38dc5f844914a8eae957e7d3e229edd.png
[image-20210124000702685]: /images/20221024/0cb255d28d77484eb1fab75c3567e8b0.png
[image-20210124000956873]: /images/20221024/27c3ce8f4241441c95e8d297c7968480.png
[image-20210124001103112]: /images/20221024/effe86810d6849318c104aa228e5cda9.png
[image-20210124001710344]: /images/20221024/9d3e079726f140c0be8ff3f445436119.png
[image-20210124001902295]: /images/20221024/5d42114a2d594c9ebcdf32ab80da5a29.png
[image-20210124002251839]: /images/20221024/f21117eb0ff345d386d1293b5687e19d.png
[image-20210124003102723]: /images/20221024/36d7e36e460b4a2085303958c956c375.png
[image-20210124113724764]: /images/20221024/02d42582413548199b688b98843d348d.png
[image-20210124113855809]: /images/20221024/56fb0d53920d4609877617f4f7bdca89.png
[image-20210124114022056]: /images/20221024/60e7b239c8404c0393cec8d05de6756f.png
[image-20210124003407181]: /images/20221024/d71c3386772846a0b3402cd504973041.png
[image-20210124102307241]: /images/20221024/abd26585f42747e79e78045e93ad011a.png
[image-20210124102706141]: /images/20221024/f871fdb1f6ef480da4b5d648af1bb615.png
[image-20210124102941902]: /images/20221024/db0170ecaaf545d7a01666da2a74208a.png
[image-20210124103604267]: /images/20221024/5acd067ec906468ea2e0caab5afaf1b4.png
[image-20210124104113201]: /images/20221024/0fdd7425543c4e3babdee76aca23c2c9.png
[image-20210124104331897]: /images/20221024/4d6286278d8741cea4248088a5e23029.png
[image-20210124105036099]: /images/20221024/1c139e3e42c54511868be0be2678c1a8.png
[image-20210124105602572]: /images/20221024/56c8e67fe7eb4f3b870577053638630c.png
[image-20210124105914335]: /images/20221024/2357181e90da4e8f91c2e29d9db16faa.png
[image-20210124110528798]: /images/20221024/a4ef951f2e0044d1ba83a8d0651cf249.png
[image-20210124110743721]: /images/20221024/d7c0a00f02c24fe282cd08c6def01d28.png
[image-20210124112123075]: /images/20221024/2a9ed56f9fef497097d049d7ee0160d8.png
[image-20210124112327554]: /images/20221024/542f6b39553e4a6e9ea17b5a5a99922d.png
[image-20210124112557933]: /images/20221024/91413921d6834f348075403854f90973.png
[image-20210124112719836]: /images/20221024/633735481c354cdfacbf7fda780a5667.png
[image-20210124113319078]: /images/20221024/bc23e73c05a34ab7aa6cf3edae0815f4.png
[image-20210124114401647]: /images/20221024/ebc2e5cdd95f4f01ab471ab8e4424ce0.png
[image-20210124115239983]: /images/20221024/ba6af93f7ca946ec86a6b431ca08a8d8.png
[image-20210124115314625]: /images/20221024/99d99afb3618400a827700a9b142cc8f.png
[image-20210124211309555]: /images/20221024/c7c42a7d7f1448c1878b9177ba29491d.png
[image-20210124211546214]: /images/20221024/4251e7dc5a1746d6a95f29d7b75c72e6.png
[image-20210124211750032]: /images/20221024/73a26917d68d4ba880f37d91ed3fea85.png
[image-20210124212010249]: /images/20221024/feca11f38d4f4c03a413ceb0b4487592.png
[image-20210124212134609]: /images/20221024/c16f971366984af69f09070d2fbd1f1d.png
[image-20210124212338035]: /images/20221024/51122edb2c7f4004b1bb6eb2bf6ab817.png
[image-20210124212537559]: /images/20221024/4307a9ceb29a4f899869d95918a98ff2.png
[image-20210124212741165]: /images/20221024/373ba7037fdf4dada1ef7961565f793d.png
[image-20210124213019608]: /images/20221024/5e0e174bc48d42bb812194a93e1f82ee.png
[image-20210124214526041]: /images/20221024/671df8b9ede844d68ccc25f940608485.png
[image-20210124214624664]: /images/20221024/56a9a9b29fde42fea3b6c37d42ca1407.png
[image-20210124215934076]: /images/20221024/0ffb9557a48741d7bea6df87898664f6.png
[image-20210124220433578]: /images/20221024/5d16ce860276445dbf35d68c726c4820.png