1. AOP

1. Aop的题目说明要求

Spring的AOP顺序
Spring的循环依赖
AOP常用注解：

  • @Before 前置通知：目标方法之前执行
  • @After 后置通知：目标方法之后执行（始终执行)
  • @AfterReturning 返回后通知：执行方法结束前执行(异常不执行)
  • @AfterThrowing 异常通知：出现异常时候执行
  • @Around 环绕通知：环绕目标方法执行

面试题
你肯定知道spring，那说说aop的全部通知顺序springboot或springboot2对aop的执行顺序影响？
说说你使用AOP中碰到的坑?

2. spring4下的aop测试案例

新建Maven工程，pom.xml如下：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  6.     <parent>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-parent</artifactId>
  9.         <version>1.5.9.RELEASE</version>
  10.         <relativePath/> <!-- lookup parent from repository -->
  11.     </parent>
  13.     <groupId>com.lun</groupId>
  14.     <artifactId>HelloSpringBoot</artifactId>
  15.     <version>1.0.0-SNAPSHOT</version>
  16.     <packaging>jar</packaging>
  18.     <name>HelloSpringBoot</name>
  19.     <url>http://maven.apache.org</url>
  21.     <properties>
  22.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23.     </properties>
  25.     <dependencies>
  26.         <!-- <version>1.5.9.RELEASE</version〉 ch/qos/Logback/core/joran/spi/JoranException解决方案-->
  27.         <dependency>
  28.             <groupId>ch.qos.logback</groupId>
  29.             <artifactId>logback-core</artifactId>
  30.             <version>1.1.3</version>
  31.         </dependency>
  33.         <dependency>
  34.             <groupId>ch.qos.logback</groupId>
  35.             <artifactId>logback-access</artifactId>
  36.             <version>1.1.3</version>
  37.         </dependency>
  39.         <dependency>
  40.             <groupId>ch.qos.logback</groupId>
  41.             <artifactId>logback-classic</artifactId>
  42.             <version>1.1.3</version>
  43.         </dependency>
  45.         <!-- web+actuator -->
  46.         <dependency>
  47.             <groupId>org.springframework.boot</groupId>
  48.             <artifactId>spring-boot-starter-web</artifactId>
  49.         </dependency>
  51.         <dependency>
  52.             <groupId>org.springframework.boot</groupId>
  53.             <artifactId>spring-boot-starter-actuator</artifactId>
  54.         </dependency>
  56.         <!-- SpringBoot与Redis整合依赖 -->
  57.         <!-- 
  58.         <dependency>
  59.             <groupId>org.springframework.boot</groupId>
  60.             <artifactId>spring-boot-starter-data-redis</artifactId>
  61.         </dependency>
  62.          -->
  64.         <dependency>
  65.             <groupId>org.apache.commons</groupId>
  66.             <artifactId>commons-pool2</artifactId>
  67.         </dependency>
  69.         <!-- jedis -->
  70.         <dependency>
  71.             <groupId>redis.clients</groupId>
  72.             <artifactId>jedis</artifactId>
  73.             <version>3.1.0</version>
  74.         </dependency>
  76.         <!-- Spring Boot AOP技术-->
  77.         <dependency>
  78.             <groupId>org.springframework.boot</groupId>
  79.             <artifactId>spring-boot-starter-aop</artifactId>
  80.         </dependency>
  82.         <!-- redisson -->
  83.         <dependency>
  84.             <groupId>org.redisson</groupId>
  85.             <artifactId>redisson</artifactId>
  86.             <version>3.13.4</version>
  87.         </dependency>
  89.         <!-- 一般通用基础配置 -->
  90.         <dependency>
  91.             <groupId>org.springframework.boot</groupId>
  92.             <artifactId>spring-boot-devtools</artifactId>
  93.             <scope>runtime</scope>
  94.             <optional>true</optional>
  95.         </dependency>
  97.         <dependency>
  98.             <groupId>org.projectlombok</groupId>
  99.             <artifactId>lombok</artifactId>
  100.             <optional>true</optional>
  101.         </dependency>
  103.         <dependency>
  104.             <groupId>org.springframework.boot</groupId>
  105.             <artifactId>spring-boot-starter-test</artifactId><scope>test</scope>
  106.             <exclusions>
  107.                 <exclusion>
  108.                     <groupId>org.junit.vintage</groupId>
  109.                     <artifactId>junit-vintage-engine</artifactId>
  110.                 </exclusion>
  111.             </exclusions>
  112.         </dependency>
  114.     </dependencies>
  116.     <build>
  117.         <plugins>
  118.             <plugin>
  119.                 <groupId>org.springframework.boot</groupId>
  120.                 <artifactId>spring-boot-maven-plugin</artifactId>
  121.             </plugin>
  122.         </plugins>
  123.     </build>
  125. </project>

启动类

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class MainApplication {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(MainApplication.class, args);
  8.     }
  9. }

接口CalcService

  1. public interface CalcService {    
  2.     public int div(int x, int y);
  3. }

接口实现类CalcServiceImpl新加@Service

  1. import org.springframework.stereotype.Service;
  3. @Service
  4. public class CalcServiceImpl implements CalcService {
  6.     @Override
  7.     public int div(int x, int y) {
  8.         int result = x / y;
  9.         System.out.println("===>CalcServiceImpl被调用，计算结果为：" + result);
  10.         return result;
  11.     }
  12. }

新建一个切面类MyAspect并为切面类新增两个注解：

  • @Aspect 指定一个类为切面类
  • @Component 纳入Spring容器管理 ```java import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component;

@Aspect @Component public class MyAspect { @Before(“execution(public int com.lun.interview.service.CalcServiceImpl.(..))”) public void beforeNotify() { System.out.println(“*@Before我是前置通知”); }

  1. @After("execution(public int com.lun.interview.service.CalcServiceImpl.*(..))")
  2. public void afterNotify() {
  3.     System.out.println("********@After我是后置通知");
  4. }
  6. @AfterReturning("execution(public int com.lun.interview.service.CalcServiceImpl.*(..))")
  7. public void afterReturningNotify() {
  8.     System.out.println("********@AfterReturning我是返回后通知");
  9. }
  11. @AfterThrowing(" execution(public int com.lun.interview.service.CalcServiceImpl.*(..))")
  12. public void afterThrowingNotify() {
  13.     System.out.println("********@AfterThrowing我是异常通知");
  14. }
  16. @Around(" execution(public int com.lun.interview.service.CalcServiceImpl.*(..))")
  17. public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  18.     Object retvalue = null;
  19.     System.out.println("我是环绕通知之前AAA");
  20.     retvalue = proceedingJoinPoint.proceed();
  21.     System.out.println("我是环绕通知之后BBB");
  22.     return retvalue ;
  23. }

}

  1. 测试类
  2. ```java
  3. import javax.annotation.Resource;
  5. import org.junit.Test;
  6. import org.junit.runner.RunWith;
  7. import org.springframework.boot.SpringBootVersion;
  8. import org.springframework.boot.test.context.SpringBootTest;
  9. import org.springframework.core.SpringVersion;
  10. import org.springframework.test.context.junit4.SpringRunner;
  12. import com.lun.interview.service.CalcService;
  14. @SpringBootTest
  15. @RunWith(SpringRunner.class)
  16. public class AopTest {
  18.     @Resource
  19.     private CalcService calcService;
  21.     @Test
  22.     public void testAop4() {
  23.         System.out.println(String.format("Spring Verision : %s, Sring Boot Version : %s.", //
  24.                 SpringVersion.getVersion(), SpringBootVersion.getVersion()));
  26.         calcService.div(10, 2);
  27.     }
  28. }

3. spring4下的aop测试结果

继续上节
输出结果：

  1. Spring Verision : 4.3.13.RELEASE, Sring Boot Version : 1.5.9.RELEASE.
  3. 我是环绕通知之前AAA
  4. ********@Before我是前置通知
  5. ===>CalcServiceImpl被调用，计算结果为：5
  6. 我是环绕通知之后BBB
  7. ********@After我是后置通知
  8. ********@AfterReturning我是返回后通知

修改测试类，让其抛出算术异常类：

  1. @SpringBootTest
  2. @RunWith(SpringRunner.class)
  3. public class AopTest {
  5.     @Resource
  6.     private CalcService calcService;
  8.     @Test
  9.     public void testAop4() {
  10.         System.out.println(String.format("Spring Verision : %s, Sring Boot Version : %s.", //
  11.                 SpringVersion.getVersion(), SpringBootVersion.getVersion()));
  13.         //calcService.div(10, 2);
  14.         calcService.div(10, 0);//将会抛异常
  15.     }
  16. }

输出结果：

  1. Spring Verision : 4.3.13.RELEASE, Sring Boot Version : 1.5.9.RELEASE.
  3. 我是环绕通知之前AAA
  4. ********@Before我是前置通知
  5. ********@After我是后置通知
  6. ********@AfterThrowing我是异常通知
  8. java.lang.ArithmeticException: / by zero
  9.     at com.lun.interview.service.CalcServiceImpl.div(CalcServiceImpl.java:10)
  10.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  11.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  12.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  13.     at java.lang.reflect.Method.invoke(Method.java:498)
  14.     ...

小结
AOP执行顺序：

  • 正常情况下：@Before前置通知——->@After后置通知——->@AfterRunning正常返回
  • 异常情况下：@Before前置通知——->@After后置通知——->@AfterThrowing方法异常

4. spring5下的aop测试

修改POM

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  6.     <parent>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-parent</artifactId>
  9.         <version>2.3.3.RELEASE</version>
  10.         <!-- 1.5.9.RELEASE -->
  11.         <relativePath/> <!-- lookup parent from repository -->
  12.     </parent>
  14.     <groupId>com.lun</groupId>
  15.     <artifactId>HelloSpringBoot</artifactId>
  16.     <version>1.0.0-SNAPSHOT</version>
  17.     <packaging>jar</packaging>
  19.     <name>HelloSpringBoot</name>
  20.     <url>http://maven.apache.org</url>
  22.     <properties>
  23.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  24.     </properties>
  26.     <dependencies>
  27.         <!-- web+actuator -->
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-web</artifactId>
  31.         </dependency>
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-actuator</artifactId>
  36.         </dependency>
  38.         <!-- SpringBoot与Redis整合依赖 -->
  39.         <!-- 
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-starter-data-redis</artifactId>
  43.         </dependency>
  44.          -->
  46.         <dependency>
  47.             <groupId>org.apache.commons</groupId>
  48.             <artifactId>commons-pool2</artifactId>
  49.         </dependency>
  51.         <!-- jedis -->
  52.         <dependency>
  53.             <groupId>redis.clients</groupId>
  54.             <artifactId>jedis</artifactId>
  55.             <version>3.1.0</version>
  56.         </dependency>
  58.         <!-- Spring Boot AOP技术-->
  59.         <dependency>
  60.             <groupId>org.springframework.boot</groupId>
  61.             <artifactId>spring-boot-starter-aop</artifactId>
  62.         </dependency>
  64.         <!-- redisson -->
  65.         <dependency>
  66.             <groupId>org.redisson</groupId>
  67.             <artifactId>redisson</artifactId>
  68.             <version>3.13.4</version>
  69.         </dependency>
  71.         <!-- 一般通用基础配置 -->
  72.         <dependency>
  73.             <groupId>org.springframework.boot</groupId>
  74.             <artifactId>spring-boot-devtools</artifactId>
  75.             <scope>runtime</scope>
  76.             <optional>true</optional>
  77.         </dependency>
  79.         <dependency>
  80.             <groupId>org.projectlombok</groupId>
  81.             <artifactId>lombok</artifactId>
  82.             <optional>true</optional>
  83.         </dependency>
  85.         <dependency>
  86.             <groupId>org.springframework.boot</groupId>
  87.             <artifactId>spring-boot-starter-test</artifactId><scope>test</scope>
  88.             <exclusions>
  89.                 <exclusion>
  90.                     <groupId>org.junit.vintage</groupId>
  91.                     <artifactId>junit-vintage-engine</artifactId>
  92.                 </exclusion>
  93.             </exclusions>
  94.         </dependency>
  96.     </dependencies>
  98.     <build>
  99.         <plugins>
  100.             <plugin>
  101.                 <groupId>org.springframework.boot</groupId>
  102.                 <artifactId>spring-boot-maven-plugin</artifactId>
  103.             </plugin>
  104.         </plugins>
  105.     </build>
  107. </project>

修改测试类

  1. import javax.annotation.Resource;
  3. import org.junit.jupiter.api.Test;
  4. //import org.junit.Test;
  5. //import org.junit.runner.RunWith;
  6. import org.springframework.boot.SpringBootVersion;
  7. import org.springframework.boot.test.context.SpringBootTest;
  8. import org.springframework.core.SpringVersion;
  9. //import org.springframework.test.context.junit4.SpringRunner;
  11. import com.lun.interview.service.CalcService;
  13. @SpringBootTest
  14. //@RunWith(SpringRunner.class)
  15. public class AopTest {
  17.     @Resource
  18.     private CalcService calcService;
  20.     @Test
  21.     public void testAop5() {
  22.         System.out.println(String.format("Spring Verision : %s, Sring Boot Version : %s.", //
  23.                 SpringVersion.getVersion(), SpringBootVersion.getVersion()));
  24.         System.out.println();
  25.         calcService.div(10, 2);
  26.         //calcService.div(10, 0);
  27.     }
  29. }

输出结果

  1. Spring Verision : 5.2.8.RELEASE, Sring Boot Version : 2.3.3.RELEASE.
  3. 我是环绕通知之前AAA
  4. ********@Before我是前置通知
  5. ===>CalcServiceImpl被调用，计算结果为：5
  6. ********@AfterReturning我是返回后通知
  7. ********@After我是后置通知
  8. 我是环绕通知之后BBB

修改测试类，让其抛出算术异常类：

  1. @SpringBootTest
  2. public class AopTest {
  4.     @Resource
  5.     private CalcService calcService;
  7.     ...
  9.     @Test
  10.     public void testAop5() {
  11.         System.out.println(String.format("Spring Verision : %s, Sring Boot Version : %s.", //
  12.                 SpringVersion.getVersion(), SpringBootVersion.getVersion()));
  13.         System.out.println();
  14.         calcService.div(10, 2);
  15.         //calcService.div(10, 0);
  16.     }
  18. }

输出结果

  1. Spring Verision : 5.2.8.RELEASE, Sring Boot Version : 2.3.3.RELEASE.
  3. 我是环绕通知之前AAA
  4. ********@Before我是前置通知
  5. ********@AfterThrowing我是异常通知
  6. ********@After我是后置通知
  8. java.lang.ArithmeticException: / by zero
  9.     at com.lun.interview.service.CalcServiceImpl.div(CalcServiceImpl.java:10)
  10.     at com.lun.interview.service.CalcServiceImpl$$FastClassBySpringCGLIB$$355acbc4.invoke(<generated>)
  11.     at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
  12.     at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:771)

2. 循环依赖

1. spring循环依赖题目说明

恶心的大厂面试题

  • 你解释下spring中的三级缓存？
  • 三级缓存分别是什么？三个Map有什么异同？
  • 什么是循环依赖？请你谈谈？看过spring源码吗？
  • 如何检测是否存在循环依赖？实际开发中见过循环依赖的异常吗？
  • 多例的情况下，循环依赖问题为什么无法解决？

    什么是循环依赖？

多个bean之间相互依赖，形成了一个闭环。比如：A依赖于B、B依赖于C、C依赖于A。
通常来说，如果问Spring容器内部如何解决循环依赖，一定是指默认的单例Bean中，属性互相引用的场景。
图片.png
两种注入方式对循环依赖的影响
循环依赖官网说明

Circular dependencies If you use predominantly constructor injection, it is possible to create an unresolvable circular dependency scenario. For example: Class A requires an instance of class B through constructor injection, and class B requires an instance of class A through constructor injection. If you configure beans for classes A and B to be injected into each other, the Spring IoC container detects this circular reference at runtime, and throws a BeanCurrentlyInCreationException. One possible solution is to edit the source code of some classes to be configured by setters rather than constructors. Alternatively, avoid constructor injection and use setter injection only. In other words, although it is not recommended, you can configure circular dependencies with setter injection. Unlike the typical case (with no circular dependencies), a circular dependency between bean A and bean B forces one of the beans to be injected into the other prior to being fully initialized itself (a classic chicken-and-egg scenario). link

结论

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

三级缓存

首先看下Spring创建一个bean的基本流程：
创建该实例的原始对象 —> 进行自动装配 —> AOP代理处理 —> 完成bean的创建并加入单例池(即一级缓存)
但是当有循环依赖的时候，Spring是如何解决的呢？
主要原理是利用三级缓存机制：
图片.png
singletonObjects： 一级缓存，也就是我们平常理解的单例池。
singletonFactories： 二级缓存，存储的是单例工厂。
earlySingletonObjects： 三级缓存，存储正在创建中的单例对象。

为什么要设立三级缓存呢？

其实当不需要实现AOP的时候，解决循环依赖不用三级缓存机制，也不用单例工厂，二级缓存就足以实现。
第一级：singletonObjects
第二级：earlySingletonObjects

不需要实现AOP时Spring解决循环依赖基本流程：

假设单例一与单例二相互依赖对方并且此时都没有加入到单例池
1 创建单例一
2 将单例一加入earlySingletonObjects缓存
3 自动装配单例二
4 判断单例二在earlySingletonObjects缓存是否存在
5 不存在则创建单例二
6 将单例二并且加入earlySingletonObjects缓存
7 自动装配单例一
8 判断单例一在earlySingletonObjects缓存是否存在
9 明显第2步已经加入earlySingletonObjects缓存
10 注入成功,单例2创建完成并加入singletonObjects单例池
11 注入成功,单例1创建完成并加入singletonObjects单例池

那为什么要设立三级缓存呢？

这是因为当我们需要使用AOP时，将会对原始对象进行代理，因此最后的对象将是代理对象而不是原始对象！

所以按照二级缓存的步骤进行创建的话将会造成一个问题：

第2步加入到二级缓存中的对象是原始对象，导致第7步自动装配到到单例2中的单例1对象是原始对象，这个对象还没有完成AOP的处理。如果此时完成单例2的创建，之后在完成进行单例1的创建时，单例1对原始对象进行AOP处理，将导致最终的单例1对象不是之前自动装配到单例2中的单例1对象。

所以Spring选择使用三级缓存来解决这个问题：singletonFactories缓存中的对象是一个单例工厂，该工厂可以将原始对象进行AOP处理。

getSingleton方法的大概处理过程为：
1 判断singletonObjects单例池中是否存在，存在则返回
2 不存在则判断earlySingletonObjects缓存中是否存在，存在则返回
3 不存在则判断singletonFactories缓存中是否存在，不存在则返回null
4 存在则通过该存储工厂创建出最终的bean
5 将该bean加入earlySingletonObjects缓存并从singletonFactories缓存中中移除

存在三级缓存机制下处理流程如下：
假设单例1与单例2相互依赖对方并且此时都没有加入到单例池
1 创建单例一
2 创建单例一的工厂对象并且加入singletonFactories缓存
3 自动装配单例二
4 通过 getSingleton方法 判断单例二在三级缓存中是否存在
5 明显此时单例一不存在，所以创建单例二
6 创建单例二的工厂并且加入singletonFactories缓存
7 自动装配单例一
8 通过 getSingleton方法 判断单例一在三级缓存中是否存在
9 明显第2步已经加入singletonFactories缓存
10 单例二进行AOP处理
11 注入单例一成功,单例二创建完成并加入singletonObjects单例池
12 注入单例二成功,单例一创建完成并加入singletonObjects单例池

以上步骤Spring就完美解决了循环依赖的问题！

检测循环依赖

spring针对循环依赖问题 不能完全解决 对于不能解决的只能检测到并抛出异常
1. spring针对构造器方法的 单实例对象和原型对象是无法解决循环依赖问题的 先说结论, 针对单例对象 getSingleton方法中 有个beforeSingletonCreation 方法 这个方法是用来检测循环依赖的 原型对象 isPrototypeCurrentlyInCreation方法beforePrototypeCreation方法配合检测循环依赖
注: inCreationCheckExclusions和singletonsCurrentlyInCreation 是两个set

  1. 1 protected void beforeSingletonCreation(String beanName) {
  2. 2         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
  3. 3             throw new BeanCurrentlyInCreationException(beanName);
  4. 4         }
  5. 5     }

以AB两个单例对象举例,

  1. Class A(){
  2.     A(B b){
  3.   }
  4. }
  6. Class B(){
  7.     B(A a){
  8.   }
  9. }

对象A在实例化的时候(getBean方法),会先执行beforeSingletonCreation方法 吧自己的beanName放入set中,然后去执行实例化 解析构造器方法的时候发现 需要用到对象B ,所以去getBean(B)
B对象在一级缓存是没有的(因为是还未实例化),所以去创建单例B,会执行和A一样的操作,把自己的beanName放入set中,然后解析构造器的时候发现依赖A对象,去一级缓存获取是没有的(因为A对象实例化还未完成 未放入到一级缓存中)
所以去实例化A 放入set的时候 发现已经存在及会抛出异常

  1. 1 protected boolean isPrototypeCurrentlyInCreation(String beanName) {
  2. 2         Object curVal = this.prototypesCurrentlyInCreation.get();
  3. 3         return (curVal != null &&
  4. 4                 (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
  5. 5     }
  1. protected void beforePrototypeCreation(String beanName) {
  2.         Object curVal = this.prototypesCurrentlyInCreation.get();
  3.         if (curVal == null) {
  4.             this.prototypesCurrentlyInCreation.set(beanName);
  5.         }
  6.         else if (curVal instanceof String) {
  7.             Set<String> beanNameSet = new HashSet<>(2);
  8.             beanNameSet.add((String) curVal);
  9.             beanNameSet.add(beanName);
  10.             this.prototypesCurrentlyInCreation.set(beanNameSet);
  11.         }
  12.         else {
  13.             Set<String> beanNameSet = (Set<String>) curVal;
  14.             beanNameSet.add(beanName);
  15.         }
  16.     }

对象在实例化之前会先调用isPrototypeCurrentlyInCreation方法,如果set中没有继续执行,实例化的时候调用beforePrototypeCreation方法 放入set中,在之后的循环依赖中 查询到set中有自己的beanName 则抛出异常

那么spring对set方法注入 是如何解决循环依赖问题的呢,一样先说结论 是使用第三级缓存来解决的
1. 在实例化bean A的时候 先去查看一级缓存中是否有(执行的方法getSingleton)
并且会查询currentlyCreationSet中有没有
2. 处理一下depend-on依赖 或者检查一下是否是抽象等等安全性校验
3.把单实例的A 的beanName放入currentlyCreationSet中
4. 实例化A对象因为是set注入 所以这时使用的空参构造 去反射出实例对象 得到一个早期对象(未进行属性注入的对象,未执行init方法调用,未进行后处理器处理,早期对象和处理后的对象的内存地址是一样的aop对象除外)
5. 早期实例A封装到objectFactory对象中,放入三级缓存
6. 进行依赖注入 依赖注入的时候发现依赖Bean B 再去执行getBean方法 重复执行1-6步 拿到一个B的早期对象objectFactory 放入到三级缓存
7. 处理B的依赖注入 发现B依赖了A 执行getbean方法 从1开始执行 去一级缓存查询没有 去currentlyCreationSet查询有A 去三级缓存中拿到A的早期实例 放入二级缓存清除三级缓存中的A早期实例并返回这个早期实例 B继续执行完成了B对象的实例 放入一级缓存中 清除掉二三级缓存相关数据
8. 继续执行A的实例化步骤 A完成实例化 存入一级缓存 清除二三级缓存相关数据 

  1. protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  2.         Object singletonObject = this.singletonObjects.get(beanName);
  3.         if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  4.             synchronized (this.singletonObjects) {
  5.                 singletonObject = this.earlySingletonObjects.get(beanName);
  6.                 if (singletonObject == null && allowEarlyReference) {
  7.                     ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  8.                     if (singletonFactory != null) {
  9.                         singletonObject = singletonFactory.getObject();
  10.                         this.earlySingletonObjects.put(beanName, singletonObject);
  11.                         this.singletonFactories.remove(beanName);
  12.                     }
  13.                 }
  14.             }
  15.         }
  16.         return singletonObject;
  17.     }

2. spring循环依赖纯java代码验证案例

Spring容器循环依赖报错演示BeanCurrentlylnCreationException
循环依赖现象在spring容器中注入依赖的对象，有2种情况

  • 构造器方式注入依赖（不可行）
  • 以set方式注入依赖（可行）

构造器方式注入依赖（不可行）

  1. @Component
  2. public class ServiceB{
  3.     private ServiceA serviceA;
  5.     public ServiceB(ServiceA serviceA){
  6.         this.serviceA = serviceA;
  7.     }
  8. }
  1. @Component
  2. public class ServiceA{
  3.     private ServiceB serviceB;
  5.     public ServiceA(ServiceB serviceB){
  6.         this.serviceB = serviceB;
  7.     }
  8. }
  1. public class ClientConstructor{
  2.     public static void main(String[] args){
  3.         new ServiceA(new ServiceB(new ServiceA()));//这会抛出编译异常
  4.     }
  5. }

以set方式注入依赖（可行）

  1. @Component
  2. public class ServiceBB{
  3.     private ServiceAA serviceAA;
  5.     public void setServiceAA(ServiceAA serviceAA){
  6.         this.serviceAA = serviceAA;
  7.         System.out.println("B里面设置了A");
  8.     }
  9. }
  1. @Component
  2. public class ServiceAA{
  3.     private ServiceBB serviceBB;
  5.     public void setServiceBB(ServiceBB serviceBB){
  6.         this.serviceBB = serviceBB;
  7.         System.out.println("A里面设置了B");
  8.     }
  9. }
  1. public class ClientSet{
  2.     public static void main(String[] args){
  3.         //创建serviceAA
  4.         ServiceAA a = new ServiceAA();
  5.         //创建serviceBB
  6.         ServiceBB b = new ServiceBB();
  7.         //将serviceA入到serviceB中
  8.         b.setServiceAA(a);
  9.         //将serviceB法入到serviceA中
  10.         a.setServiceBB(b);
  11.     }
  12. }

输出结果：

  1. B里面设置了A
  2. A里面设置了B

3. spring循环依赖bug演示

beans：A，B

  1. public class A {
  3.     private B b;
  5.     public B getB() {
  6.         return b;
  7.     }
  9.     public void setB(B b) {
  10.         this.b = b;
  11.         System.out.println("A call setB.");
  12.     }
  13. }
  1. public class B {
  3.     private A a;
  5.     public A getA() {
  6.         return a;
  7.     }
  9.     public void setA(A a) {
  10.         this.a = a;
  11.         System.out.println("B call setA.");
  12.     }    
  13. }

运行类

  1. import org.springframework.context.ApplicationContext;
  2. import org.springframework.context.support.ClassPathXmlApplicationContext;
  4. public class ClientSpringContainer {
  6.     public static void main(String[] args) {
  7.         ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  8.         A a = context.getBean("a", A.class);
  9.         B b = context.getBean("b", B.class);
  10.     }
  11. }

默认的单例(Singleton)的场景是支持循环依赖的，不报错
beans.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
  7.        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  8.        http://www.springframework.org/schema/context 
  9.        http://www.springframework.org/schema/context/spring-context-4.0.xsd
  10.        http://www.springframework.org/schema/tx 
  11.        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
  12.        http://www.springframework.org/schema/aop
  13.        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
  15.     <bean id="a" class="com.lun.interview.circular.A">
  16.         <property name="b" ref="b"></property>
  17.     </bean>
  18.     <bean id="b" class="com.lun.interview.circular.B">
  19.         <property name="a" ref="a"></property>
  20.     </bean>
  22. </beans>

输出结果

  1. 00:00:25.649 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6d86b085
  2. 00:00:25.828 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 2 bean definitions from class path resource [beans.xml]
  3. 00:00:25.859 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'a'
  4. 00:00:25.875 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'b'
  5. B call setA.
  6. A call setB.

原型(Prototype)的场景是不支持循环依赖的，会报错
beans.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
  7.        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  8.        http://www.springframework.org/schema/context 
  9.        http://www.springframework.org/schema/context/spring-context-4.0.xsd
  10.        http://www.springframework.org/schema/tx 
  11.        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
  12.        http://www.springframework.org/schema/aop
  13.        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
  15.     <bean id="a" class="com.lun.interview.circular.A" scope="prototype">
  16.         <property name="b" ref="b"></property>
  17.     </bean>
  18.     <bean id="b" class="com.lun.interview.circular.B" scope="prototype">
  19.         <property name="a" ref="a"></property>
  20.     </bean>
  22. </beans>

输出结果

  1. 00:01:39.904 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6d86b085
  2. 00:01:40.062 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 2 bean definitions from class path resource [beans.xml]
  3. Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'a' defined in class path resource [beans.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 [beans.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?
  4.     at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:342)
  5.     at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessary(BeanDefinitionValueResolver.java:113)
  6.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyPropertyValues(AbstractAutowireCapableBeanFactory.java:1697)
  7.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1442)
  8.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:593)
  9.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:516)
  10.     at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:342)
  11.     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:207)
  12.     at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1115)
  13.     at com.lun.interview.circular.ClientSpringContainer.main(ClientSpringContainer.java:10)
  14. Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'b' defined in class path resource [beans.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?
  15.     at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:342)
  16.     at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessary(BeanDefinitionValueResolver.java:113)
  17.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyPropertyValues(AbstractAutowireCapableBeanFactory.java:1697)
  18.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1442)
  19.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:593)
  20.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:516)
  21.     at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:342)
  22.     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)
  23.     at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:330)
  24.     ... 9 more
  25. Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?
  26.     at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:268)
  27.     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)
  28.     at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:330)
  29.     ... 17 more

重要结论(spring内部通过3级缓存来解决循环依赖) - DefaultSingletonBeanRegistry

只有单例的bean会通过三级缓存提前暴露来解决循环依赖的问题，而非单例的bean，每次从容器中获取都是一个新的对象，都会重新创建，所以非单例的bean是没有缓存的，不会将其放到三级缓存中。

第一级缓存（也叫单例池）singletonObjects：存放已经经历了完整生命周期的Bean对象。
第二级缓存：earlySingletonObjects，存放早期暴露出来的Bean对象，Bean的生命周期未结束（属性还未填充完。
第三级缓存：Map> singletonFactories，存放可以生成Bean的工厂。

  1. package org.springframework.beans.factory.support;
  3. ...
  5. public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
  7.     ...
  9.     /** Cache of singleton objects: bean name to bean instance. */
  10.     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  12.     /** Cache of singleton factories: bean name to ObjectFactory. */
  13.     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  15.     /** Cache of early singleton objects: bean name to bean instance. */
  16.     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
  18.     ...
  20. }

4. spring循环依赖debug前置知识

实例化 - 内存中申请一块内存空间，如同租赁好房子，自己的家当还未搬来。
初始化属性填充 - 完成属性的各种赋值，如同装修，家具，家电进场。
3个Map和四大方法，总体相关对象
图片.png
第一层 singletonObjects存放的是已经初始化好了的Bean,
第二层 earlySingletonObjects存放的是实例化了，但是未初始化的Bean,
第三层 singletonFactories存放的是FactoryBean。假如A类实现了FactoryBean,那么依赖注入的时候不是A类，而是A类产生的Bean

  1. package org.springframework.beans.factory.support;
  3. ...
  5. public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
  7.     ...
  9.     /** 
  10.     单例对象的缓存:bean名称—bean实例，即:所谓的单例池。
  11.     表示已经经历了完整生命周期的Bean对象
  12.     第一级缓存
  13.     */
  14.     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  16.     /**
  17.     早期的单例对象的高速缓存: bean名称—bean实例。
  18.     表示 Bean的生命周期还没走完（Bean的属性还未填充）就把这个 Bean存入该缓存中也就是实例化但未初始化的 bean放入该缓存里
  19.     第二级缓存
  20.     */
  21.     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
  23.     /**
  24.     单例工厂的高速缓存:bean名称—ObjectFactory
  25.     表示存放生成 bean的工厂
  26.     第三级缓存
  27.     */
  28.     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  30.     ...
  32. }

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

  1. A创建过程中需要B，于是A将自己放到三级缓里面，去实例化B。
  2. B实例化的时候发现需要A，于是B先查一级缓存，没有，再查二级缓存，还是没有，再查三级缓存，找到了A然后把三级缓存里面的这个A放到二级缓存里面，并删除三级缓存里面的A。

  3. B顺利初始化完毕，将自己放到一级缓存里面（此时B里面的A依然是创建中状态)，然后回来接着创建A，此时B已经创建结束，直接从一级缓存里面拿到B，然后完成创建，并将A自己放到一级缓存里面。 ```java @FunctionalInterface public interface ObjectFactory {

    T getObject() throws BeansException;

}

  1. <a name="Qd7bP"></a>
  2. ## 5. spring循环依赖debug源码
  3. DEBUG一步一步来，scope默认为singleton<br />从运行类启航
  4. ```java
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;
  8. public class ClientSpringContainer {
  10.     public static void main(String[] args) {
  11.         ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  12.         A a = context.getBean("a", A.class);
  13.         B b = context.getBean("b", B.class);
  14.     }
  16. }
  1. package org.springframework.context.support;
  3. ...
  5. public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
  7.     public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
  8.         this(new String[] {configLocation}, true, null);
  9.     }
  11.     public ClassPathXmlApplicationContext(
  12.             String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
  13.             throws BeansException {
  15.         super(parent);
  16.         setConfigLocations(configLocations);
  17.         if (refresh) {
  18.             //源于AbstractXmlApplicationContext
  19.             //->AbstractRefreshableConfigApplicationContext
  20.             //->AbstractRefreshableApplicationContext
  21.             //->AbstractApplicationContext的refresh()
  22.             refresh();
  23.         }
  24.     }
  26. }
  1. package org.springframework.context.support;
  3. ...
  5. public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {
  6.     ...
  7. }
  1. package org.springframework.context.support;
  3. ...
  5. public abstract class AbstractRefreshableConfigApplicationContext extends AbstractRefreshableApplicationContext
  6.         implements BeanNameAware, InitializingBean {
  7.     ...
  8. }
  1. package org.springframework.context.support;
  3. ...
  5. public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
  6.     ...
  7. }
  1. package org.springframework.context.support;
  3. ...
  5. public abstract class AbstractApplicationContext extends DefaultResourceLoader
  6.         implements ConfigurableApplicationContext {
  8.     ...
  10.     @Override
  11.     public void refresh() throws BeansException, IllegalStateException {
  12.         synchronized (this.startupShutdownMonitor) {
  13.             // Prepare this context for refreshing.
  14.             prepareRefresh();
  16.             // Tell the subclass to refresh the internal bean factory.
  17.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  19.             // Prepare the bean factory for use in this context.
  20.             prepareBeanFactory(beanFactory);
  22.             try {
  23.                 // Allows post-processing of the bean factory in context subclasses.
  24.                 postProcessBeanFactory(beanFactory);
  26.                 // Invoke factory processors registered as beans in the context.
  27.                 invokeBeanFactoryPostProcessors(beanFactory);
  29.                 // Register bean processors that intercept bean creation.
  30.                 registerBeanPostProcessors(beanFactory);
  32.                 // Initialize message source for this context.
  33.                 initMessageSource();
  35.                 // Initialize event multicaster for this context.
  36.                 initApplicationEventMulticaster();
  38.                 // Initialize other special beans in specific context subclasses.
  39.                 onRefresh();
  41.                 // Check for listener beans and register them.
  42.                 registerListeners();
  44. --------------->//<---------------------重点关注点是这里
  45.                 // Instantiate all remaining (non-lazy-init) singletons.
  46.                 finishBeanFactoryInitialization(beanFactory);
  48.                 // Last step: publish corresponding event.
  49.                 finishRefresh();
  50.             }
  52.             catch (BeansException ex) {
  53.                 if (logger.isWarnEnabled()) {
  54.                     logger.warn("Exception encountered during context initialization - " +
  55.                             "cancelling refresh attempt: " + ex);
  56.                 }
  58.                 // Destroy already created singletons to avoid dangling resources.
  59.                 destroyBeans();
  61.                 // Reset 'active' flag.
  62.                 cancelRefresh(ex);
  64.                 // Propagate exception to caller.
  65.                 throw ex;
  66.             }
  68.             finally {
  69.                 // Reset common introspection caches in Spring's core, since we
  70.                 // might not ever need metadata for singleton beans anymore...
  71.                 resetCommonCaches();
  72.             }
  73.         }
  74.     }
  76.        /**
  77.      * Finish the initialization of this context's bean factory,
  78.      * initializing all remaining singleton beans.
  79.      */
  80.     protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  81.         // Initialize conversion service for this context.
  82.         if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  83.                 beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  84.             beanFactory.setConversionService(
  85.                     beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  86.         }
  88.         // Register a default embedded value resolver if no bean post-processor
  89.         // (such as a PropertyPlaceholderConfigurer bean) registered any before:
  90.         // at this point, primarily for resolution in annotation attribute values.
  91.         if (!beanFactory.hasEmbeddedValueResolver()) {
  92.             beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  93.         }
  95.         // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  96.         String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  97.         for (String weaverAwareName : weaverAwareNames) {
  98.             getBean(weaverAwareName);
  99.         }
  101.         // Stop using the temporary ClassLoader for type matching.
  102.         beanFactory.setTempClassLoader(null);
  104.         // Allow for caching all bean definition metadata, not expecting further changes.
  105.         beanFactory.freezeConfiguration();
  107. ------->//<---------------------重点关注点是这里
  108.         // Instantiate all remaining (non-lazy-init) singletons.
  109.         beanFactory.preInstantiateSingletons();
  110.     }
  112. }

接着上文的beanFactory.preInstantiateSingletons()

beanFactory是ConfigurableListableBeanFactory

DefaultListableBeanFactory实现了ConfigurableListableBeanFactory接口

  1. public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
  2.         implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
  3.     ...
  5.     @Override
  6.     public void preInstantiateSingletons() throws BeansException {
  7.         if (logger.isTraceEnabled()) {
  8.             logger.trace("Pre-instantiating singletons in " + this);
  9.         }
  11.         // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  12.         // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  13.         List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  14.         //根据上下文beanNames为[a, b]
  16.         // Trigger initialization of all non-lazy singleton beans...
  17.         for (String beanName : beanNames) {//遍历a,b
  18.             RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  19.             if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  20.                 if (isFactoryBean(beanName)) {
  21.                     Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  22.                     if (bean instanceof FactoryBean) {
  23.                         FactoryBean<?> factory = (FactoryBean<?>) bean;
  24.                         boolean isEagerInit;
  25.                         if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  26.                             isEagerInit = AccessController.doPrivileged(
  27.                                     (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  28.                                     getAccessControlContext());
  29.                         }
  30.                         else {
  31.                             isEagerInit = (factory instanceof SmartFactoryBean &&
  32.                                     ((SmartFactoryBean<?>) factory).isEagerInit());
  33.                         }
  34.                         if (isEagerInit) {
  35.                             getBean(beanName);
  36.                         }
  37.                     }
  38.                 }
  39.                 else {
  40. ------------------->//<---------------------重点关注点是这里
  41.                     //源于AbstractAutowireCapableBeanFactory
  42.                     //->AbstractBeanFactory的getBean()
  43.                     getBean(beanName);
  44.                 }
  45.             }
  46.         }
  48. ------------------------------下面可略读---------------------------
  49.         // Trigger post-initialization callback for all applicable beans...
  50.         for (String beanName : beanNames) {
  51.             Object singletonInstance = getSingleton(beanName);
  52.             if (singletonInstance instanceof SmartInitializingSingleton) {
  53.                 SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  54.                 if (System.getSecurityManager() != null) {
  55.                     AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  56.                         smartSingleton.afterSingletonsInstantiated();
  57.                         return null;
  58.                     }, getAccessControlContext());
  59.                 }
  60.                 else {
  61.                     smartSingleton.afterSingletonsInstantiated();
  62.                 }
  63.             }
  64.         }
  65.     }    
  67. }
  1. package org.springframework.beans.factory.support;
  3. ...
  5. public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
  6.         implements AutowireCapableBeanFactory {
  7.     ...
  8. }
  1. package org.springframework.beans.factory.support;
  3. ...
  5. public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
  6.     ...
  7.     @Override
  8.     public Object getBean(String name) throws BeansException {
  9.         return doGetBean(name, null, null, false);
  10.     }
  13.     @SuppressWarnings("unchecked")
  14.     protected <T> T doGetBean(
  15.             String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
  16.             throws BeansException {
  18.         //name为a
  19.         String beanName = transformedBeanName(name);
  20.         Object bean;
  22.         // Eagerly check singleton cache for manually registered singletons.
  23. ------->//<---------------------重点关注点是这里
  24. ------->//<---------------------重点关注点是这里
  25. ------->//<---------------------重点关注点是这里
  26.         //源于FactoryBeanRegistrySupport
  27.         //->DefaultSingletonBeanRegistry的getSingleton()
  28.         //DefaultSingletonBeanRegistry也就是上文谈论的三级缓存所在类
  29.         //本章节末有getSingleton()源码
  30.         //最后getSingleton返回null
  31.         Object sharedInstance = getSingleton(beanName);
  32.         //sharedInstance为null，下面if语块不执行
  33.         if (sharedInstance != null && args == null) {
  34.             if (logger.isTraceEnabled()) {
  35.                 if (isSingletonCurrentlyInCreation(beanName)) {
  36.                     logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  37.                             "' that is not fully initialized yet - a consequence of a circular reference");
  38.                 }
  39.                 else {
  40.                     logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  41.                 }
  42.             }
  43.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  44.         }
  46.         else {
  47.             // Fail if we're already creating this bean instance:
  48.             // We're assumably within a circular reference.
  49.             //不执行下面if语块
  50.             if (isPrototypeCurrentlyInCreation(beanName)) {
  51.                 throw new BeanCurrentlyInCreationException(beanName);
  52.             }
  54.             // Check if bean definition exists in this factory.
  55.             BeanFactory parentBeanFactory = getParentBeanFactory();
  56.             //parentBeanFactory为null，不执行下面if语块
  57.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  58.                 // Not found -> check parent.
  59.                 String nameToLookup = originalBeanName(name);
  60.                 if (parentBeanFactory instanceof AbstractBeanFactory) {
  61.                     return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  62.                             nameToLookup, requiredType, args, typeCheckOnly);
  63.                 }
  64.                 else if (args != null) {
  65.                     // Delegation to parent with explicit args.
  66.                     return (T) parentBeanFactory.getBean(nameToLookup, args);
  67.                 }
  68.                 else if (requiredType != null) {
  69.                     // No args -> delegate to standard getBean method.
  70.                     return parentBeanFactory.getBean(nameToLookup, requiredType);
  71.                 }
  72.                 else {
  73.                     return (T) parentBeanFactory.getBean(nameToLookup);
  74.                 }
  75.             }
  77.             if (!typeCheckOnly) {
  78.                 markBeanAsCreated(beanName);
  79.             }
  81.             try {
  82.                 //下面方法返回Root bean: class [com.lun.interview.circular.A]; 
  83.                 //scope=singleton; abstract=false; lazyInit=false; 
  84.                 //autowireMode=0; dependencyCheck=0; autowireCandidate=true; 
  85.                 //primary=false; factoryBeanName=null; factoryMethodName=null; 
  86.                 //initMethodName=null; destroyMethodName=null; 
  87.                 //defined in class path resource [beans.xml]
  88.                 //重点关注scope=singleton
  89.                 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  91.                 checkMergedBeanDefinition(mbd, beanName, args);
  93.                 // Guarantee initialization of beans that the current bean depends on.
  94.                 String[] dependsOn = mbd.getDependsOn();
  95.                 //dependsOn返回null，不执行下面if语块
  96.                 if (dependsOn != null) {
  97.                     for (String dep : dependsOn) {
  98.                         if (isDependent(beanName, dep)) {
  99.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  100.                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  101.                         }
  102.                         registerDependentBean(dep, beanName);
  103.                         try {
  104.                             getBean(dep);
  105.                         }
  106.                         catch (NoSuchBeanDefinitionException ex) {
  107.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  108.                                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  109.                         }
  110.                     }
  111.                 }
  113.                 // Create bean instance.
  114.                 //mbd.isSingleton()返回true，执行下面if语块
  115.                 if (mbd.isSingleton()) {
  116.                     sharedInstance = getSingleton(beanName, () -> {
  117.                         try {
  118. --------------------------->//<---------------------重点关注点是这里
  119.                             return createBean(beanName, mbd, args);
  120.                         }
  121.                         catch (BeansException ex) {
  122.                             // Explicitly remove instance from singleton cache: It might have been put there
  123.                             // eagerly by the creation process, to allow for circular reference resolution.
  124.                             // Also remove any beans that received a temporary reference to the bean.
  125.                             destroySingleton(beanName);
  126.                             throw ex;
  127.                         }
  128.                     });
  129.                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  130.                 }
  132. ----------------------------下面代码可略读---------
  133.     ------------------
  135.                 else if (mbd.isPrototype()) {
  136.                     // It's a prototype -> create a new instance.
  137.                     Object prototypeInstance = null;
  138.                     try {
  139.                         beforePrototypeCreation(beanName);
  140.                         prototypeInstance = createBean(beanName, mbd, args);
  141.                     }
  142.                     finally {
  143.                         afterPrototypeCreation(beanName);
  144.                     }
  145.                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  146.                 }
  148.                 else {
  149.                     String scopeName = mbd.getScope();
  150.                     if (!StringUtils.hasLength(scopeName)) {
  151.                         throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
  152.                     }
  153.                     Scope scope = this.scopes.get(scopeName);
  154.                     if (scope == null) {
  155.                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  156.                     }
  157.                     try {
  158.                         Object scopedInstance = scope.get(beanName, () -> {
  159.                             beforePrototypeCreation(beanName);
  160.                             try {
  161.                                 return createBean(beanName, mbd, args);
  162.                             }
  163.                             finally {
  164.                                 afterPrototypeCreation(beanName);
  165.                             }
  166.                         });
  167.                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  168.                     }
  169.                     catch (IllegalStateException ex) {
  170.                         throw new BeanCreationException(beanName,
  171.                                 "Scope '" + scopeName + "' is not active for the current thread; consider " +
  172.                                 "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  173.                                 ex);
  174.                     }
  175.                 }
  176.             }
  177.             catch (BeansException ex) {
  178.                 cleanupAfterBeanCreationFailure(beanName);
  179.                 throw ex;
  180.             }
  181.         }
  183.         // Check if required type matches the type of the actual bean instance.
  184.         if (requiredType != null && !requiredType.isInstance(bean)) {
  185.             try {
  186.                 T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  187.                 if (convertedBean == null) {
  188.                     throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  189.                 }
  190.                 return convertedBean;
  191.             }
  192.             catch (TypeMismatchException ex) {
  193.                 if (logger.isTraceEnabled()) {
  194.                     logger.trace("Failed to convert bean '" + name + "' to required type '" +
  195.                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
  196.                 }
  197.                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  198.             }
  199.         }
  200.         return (T) bean;
  201.     }
  202. }

AbstractBeanFactory继承了FactoryBeanRegistrySupport

  1. package org.springframework.beans.factory.support;
  3. ...
  5. public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
  6.     ...
  7. }

FactoryBeanRegistrySupport继承了DefaultSingletonBeanRegistry，DefaultSingletonBeanRegistry也就是前文讨论三级缓存所在的类。

  1. package org.springframework.beans.factory.support;
  3. ...
  5. public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
  7.     ...
  9.     /** Cache of singleton objects: bean name to bean instance. */
  10.     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  12.     /** Cache of singleton factories: bean name to ObjectFactory. */
  13.     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  15.     /** Cache of early singleton objects: bean name to bean instance. */
  16.     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
  18.     @Override
  19.     @Nullable
  20.     public Object getSingleton(String beanName) {
  21.         return getSingleton(beanName, true);
  22.     }
  24.     /**
  25.      * Return the (raw) singleton object registered under the given name.
  26.      * <p>Checks already instantiated singletons and also allows for an early
  27.      * reference to a currently created singleton (resolving a circular reference).
  28.      */
  29.     @Nullable
  30.     protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  31.         //beanName为a,查找缓存，显然返回null
  32.         Object singletonObject = this.singletonObjects.get(beanName);
  33.         //singletonObject为null，下面if语块不执行
  34.         if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  35.             synchronized (this.singletonObjects) {
  36.                 singletonObject = this.earlySingletonObjects.get(beanName);
  37.                 if (singletonObject == null && allowEarlyReference) {
  38.                     ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  39.                     if (singletonFactory != null) {
  40.                         singletonObject = singletonFactory.getObject();
  41.                         this.earlySingletonObjects.put(beanName, singletonObject);
  42.                         this.singletonFactories.remove(beanName);
  43.                     }
  44.                 }
  45.             }
  46.         }
  47.         //返回null
  48.         return singletonObject;
  49.     }
  51. }

本节太晕了，画个图理解
Spring循环依赖debug源码图

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

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

    6. spring循环依赖小总结

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

每次创建 bean之前，我们都会从缓存中查下有没有该bean，因为是单例，只能有一个

当我们创建 beanA的原始对象后，并把它放到三级缓存中，接下来就该填充对象属性了，这时候发现依赖了beanB，接着就又去创建beanB，同样的流程，创建完beanB填充属性时又发现它依赖了beanA又是同样的流程，
不同的是：这时候可以在三级缓存中查到刚放进去的原始对象beanA.所以不需要继续创建，用它注入 beanB，完成 beanB的创建

既然 beanB创建好了，所以 beanA就可以完成填充属性的步骤了，接着执行剩下的逻辑，闭环完成
图片.png
Spring解决循环依赖依靠的是Bean的”中间态”这个概念，而这个中间态指的是已经实例化但还没初始化的状态—>半成债。实例化的过程又是通过构造器创建的，如果A还没创建好出来怎么可能提前曝光，所以构造器的循环依赖无法解决。”对
Spring为了解决单例的循坏依赖问题，使用了三级缓存：

其中一级缓存为单例池(singletonObjects)。
二级缓存为提前曝光对象(earlySingletonObjects)。
三级级存为提前曝光对象工厂(singletonFactories) 。

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

](https://blog.csdn.net/u011863024/article/details/115270840)
Spring解决循环依赖过程：

  1. 调用doGetBean()方法，想要获取beanA，于是调用getSingleton()方法从缓存中查找beanA
  2. 在getSingleton()方法中，从一级缓存中查找，没有，返回null
  3. doGetBean()方法中获取到的beanA为null，于是走对应的处理逻辑，调用getSingleton()的重载方法（参数为ObjectFactory的)
  4. 在getSingleton()方法中，先将beanA_name添加到一个集合中，用于标记该bean正在创建中。然后回调匿名内部类的creatBean方法
  5. 进入AbstractAutowireCapableBeanFactory#ndoCreateBean，先反射调用构造器创建出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从二级缓存移动到一级缓存中

参考

三级缓存 https://blog.csdn.net/m0_46741750/article/details/119579315 aop https://blog.csdn.net/u011863024/article/details/115270840
检测循环依赖 https://www.cnblogs.com/isnotnull/p/14300376.html