Mr. Cappuccino的第64杯咖啡——Spring循环依赖问题

业界资讯 2023-10-05 08:18:52 阅读次数: 0

Spring循环依赖问题

什么是循环依赖问题

多个bean之间相互依赖，形成了一个闭环。 比如：A依赖于B、B依赖于C、C依赖于A

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

示例

项目结构

在这里插入图片描述

项目代码

pom.xml

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com</groupId>
    <artifactId>spring-circular-dependency</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.geronimo.bundles</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8_2</version>
        </dependency>
    </dependencies>

</project>

Bean01.java

package com.spring.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author honey
 * @date 2023-08-23 17:50:53
 */
@Component
public class Bean01 {
    
    

    @Autowired
    private Bean02 bean02;
}

Bean02.java

package com.spring.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author honey
 * @date 2023-08-23 17:52:55
 */
@Component
public class Bean02 {
    
    

    @Autowired
    private Bean01 bean01;
}

SpringConfig01.java

package com.spring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author honey
 * @date 2023-08-23 17:59:37
 */
@Configuration
@ComponentScan(value = {
    
    "com.spring.bean"})
public class SpringConfig01 {
    
    
}

SpringTest01.java

package com.spring.test;

import com.spring.bean.Bean01;
import com.spring.bean.Bean02;
import com.spring.config.SpringConfig01;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author honey
 * @date 2023-08-23 18:00:24
 */
public class SpringTest01 {
    
    

    public static void main(String[] args) {
    
    
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig01.class);
        Bean01 bean01 = applicationContext.getBean("bean01", Bean01.class);
        Bean02 bean02 = applicationContext.getBean("bean02", Bean02.class);
        System.out.println(bean01);
        System.out.println(bean02);
    }
}
运行结果

在这里插入图片描述

在这里插入图片描述

Spring默认情况下已经解决了循环依赖问题（单例Bean）

@Async注解导致的问题

在SpringConfig01类上加上@EnableAsync注解

在这里插入图片描述

在Bean01类中使用@Async注解修饰的异步方法

在这里插入图片描述

Bean01.java

package com.spring.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * @author honey
 * @date 2023-08-23 17:50:53
 */
@Component
public class Bean01 {
    
    

    @Autowired
    private Bean02 bean02;

    @Async
    public void test() {
    
    
        System.out.println(Thread.currentThread().getName() + "Bean01测试中...");
    }
}

运行结果

在这里插入图片描述

"C:\Program Files\Java\jdk1.8.0_191\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1.1\lib\idea_rt.jar=57456:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1.1\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_191\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\rt.jar;E:\知识点资料（第四年）\Spring源码解读\代码\spring-circular-dependency\target\classes;D:\maven_jar\org\springframework\spring-core\5.2.1.RELEASE\spring-core-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-jcl\5.2.1.RELEASE\spring-jcl-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-beans\5.2.1.RELEASE\spring-beans-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-context\5.2.1.RELEASE\spring-context-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-aop\5.2.1.RELEASE\spring-aop-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-expression\5.2.1.RELEASE\spring-expression-5.2.1.RELEASE.jar;D:\maven_jar\org\aspectj\aspectjrt\1.8.9\aspectjrt-1.8.9.jar;D:\maven_jar\org\apache\geronimo\bundles\aspectjweaver\1.6.8_2\aspectjweaver-1.6.8_2.jar" com.spring.test.SpringTest01
八月 23, 2023 7:07:05 下午 org.springframework.context.support.AbstractApplicationContext refresh
警告: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'bean01': Bean with name 'bean01' has been injected into other beans [bean02] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
Exception in thread "main" org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'bean01': Bean with name 'bean01' has been injected into other beans [bean02] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:624)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:517)
	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:323)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:321)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:879)
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:878)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:550)
	at org.springframework.context.annotation.AnnotationConfigApplicationContext.<init>(AnnotationConfigApplicationContext.java:89)
	at com.spring.test.SpringTest01.main(SpringTest01.java:15)

Process finished with exit code 1

Spring在扫描bean发现某个类方法被@Async修饰时，会通过后置处理器AsyncAnnotationBeanPostProcessor生成代理对象，而该后置处理器的顺序比处理AOP的后置处理器还靠后，因此会导致Spring处理不了循环依赖。

使用@Lazy注解解决@Async注解导致的问题

在Bean01类中循环依赖的属性上使用@Lazy注解

在这里插入图片描述

运行结果

在这里插入图片描述

在这里插入图片描述

开启Aop使用代理对象示例

项目结构

在这里插入图片描述

项目代码

AspectAop.java

package com.spring.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * @author honey
 * @date 2023-08-23 18:26:33
 */
@Component
@Aspect
public class AspectAop {
    
    

    @Pointcut("execution (* com.spring.bean.*.*(..))")
    public void pointcut() {
    
    
    }

    @Around(value = "pointcut()")
    public Object doAround(ProceedingJoinPoint point) throws Throwable {
    
    
        System.out.println("doAround advice start");
        Object result = point.proceed();
        System.out.println("doAround advice end");
        return result;
    }
}

需要在Bean01和Bean02中加上一个普通方法，如：

在这里插入图片描述

package com.spring.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author honey
 * @date 2023-08-23 17:52:55
 */
@Component
public class Bean02 {
    
    

    @Autowired
    private Bean01 bean01;

    public void add() {
    
    

    }
}

SpringConfig01.java

package com.spring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author honey
 * @date 2023-08-23 17:59:37
 */
@Configuration
@ComponentScan(value = {
    
    "com.spring.bean", "com.spring.aop"})
@EnableAspectJAutoProxy
public class SpringConfig01 {
    
    
}
运行结果

在这里插入图片描述

在这里插入图片描述

Spring是如何解决循环依赖问题的

Spring底层通过三级缓存解决了循环依赖问题。

一级缓存：singletonObjects，也叫作单例池，存放已经经历了完整生命周期的Bean对象；

/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

二级缓存：earlySingletonObjects，存放早期暴露出来的Bean对象，Bean的生命周期未结束（属性还未填充完整）；

/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

三级缓存：singletonFactories，存放可以生成Bean的工厂；

/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

原理

假设有两个对象分别是A和B，其中A依赖于B，B依赖于A

  1. 在创建A对象时需要B对象，于是将A对象存入三级缓存，再去创建B对象；
  2. 在创建B对象时发现需要A对象，于是先查一级缓存，没有，再查二级缓存，还是没有，再查三级缓存，找到了A对象，然后把三级缓存里面的A对象存入二级缓存，并删除三级缓存里面的A对象；
  3. B对象创建完成，将B对象存入一级缓存（此时B对象依赖的A对象依然是创建中状态），获取到B对象后回来接着创建A对象，直到创建完成，并将A对象存入一级缓存中（如果其它对象依赖于A对象和B对象，可以直接从一级缓存里面获取）；

源码解读

在创建A对象时，A对象完成实例化后，会将A对象封装成ObjectFactory存入三级缓存。

AbstractBeanFactory.java

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

AbstractAutowireCapableBeanFactory.java

在这里插入图片描述
在这里插入图片描述

ObjectFactory.java

在这里插入图片描述

如果该对象是单例对象且开启了循环依赖且该对象正在创建中，则会将该对象封装成ObjectFactory对象存入三级缓存。其中ObjectFactory是一个函数接口，在调用getObject()方法时，才会真正去执行lambda语句调用getEarlyBeanReference()方法。

// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
		isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
    
    
	if (logger.isTraceEnabled()) {
    
    
		logger.trace("Eagerly caching bean '" + beanName +
				"' to allow for resolving potential circular references");
	}
	addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

DefaultSingletonBeanRegistry.java

在这里插入图片描述

在为A对象设置属性时，发现A对象依赖于B对象，则会去尝试获取B对象，由于此时B对象还未被创建，所以B对象也会走和A对象一样的创建逻辑，不同的是在为B对象设置属性时，发现B对象依赖于A对象，可以从三级缓存中获取得到A对象。

AbstractBeanFactory.java

在这里插入图片描述

DefaultSingletonBeanRegistry.java

在这里插入图片描述

在这里插入图片描述

此时存入二级缓存的是不完整对象，调用singletonFactory.getObject()方法实际上是在调用getEarlyBeanReference(beanName, mbd, bean)方法。

在这里插入图片描述

在这里插入图片描述

如果是正常情况下，返回原始对象

InstantiationAwareBeanPostProcessorAdapter.java

在这里插入图片描述

如果是开启了Aop的情况下，返回Aop代理对象

AbstractAutoProxyCreator.java

在这里插入图片描述

将获取到的A对象设置为B对象的属性并执行完B对象的完整生命周期后，将B对象存入一级缓存中并从二级缓存、三级缓存中移除。此处也使用了ObjectFactory这个函数接口。

AbstractBeanFactory.java

在这里插入图片描述

DefaultSingletonBeanRegistry.java

在这里插入图片描述
在这里插入图片描述

获取得到B对象后，接着执行A对象的生命周期，执行完成后和B对象一样存入一级缓存中。

什么情况下Spring无法解决循环依赖问题

  1. 构造器注入的循环依赖问题；
  2. 非单例对象的循环依赖问题；

猜你喜欢

转载自blog.csdn.net/sinat_41888963/article/details/132458437
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022