Spring的三级缓存与循环依赖

最新推荐文章于 2024-06-20 20:35:20 发布
最新推荐文章于 2024-06-20 20:35:20 发布
阅读量945 收藏 2
点赞数 1
分类专栏： Spring源码 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45596022/article/details/110351170
版权

一，spring4版本与spring5版本aop的执行顺序

依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <!--		<version>2.2.6.RELEASE</version>-->
        <relativePath/>
    </parent>
    <groupId>com.yhd</groupId>
    <artifactId>aop</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>aop</name>
    <description>Demo project for Spring Boot</description>

    <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-aop</artifactId>
        </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>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

被增强方法

/**
 * @author yhd
 * @createtime 2020/11/27 11:37
 */
@Service
public class Demo {

    public int dev(int x,int y){
        System.out.println(x/y);
        return x/y;
    }
}

aop切面类

/**
 * @author yhd
 * @createtime 2020/11/27 11:01
 */
@Component
@Aspect
public class AopDemo {

    @Pointcut(value = "execution(public int com.yhd.aop.*.*.*(..))")
    public void  pointCut(){

    }
    @Before("pointCut()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知。。。");
    }
    @AfterReturning("pointCut()")
    public void afterReturing(){
        System.out.println("返回通知。。。");
    }
    @AfterThrowing("pointCut()")
    public void afterThrowing(){
        System.out.println("异常通知。。。");
    }
    @After("pointCut()")
    public void after(){
        System.out.println("最终通知。。。");
    }
    @Around("pointCut()")
    public int around(ProceedingJoinPoint joinPoint)throws Throwable{

            System.out.println("环绕通知----前置通知");
            Object proceed = joinPoint.proceed();
            System.out.println("环绕通知---后置通知");
            return (int) proceed;

    }
}

测试类

/**
 * @author yhd
 * @createtime 2020/11/27 11:01
 */
@Component
@Aspect
public class AopDemo {

    @Pointcut(value = "execution(public int com.yhd.aop.*.*.*(..))")
    public void  pointCut(){

    }
    @Before("pointCut()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知。。。");
    }
    @AfterReturning("pointCut()")
    public void afterReturing(){
        System.out.println("返回通知。。。");
    }
    @AfterThrowing("pointCut()")
    public void afterThrowing(){
        System.out.println("异常通知。。。");
    }
    @After("pointCut()")
    public void after(){
        System.out.println("最终通知。。。");
    }
    @Around("pointCut()")
    public int around(ProceedingJoinPoint joinPoint)throws Throwable{

            System.out.println("环绕通知----前置通知");
            Object proceed = joinPoint.proceed();
            System.out.println("环绕通知---后置通知");
            return (int) proceed;

    }
}

最终结论

在这里插入图片描述

二，spring利用三级缓存来解决循环依赖

什么是循环依赖？

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

@Component
public class A {
    @Autowired
    private B b;
}

@Component
class B {
    @Autowired
    private C c;
}

@Component
class C {
    @Autowired
    private A a;
}

通常来说，谈到spring容器如何解决循环依赖，一定是指默认的单利bean，属性互相引用的场景。

也就是说，spring的循环依赖，是spring容器注入时候出现的问题。

spring容器循环依赖报错BaanCurrentlylnCreationException

1.构造器方式注入依赖

构造器方式注入没有办法解决循环依赖，想用构造器注入解决循环依赖是不存在的。

    @Test
    public void test2(){
        new A(new B(new A(。。。)));
    }

2.set方法注入依赖

set方法是可以解决循环依赖注入问题的

@Component
@Setter
public class A {
    
    private B b;
}

@Component
@Setter
public class B {

    private A a;
}

    @Test
    public void test2(){
        A a = new A();
        B b = new B();
        a.setB(b);
        b.setA(a);
    }

3.spring容器依赖注入

默认的单例场景是支持循环依赖的，不报错。

多例场景是不支持循环依赖的，报错。

依赖
    <!-- 统一管理jar包版本 -->
    <properties>
        <spring.version>5.0.2.RELEASE</spring.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <shiro.version>1.2.3</shiro.version>
        <mysql.version>5.1.6</mysql.version>
        <mybatis.version>3.4.5</mybatis.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.security.version>5.0.1.RELEASE</spring.security.version>
    </properties>

    <!-- 锁定jar包版本 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 项目依赖jar包 -->
    <dependencies>
        <!-- spring -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>
beans.xml
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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">
    <context:component-scan base-package="com"></context:component-scan>
</beans>
配置类
@Configuration
public class SpringConfig {

    @Bean
    @Scope
    public A a(){
        return new A();
    }
    @Bean
    @Scope
    public B b(){
        return new B();
    }
}
实体类
@Setter
public class A {

    private B b;
}

@Setter
public class B {

    private A a;
}

4.结论

spring内部通过三级缓存来解决循环依赖，所谓的三级缓存，其实就是spring容器内部用来解决循环依赖问题的三个map。

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

实例化：堆空间申请一块空间。

初始化：完成属性填充赋值。
在这里插入图片描述

源码追踪结论

整个执行流程主要是三个缓存map和四个方法

	//一级缓存：实例化完的bean
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	//三级缓存：单例bean工厂
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	//二级缓存：早期暴露的bean
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

四个方法分别是

getSingleton 希望从容器里面获取单例的bean

doCreateBean 没有就创建bean

populateBean 创建以后填充属性

addSingleton 填充完成在添加到容器使用

AB俩对象在三级缓存中的迁移说明

1.A创建过程中需要B，于是A将自己放到三级缓存去实例化B

2.B实例化的时候发现需要A，于是B先查一级缓存，没有，再查二级缓存，没有，再查三级缓存，找到了A，然后把三级缓存里面的A放到二级缓存里面，并删除三级缓存里面的A。

3.B顺利初始化完毕，将自己放到一级缓存里面（此时B里面的A还未创建完），然后接着回来创建A，此时B已经创建结束，直接从一级缓存里面拿到B，然后完成创建，并将A自己放到一级缓存里面。

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

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

spring为了解决单利的循环依赖问题，使用了三级缓存：其中一级为单例池，二级为提前曝光对象，三级为提前曝光对象工厂。

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

学nm个锤子
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring的三级缓存和循环依赖
qf2019的博客
08-31 105
循环依赖 什么是依赖注入?假设有两个类A和B，A在实例化的时候需要B的实例，而B在实例化时又需要A的实例，在类的实例化过程就陷入死循环。这也就是传统逻辑上的，“到底是先有鸡，还是先有蛋”的问题? 下面举一个例子,定义了两个类Type和Org： // Org.java @Data @Component public class Org { private final Role role; public Org(Role role) { this.role = role; .
Spring循环依赖与三级缓存
zhouyu5408的博客
07-01 4827
一、什么是循环依赖。 现在有A类和B类，A持有B的引用，B持有A的引用，这就是循环依赖。如果没有Spring，我们又是如何去解决循环依赖呢。 @Test public void testCircle() throws Exception { TestA a = new TestA(); TestB b = new TestB(); b.setTestA(a); a.setTestB(b); } 二、Spring实现循环依赖原理 spring解决循环依赖也是如此，首先暴露一个未初始化的
Spring三级缓存解决循环依赖问题
trong_ 的烂笔头
10-26 3579
解析理解在互相依赖的 Bean 是单例的、依赖注入的方式不都是构造注入的前提下如何使用三级缓存解决Spring中的循环依赖的问题。
Spring框架(四) 三级缓存与循环依赖
热门推荐
刘跃辉的博客
04-26 10万+
1.循环依赖 首先我们需要明白什么是循环依赖 ， 打个比方 ， 就是说A对象在创建的过程中 ， 需要依赖注入B对象 ， 但是B对象没有 ， 就需要去创建 ， 而在创建B对象的过程中又需要注入A对象 ， A对象此时还在创建中，所以就构成了一个死循环 ， A，B相互依赖 这样的关系被成为循环依赖（当然 ， 可能还会有其他的情况），下面我们就来看看Spring是如何让解决循环依赖的 2.一二三级缓存 三个缓存对应着三个不同的Map 一级：singletonObjects 这个缓存也就是单例池 ， 它存放
什么是spring三级缓存
最新发布
2301_76166241的博客
06-20 777
我们可以在:即单例缓存Map，其内部存储的都是以bean的名称为key，已经完全创建的bean作为value的Map。:该缓存都bean的工厂方法，可能有些读者不太理解，我们就以上文的AService为例，在Spring进行每一个bean初始化时，都会为这个bean封装一个工厂方法用于bean的创建，这一点笔者也会在后续的代码中提及，这里我们只需要知道这个缓存是以bean的名称作为key，创建该bean的工厂方法为value的Map即可。：其内部缓存的都是未完全完成创建的bean，就比如某个Service。
spring三级缓存解决循环依赖
aumiel的博客
03-05 1569
singletonObjects:缓存经过了完整生命周期的beanearlySingletonObjects:缓存未经过完整生命周期的bean,如果某个bean出现了循环依赖,就会提前。
Spring-三级缓存和循环依赖
泡^泡
11-28 459
Spring-三级缓存和循环依赖
Spring三级缓存解决循环依赖
qq_44027353的博客
08-09 9420
在BService创建中依赖出入时，如果在单例池中没有找到需要的bean，那就去createSet集合中判断有没有我们需要的Bean，如果有就表示当前需要的Bean对象它自己正在创建中，这也就是循环依赖。Spring里面还是会用到一个map，我们可以暂时理解为前面说的hushangMap，先推断构造函数创建好AService的普通对象后，存入Map中去，key是bean的名字，value中存创建好的bean的名字、普通对象以及beanDefinition，这里有三个对象，value里面如何存放三个对象嘞？.
Spring三级缓存解决循环依赖.pdf
06-22
Spring三级缓存解决循环依赖.pdf
3. 循环依赖问题（三级缓存）.xmind
08-29
《spring源码之循环依赖和三级缓存》整理，本人水平有限，从网上找的资料整合之后做的，请辩证的看待其中内容。
简单了解Spring循环依赖解决过程
08-25
三级缓存是 Spring 解决循环依赖关系的核心机制。三级缓存包括： 1. singletonObjects：一级缓存，用于存储已经实例化的 Bean。 2. earlySingletonObjects：二级缓存，用于存储正在实例化的 Bean。 3. ...
画图带你彻底弄懂三级缓存和循环依赖的问题.doc
07-09
【Spring 三级缓存与循环依赖】\n\n在软件开发中，Spring 框架以其强大的功能和灵活性被广泛使用。在 Spring 中，循环依赖（Circular Dependency）和三级缓存是两个重要的概念，尤其在面试和技术探讨中经常被提及。...
探秘Spring框架解决循环依赖的高效策略
12-13
Spring框架在处理循环依赖...总之，Spring通过三级缓存和AOP代理机制，实现了对循环依赖的高效处理，保证了应用的稳定性和性能。这个解决方案不仅体现了Spring的灵活性，也为Java开发者提供了宝贵的设计和架构经验。
Spring循环依赖是什么?怎么解决
易雪寒的博客
04-13 809
前言 Spring如何解决的循环依赖，是近两年流行起来的一道Java面试题。 其实笔者本人对这类框架源码题还是持一定的怀疑态度的。 如果笔者作为面试官，可能会问一些诸如“如果注入的属性为null，你会从哪几个方向去排查”这些场景题。 那么既然写了这篇文章，闲话少说，发车看看Spring是如何解决的循环依赖，以及带大家看清循环依赖的本质是什么。 正文 通常来说，如果问Spring内部如何...
Spring大白话--三级缓存解决循环依赖问题
拽着尾巴的鱼儿的博客
09-27 957
在使用Spring 开发过程中，我们需要对定义后的bean 通过构造方法，或者bean 注入的方式注入到某个类中进而使用改bean 对应的方法，在此过程中就会出现一个类中注入了n多个bean，几个类中bean 相互注入，出现 A 依赖B，B依赖C，C又依赖A/B 这种循环情况的出现。提示：以下是本篇文章正文内容，下面案例可供参考。
Spring使用三级缓存解决循环依赖
xiaomu_a的博客
05-11 1601
循环依赖： @Service public class TestService1 { @Autowired private TestService2 testService2; public void test1() { } } @Service public class TestService2 { @Autowired private TestService1 testService1; public void test2() {
Spring——三级缓存解决循环依赖详解
共勉
11-29 1万+
结合Spring源码分析三级缓存分别是什么？在哪里产生？一张图搞清楚到底是怎么解决循环依赖的？一张图搞清楚二级缓存行不行？
什么是Spring三级缓存 对象在三级缓存中的创建流程 【三级缓存 循环依赖】
世上哪有什么岁月静好,不过是有人替你负重前行
05-20 2518
一、什么是Spring三级缓存 第一级缓存：也叫单例池，存放已经经历了完整生命周期的Bean对象。 第二级缓存：存放早期暴露出来的Bean对象，实例化以后，就把对象放到这个Map中。（Bean可能只经过实例化，属性还未填充）。 第三级缓存：存放早期暴露的Bean的工厂。 注： 只有单例的bean会通过三级缓存提前暴露来解决循环依赖的问题，而非单例的bean，每次从容器中获取都是一个新的对象，都会重新创建，所以非单例的bean是没有缓存的，不会将其放到三级缓存中。 为了解决第二级缓存中AOP生成新对象的问题
spring之我见- spring循环依赖为啥是三级缓存？
葵续浅笑的博客
03-06 2387
单例在spring里的获取方式 今天讲一下spring中针对单例bean的循环依赖问题，本着追本溯源的学习理念，我们要先知道单例在spring中怎么管理的。spring获取实例都通过beanfactory的getBean方法获取实例，顺着代码而下，在doGetBean方法(AbstractBeanFactory)中，单例总是通过getSingleton()方法获取缓存实例。 protected &...
Spring三级缓存与循环依赖解析
"本文详细探讨了Spring框架中的三级缓存机制以及如何解决循环依赖问题。通过图形解释，作者清晰地展示了Bean的创建过程，并指出了解决循环依赖的关键在于理解Bean的生命周期。" 在Java开发中，Spring框架是常用的一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值