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

没什么技术

已于 2024-04-13 15:35:26 修改

阅读量806

点赞数 15

文章标签： spring 缓存 java

于 2024-04-13 15:06:13 首次发布

本文链接：https://blog.csdn.net/qq_62775328/article/details/137715924

版权

本文详细介绍了SpringIOC容器的加载过程，包括bean的扫描、实例化、依赖注入和多级缓存策略，特别是针对循环依赖问题的解决方案，通过一级、二级和三级缓存的使用来确保线程安全和规范执行。

摘要由CSDN通过智能技术生成

在文章开始之前，先来看一张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);
    }
}

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