手写spring IOC底层源码来模拟spring如何利用多级缓存解决循环依赖的问题

news2025/3/1 11:12:30

在文章开始之前，先来看一张spring IOC加载过程的脑图吧

Spring IOC的加载过程

首先,当我们去new了一个applicationContext,它底层呢就会把我们配置的bean进行扫描,然后创建成一个一个的beanDefinition放在我们的beanDefinitionMap中,此时就有了一切创造bean的原料信息,然后就会去循环beanDefinition,去调用beanfactory.getBean方法,先尝试在一级缓存中获取,获取不到呢就会进行创建,先进行实例化,然后进行依赖注入,最后初始化,放入到一级缓存中.

手写源码

package cn.edu.hunau;

import cn.edu.hunau.service.AService;
import cn.edu.hunau.service.BService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;

import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author SuJ
 * @Date 2024 04 12 15 13.
 * 手写spring IOC底层源码来模拟spring如何利用多级缓存解决循环依赖的问题。
 **/
public class SuJApplicationContext {
    private Map<String, BeanDefinition> beanDefinitionMap = new LinkedHashMap<>();
    // 一级缓存 单例池
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();


    public SuJApplicationContext() throws Exception{
        // 加载ioc容器  创建所有的bean
        refersh();

        finishBeanFactoryInitialization();
    }

    //一个个的创建bean
    private void finishBeanFactoryInitialization() {
        //循环所有的beanDefinition
        beanDefinitionMap.keySet().forEach(
                beanName -> {
                    try {
                        getBean(beanName);
                    } catch (InstantiationException e) {
                        throw new RuntimeException(e);
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e);
                    }
                }
        );
    }

    private Object getBean(String beanName) throws InstantiationException, IllegalAccessException {
        // 1.尝试在一级缓存中获取
        Object bean = getSingleton(beanName);
        //如果存在 直接放回
        if(bean != null){
            return bean;
        }

        // 2.创建  ---> 实例化
        RootBeanDefinition beanDefinition = (RootBeanDefinition)beanDefinitionMap.get(beanName);
        Class<?> beanClass = beanDefinition.getBeanClass();
        bean = beanClass.newInstance();

        //3. 依赖注入
        for (Field declaredField : beanClass.getDeclaredFields()){
            //当前属性有注解
            if(declaredField.getAnnotation(Autowired.class) != null){
                String name = declaredField.getName();
                Object dependBean = getBean(name);

                declaredField.setAccessible(true);
                declaredField.set(bean, dependBean);
            }
        }

        //4.初始化
//if(bean instanceof InitializingBean){
//    ((InitializingBean)bean).afterPropertiesSet();
//}

        //5.放入一级缓存
        singletonObjects.put(beanName, bean);
        return bean;

    }
//获取单例池中的bean
    private Object getSingleton(String beanName) {
        if(singletonObjects.containsKey(beanName)){
            return singletonObjects.get(beanName);
        }
        return null;
    }

    //ioc容器加载
    public void refersh() throws Exception{
        //1.解析配置 支持BeanDefinition
        loadBeanDefinitions();
    }

    /**
     *
     * 根据配置信息创建BeanDefinition  底层是通过解析配置类注册beandefiniton
     */
    private void loadBeanDefinitions(){

        // 创建A BeanDefinition
        RootBeanDefinition aBeanDefinition = new RootBeanDefinition(AService.class);
        //创建B BeanDefinition
        RootBeanDefinition bBeanDefinition = new RootBeanDefinition(BService.class);

        beanDefinitionMap.put("aService",aBeanDefinition);
        beanDefinitionMap.put("bService",bBeanDefinition);
    }
}

当我们手写完IOC容器的创建过程,会发现其实在一级缓存就可以解决循环依赖的问题,只需要增加一行代码。

我们可以发现程序正常执行

那为什么spring的设计人员不采取这种方式，而是要通过三级缓存来解决循环依赖的问题呢？

这是因为只通过一级缓存来解决循环依赖问题会造成线程安全问题，例如线程1先实例化A,直接放到一级缓存，这时线程2从一级缓存中获取到了实例，调用B实例的方法，由于没有进行依赖注入，我们的B实例为null，会造成空指针异常。

为了解决这个问题，我们引入了二级缓存，专门用于存储不完整的bean，使用二级缓存获取到的bean作为出口，并且将临界资源锁住（这里借用了单例模式的思想），果然解决了线程安全的问题。

package cn.edu.hunau;

import cn.edu.hunau.service.AService;
import cn.edu.hunau.service.BService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;

import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author SuJ
 * @Date 2024 04 12 15 13.
 * 手写spring IOC底层源码来模拟spring如何利用多级缓存解决循环依赖的问题。
 **/
public class SuJApplicationContext {
    private Map<String, BeanDefinition> beanDefinitionMap = new LinkedHashMap<>();
    // 一级缓存 单例池
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    // 二级缓存 ---->  并发获取不完整bean------dcl
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();


    public SuJApplicationContext() throws Exception {
        // 加载ioc容器  创建所有的bean
        refersh();

        finishBeanFactoryInitialization();
    }

    //一个个的创建bean
    private void finishBeanFactoryInitialization() {
        //循环所有的beanDefinition
        beanDefinitionMap.keySet().forEach(
                beanName -> {
                    try {
                        getBean(beanName);
                    } catch (InstantiationException e) {
                        throw new RuntimeException(e);
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e);
                    }
                }
        );
    }

    private Object getBean(String beanName) throws InstantiationException, IllegalAccessException {
        // 1.尝试在一级缓存中获取
        Object bean = getSingleton(beanName);
        //如果存在 直接放回
        if (bean != null) {
            return bean;
        }
        synchronized (singletonObjects) {
            bean = getSingleton(beanName);
            //如果存在 直接返回
            if (bean != null) {
                return bean;
            }

            // 2.创建  ---> 实例化
            RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
            Class<?> beanClass = beanDefinition.getBeanClass();
            bean = beanClass.newInstance();

            earlySingletonObjects.put(beanName, bean);

            //3. 依赖注入
            for (Field declaredField : beanClass.getDeclaredFields()) {
                //当前属性有注解
                if (declaredField.getAnnotation(Autowired.class) != null) {
                    String name = declaredField.getName();
                    Object dependBean = getBean(name);

                    declaredField.setAccessible(true);
                    declaredField.set(bean, dependBean);
                }
            }

            //4.初始化
//if(bean instanceof InitializingBean){
//    ((InitializingBean)bean).afterPropertiesSet();
//}

            //5.放入一级缓存
            singletonObjects.put(beanName, bean);
            earlySingletonObjects.remove(beanName);  //二级缓存是临时的需要清楚
            return bean;
        }
    }

    //获取单例池中的bean
    private Object getSingleton(String beanName) {
        if (singletonObjects.containsKey(beanName)) {
            return singletonObjects.get(beanName);
        }

        //出口
        synchronized (singletonObjects) {
            if (earlySingletonObjects.containsKey(beanName)) {
                return earlySingletonObjects.get(beanName);
            }
        }
        return null;
    }

    //ioc容器加载
    public void refersh() throws Exception {
        //1.解析配置 支持BeanDefinition
        loadBeanDefinitions();
    }

    /**
     * 根据配置信息创建BeanDefinition  底层是通过解析配置类注册beandefiniton
     */
    private void loadBeanDefinitions() {

        // 创建A BeanDefinition
        RootBeanDefinition aBeanDefinition = new RootBeanDefinition(AService.class);
        //创建B BeanDefinition
        RootBeanDefinition bBeanDefinition = new RootBeanDefinition(BService.class);

        beanDefinitionMap.put("aService", aBeanDefinition);
        beanDefinitionMap.put("bService", bBeanDefinition);
    }
}

那三级缓存用来干什么的？

三级缓存主要是处理我们涉及到需要代理的Bean的情况的。一般来说，动态代理需要Bean的初始化过程中进行创建，但是在循环依赖的这种特殊情况下，程序根本无法走到初始化这一步，所以我们需要在实例化后就进行Bean的增强。假如说我们只使用二级缓存（如下图这样写的话）,对于需要进行增强的Bean会造成两个问题

1.没有遵循规范（初始化再增强

2.循环依赖多次会创建多次（A和B循环依赖，A和C循环依赖

为了解决这些问题，spring的底层引入了三级缓存（存储一个Bean工厂对象，对于需要做增强的Bean返回代理类，不需要的返回原始类）

package cn.edu.hunau;

import cn.edu.hunau.service.impl.AService;
import cn.edu.hunau.service.impl.BService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;

import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author SuJ
 * @Date 2024 04 12 15 13.
 * 手写spring IOC底层源码来模拟spring如何利用多级缓存解决循环依赖的问题。
 **/
public class SuJApplicationContext {
    private Map<String, BeanDefinition> beanDefinitionMap = new LinkedHashMap<>();
    // 一级缓存 单例池
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    // 二级缓存 ---->  并发获取不完整bean------dcl
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();

    //三级缓存
    private final Map<String, ObjectFactory> factoriesEarlySingletonObjects = new ConcurrentHashMap<>();


    public SuJApplicationContext() throws Exception {
        // 加载ioc容器  创建所有的bean
        refersh();

        finishBeanFactoryInitialization();
    }

    //一个个的创建bean
    private void finishBeanFactoryInitialization() {
        //循环所有的beanDefinition
        beanDefinitionMap.keySet().forEach(
                beanName -> {
                    try {
                        getBean(beanName);
                    } catch (InstantiationException e) {
                        throw new RuntimeException(e);
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e);
                    }
                }
        );
    }

    public Object getBean(String beanName) throws InstantiationException, IllegalAccessException {
        // 1.尝试在一级缓存中获取
        Object bean = getSingleton(beanName);
        //如果存在 直接放回
        if (bean != null) {
            return bean;
        }
        synchronized (singletonObjects) {
            bean = getSingleton(beanName);
            //如果存在 直接返回
            if (bean != null) {
                return bean;
            }

            // 2.创建  ---> 实例化
            RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
            Class<?> beanClass = beanDefinition.getBeanClass();
            Object beanNew = beanClass.newInstance();

            //1.没有遵循规范  2.循环依赖多次会创建多次
            Object beanAop = new JdkProxyBeanPostProcessor().getEarlyBeanReference(bean, beanName);

            factoriesEarlySingletonObjects.put(beanName, ()->{
                return new JdkProxyBeanPostProcessor().getEarlyBeanReference(beanNew,beanName );
            });

            // 首先将早期引用放入二级缓存
//            earlySingletonObjects.put(beanName, beanNew);

            //3. 依赖注入
            for (Field declaredField : beanClass.getDeclaredFields()) {
                //当前属性有注解
                if (declaredField.getAnnotation(Autowired.class) != null) {
                    String name = declaredField.getName();
                    Object dependBean = getBean(name);

                    declaredField.setAccessible(true);
                    declaredField.set(beanNew, dependBean);
                }
            }

            //4.初始化
//if(bean instanceof InitializingBean){
//    ((InitializingBean)bean).afterPropertiesSet();
//}

            //5.放入一级缓存
            singletonObjects.put(beanName, beanNew);
            earlySingletonObjects.remove(beanName);  //二级缓存是临时的需要清除
            factoriesEarlySingletonObjects.remove(beanName);    //三级缓存是临时的需要清除
            return beanNew;
        }
    }


    private Object getSingleton(String beanName) {
        if (singletonObjects.containsKey(beanName)) {
            return singletonObjects.get(beanName);
        }

        //出口  -- 当前是循环依赖
        synchronized (singletonObjects) {
            if (earlySingletonObjects.containsKey(beanName)) {
                return earlySingletonObjects.get(beanName);
            }

            if (factoriesEarlySingletonObjects.containsKey(beanName)) {
                ObjectFactory objectFactory = factoriesEarlySingletonObjects.get(beanName);
                // aop
                Object object = objectFactory.getObject();
                earlySingletonObjects.put(beanName, object); //解决循环依赖多次会创建多次的问题
                return object;
            }
        }
        return null;
    }

    //ioc容器加载
    public void refersh() throws Exception {
        //1.解析配置 支持BeanDefinition
        loadBeanDefinitions();
    }

    /**
     * 根据配置信息创建BeanDefinition  底层是通过解析配置类注册beandefiniton
     */
    private void loadBeanDefinitions() {

        // 创建A BeanDefinition
        RootBeanDefinition aBeanDefinition = new RootBeanDefinition(AService.class);
        //创建B BeanDefinition
        RootBeanDefinition bBeanDefinition = new RootBeanDefinition(BService.class);

        beanDefinitionMap.put("aService", aBeanDefinition);
        beanDefinitionMap.put("bService", bBeanDefinition);
    }
}

其实三级缓存的思想就是：在实例化后不是直接动态代理，而是其函数式接口放入三级缓存中，出现循环依赖时在进行调用创建代理的函数。

以上是我个人的见解，请大家多指教

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1601286.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

k-means聚类算法的MATLAB实现及可视化

k-means聚类算法的MATLAB实现及可视化

K-means算法是一种无监督学习算法&#xff0c;主要用于数据聚类。其工作原理基于迭代优化&#xff0c;将数据点划分为K个集群&#xff0c;使得每个数据点都属于最近的集群&#xff0c;并且每个集群的中心&#xff08;质心&#xff09;是所有属于该集群的数据点的平均值。以下是…
阅读更多...
「GO基础」文件名规范、关键字与标识符

「GO基础」文件名规范、关键字与标识符

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:「stormsha的主页」…
阅读更多...
【数据结构与算法】最大公约数与最小公倍数

【数据结构与算法】最大公约数与最小公倍数

最大公因数&#xff08;英语&#xff1a;highest common factor&#xff0c;hcf&#xff09;也称最大公约数&#xff08;英语&#xff1a;greatest common divisor&#xff0c;gcd&#xff09;是数学词汇&#xff0c;指能够整除多个非零整数的最大正整数。例如8和12的最大公因数…
阅读更多...
社交创新的标杆：解读Facebook的社交模式

社交创新的标杆：解读Facebook的社交模式

引言 在当今数字化时代&#xff0c;社交媒体已成为人们日常生活和沟通的重要工具。作为全球最大的社交媒体平台&#xff0c;Facebook不仅改变了我们的社交模式&#xff0c;而且对全球的社交文化、商业活动和公共事务产生了深远的影响。本文将深入探讨Facebook的社交模式&#…
阅读更多...
关于Qt主窗口的菜单部件

关于Qt主窗口的菜单部件

前言 在介绍主窗口的两大部件之前&#xff0c;我们要先知道关于主窗口的一些知识。 主窗口 一个主窗口可以没有菜单条、工具条、状态条&#xff0c;但必须设置中心部件。在 Q 生成的 C头文件 ui_mainwindow.h 代码中,我们可以看到以下代码: centralWidget new Qwidget(MainWi…
阅读更多...
Three.js加载glb / gltf模型，Vue加载glb / gltf模型（如何在vue中使用three.js，vue使用threejs加载glb模型）

Three.js加载glb / gltf模型，Vue加载glb / gltf模型（如何在vue中使用three.js，vue使用threejs加载glb模型）

简介&#xff1a;Three.js 是一个用于在 Web 上创建和显示 3D 图形的 JavaScript 库。它提供了丰富的功能和灵活的 API&#xff0c;使开发者可以轻松地在网页中创建各种 3D 场景、模型和动画效果。可以用来展示产品模型、建立交互式场景、游戏开发、数据可视化、教育和培训等等…
阅读更多...
BetterDisplay Pro for Mac 显示器校准和优化软件

BetterDisplay Pro for Mac 显示器校准和优化软件

BetterDisplay Pro for Mac是一款适用于Mac电脑的显示器校准和优化软件。它可以帮助用户校准显示器的颜色、亮度、对比度和伽马值等参数&#xff0c;使得显示器更加准确和清晰&#xff0c;提高用户的工作效率。 BetterDisplay Pro for Mac v2.0.11激活版下载 这款软件具有直观的…
阅读更多...
RS232、RS485、RS422、TTL、CAN各自的区别

RS232、RS485、RS422、TTL、CAN各自的区别

目录 一&#xff1a;工业串口通信标准RS232、RS485、RS422的区别 第一个区别、硬件管脚接口定义不同 第二个区别、工作方式不同 第三个区别、通信方式不同 第四个区别&#xff0c;逻辑特性不同 第五个区别、抗干扰性、传输距离和传输速率也不同 二&#xff1a;RS232、RS…
阅读更多...
记录Python链接mysql数据的增删改查方法

记录Python链接mysql数据的增删改查方法

一、添加方法 db pymysql.connect(hostlocalhost,userroot,password123456,dbpython) cursor db.cursor() sql """insert into EMPLOYEEVALUES(3,张,天爱,35,F,8000) """ try:cursor.execute(sql)db.commit() #提交后&#xff0c;数据才会变 …
阅读更多...
上班最大的意义，不是那点工资

上班最大的意义，不是那点工资

最近在网上看到这样一段话&#xff1a;“上班最大的意义&#xff0c;不是那点工资&#xff0c;而是工作能让你有规律的生活&#xff0c;有见人的机会&#xff0c;有稳定的社交圈子&#xff0c;还有来自客户&#xff0c;同事&#xff0c;或者或少的压力&#xff0c;一可以锻炼心…
阅读更多...
数字革命的先锋：Web3对社会的影响

数字革命的先锋：Web3对社会的影响

引言 在信息技术飞速发展的当下&#xff0c;Web3作为一个新兴的互联网模式&#xff0c;正在逐渐改变我们的生活方式、商业模式和社会结构。本文将深入探讨Web3的核心特点、它在各个领域中的应用以及对社会产生的深远影响。 1. Web3的核心特点 1.1 去中心化 Web3强调去中心化…
阅读更多...
使用阿里云试用Elasticsearch学习：使用内置模型 lang_ident_model_1 创建管道并使用

使用阿里云试用Elasticsearch学习：使用内置模型 lang_ident_model_1 创建管道并使用

文档&#xff1a;https://www.elastic.co/guide/en/machine-learning/current/ml-nlp-deploy-model.html 部署刚刚下载好的内置模型 部署内存不够用 还得花钱&#xff0c;拉几把倒吧。就用自带的吧。 测试模型 POST _ml/trained_models/lang_ident_model_1/_infer {"doc…
阅读更多...
大数据快速搭建环境 CDH QuickStart VM虚拟机版本安装

大数据快速搭建环境 CDH QuickStart VM虚拟机版本安装

虚拟机镜像安装 下载 https://downloads.cloudera.com/demo_vm/vmware/cloudera-quickstart-vm-5.8.0-0-vmware.zip https://downloads.cloudera.com/demo_vm/vmware/cloudera-quickstart-vm-5.12.0-0-vmware.zip https://downloads.cloudera.com/demo_vm/vmware/cloudera-…
阅读更多...
.net core webapi 发布后出现访问不了swagger让人抓狂的原因

.net core webapi 发布后出现访问不了swagger让人抓狂的原因

.net core webapi 发布出现访问不了swagger让人抓狂 小编最近发布一个测试的webapi,想要给三方测试使用&#xff0c;结果发布后访问不了swagger&#xff0c;找了半天原因急死了。 第一&#xff0c;查看开放端口&#xff0c;都开放了第二&#xff0c;本次编译器执行&#xff0…
阅读更多...
FAGLL03H 新增自定义字段

FAGLL03H 新增自定义字段

1、SGLPOS_N_GL_CT、SGLPOS_N_CT两个结构新增自定义字段 2、执行t-code:HDBVIEWS 3、实施增强 FAGL_LIB 4、使用select data方法 5、代码示例: method IF_FAGL_LIB~SELECT_DATA.FIELD-SYMBOLS: <fs> TYPE any.FIELD-SYMBOLS <ls_data> TYPE any.F…
阅读更多...
Since Maven 3.8.1 http repositories are blocked.

Since Maven 3.8.1 http repositories are blocked.

编译maven 项目时候报错提示下面信息&#xff1a; Since Maven 3.8.1 http repositories are blocked.Possible solutions: - Check that Maven settings.xml does not contain http repositories - Check that Maven pom files do not contain http repository http://XXXXXX:…
阅读更多...
Proxyman Premium for Mac v5.1.1激活版：卓越的网络调试与分析工具

Proxyman Premium for Mac v5.1.1激活版：卓越的网络调试与分析工具

Proxyman Premium for Mac是一款功能强大的网络调试与分析工具&#xff0c;专为开发人员和测试人员精心打造。它集多种功能于一身&#xff0c;为用户提供了全面、高效的网络开发体验。 Proxyman Premium for Mac v5.1.1激活版下载 作为一款跨平台代理工具&#xff0c;Proxyman …
阅读更多...
网站创建的流程是什么

网站创建的流程是什么

网站的创建过程包括几个主要的步骤&#xff0c;其中涉及到一系列的决策和实践操作。下面我将详细介绍网站创建的流程&#xff0c;帮助读者了解如何创建一个成功的网站。 第一步&#xff1a;确定网站目标和功能 在创建网站之前&#xff0c;你需要明确自己网站的目标和功能。是用…
阅读更多...
pytorch Neural Networks学习笔记

pytorch Neural Networks学习笔记

&#xff08;1&#xff09;输入图像&#xff0c;13232&#xff0c;通道数1&#xff0c;高32&#xff0c;宽32 &#xff08;2&#xff09;卷积层1&#xff0c;滤波器的shape为6155&#xff0c;滤波器个数6&#xff0c;通道数1&#xff0c;高5&#xff0c;宽5。卷积层1的输出为62…
阅读更多...
网络靶场实战-加密固件分析

网络靶场实战-加密固件分析

背景 在漏洞挖掘过程中&#xff0c;想要对二进制程序改进分析&#xff0c;我们就需要获取目标设备的文件系统&#xff0c;这样才能更好的逆向分析设备程序的运行逻辑&#xff0c;从而发现其中的漏洞点。然而并非所有设备固件中的文件系统都可以让我们轻易获取&#xff0c;对于…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023