springboot三级缓存循环依赖

对于Spring Boot的三级缓存循环依赖问题，需要先了解Bean的创建过程。Spring Boot在创建Bean时，首先扫描所有的@Component注解，将其注册到Bean定义列表中，然后再逐一实例化Bean对象，此过程中如果发现依赖关系，则从Bean定义列表中查找已经实例化的Bean，如果找不到，则会将该Bean加入到三级缓存中等待后续处理。 当所有的Bean实例化完成后，Spring Boot会开始解决循环依赖问题，此时会从三级缓存中查找该Bean的代理对象并返回。 如果在三级缓存中仍然找不到，则表示出现了无法解决的循环依赖问题，抛出BeanCurrentlyInCreationException异常。因此，我们需要小心处理Bean之间的依赖关系，尽量避免出现循环依赖问题。

相关问题

springboot三级缓存

Spring Boot并没有内置的三级缓存功能。引用\[1\]中提到的三级缓存是指在Spring框架中解决循环依赖问题时使用的一种缓存机制。这个缓存机制只适用于单例的Bean，并且是在Spring框架内部实现的。它的大致流程是：首先，当一个Bean被创建时，会将其放入一级缓存中；然后，当需要解决循环依赖时，会将正在创建的Bean放入二级缓存中；最后，当Bean创建完成后，会将其放入三级缓存中。这样，在后续的Bean创建过程中，如果遇到相同的循环依赖，就可以直接从三级缓存中获取已经创建好的Bean，而不需要重新创建。但需要注意的是，这个三级缓存只是Spring框架内部使用的，对于非单例的Bean以及Spring Boot应用中的缓存功能，需要使用其他的缓存解决方案，比如Redis、Memcache等。所以，如果你想在Spring Boot中使用三级缓存，需要自己实现或使用第三方的缓存库来实现。
#### 引用[.reference_title]
- *1* [Spring三级缓存](https://blog.csdn.net/qq_36363499/article/details/126224949)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item]
- *2* *3* [SpringBoot+Redis+MemCache+Nginx+Lua实现三级缓存架构（一）——三级缓存架构体系](https://blog.csdn.net/wdcl2468/article/details/100040202)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]

springboot如何用三级缓存解决循环依赖

在Spring中，循环依赖可能会导致bean无法正确地初始化，此时可以使用三级缓存解决该问题。具体步骤如下：

1. 创建一个ConcurrentHashMap类型的三级缓存，用于存储正在创建的bean。

2. 当Spring创建一个bean时，将该bean放入三级缓存的第一级中。如果发现该bean依赖于另一个正在创建的bean，则将该bean放入三级缓存的第二级中，表示该bean已经被创建但是未完成初始化。

3. 当另一个bean依赖于第二级缓存中的bean时，将该bean放入三级缓存的第三级中，表示该bean已经被创建和完成初始化。

4. 如果一个bean已经完成初始化，则将其从三级缓存中移除，同时将其添加到Spring容器中。

5. 如果在创建bean的过程中发生异常，则将该bean从三级缓存中移除，并抛出异常。

示例代码如下：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    // 三级缓存，用于存储正在创建的bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    @Override
    public Object getSingleton(String beanName) {
        // 从第一级缓存中获取bean
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            // 从第二级缓存中获取bean
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null) {
                // 从第三级缓存中获取bean
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    // 将bean从第三级缓存移动到第二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
        return singletonObject;
    }

    protected boolean isSingletonCurrentlyInCreation(String beanName) {
        return this.singletonObjects.containsKey(beanName);
    }

    protected void addSingleton(String beanName, Object singletonObject) {
        // 将bean从第一级缓存移动到第二级缓存
        this.singletonObjects.remove(beanName);
        this.earlySingletonObjects.put(beanName, singletonObject);
    }

    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        // 将bean从第一级缓存移动到第三级缓存
        this.singletonObjects.remove(beanName);
        this.singletonFactories.put(beanName, singletonFactory);
    }

    protected void removeSingleton(String beanName) {
        // 将bean从第二级缓存或第三级缓存移除
        this.earlySingletonObjects.remove(beanName);
        this.singletonFactories.remove(beanName);
        this.singletonObjects.remove(beanName);
    }
}

在Spring Boot中，可以通过配置以下属性开启循环依赖的三级缓存：

spring.main.allow-circular-references=true

注意：使用三级缓存解决循环依赖可能会导致内存泄漏和线程安全问题，需要谨慎使用。