当前位置：首页 > news >正文

泰州网站制作费用如何建立外贸网站

news 2025/10/16 15:06:27

泰州网站制作费用,如何建立外贸网站,企业融资案例,做网站代码编辑工具目录三级缓存核心原理循环依赖的解决过程 1. Bean A创建过程中提前曝光工厂 2. Bean B创建时发现依赖A，从缓存获取 3. Bean A继续完成初始化三级缓存的作用总结二级缓存为何不够解决缓存依赖？ 三级缓存如何解决？ 为什么不直接在…

三级缓存核心原理

循环依赖的解决过程

1. Bean A创建过程中提前曝光工厂

2. Bean B创建时发现依赖A，从缓存获取

3. Bean A继续完成初始化

三级缓存的作用总结

二级缓存为何不够解决缓存依赖？

三级缓存如何解决？

为什么不直接在实例化后创建代理？

总结

Spring通过三级缓存机制解决循环依赖问题，这与populateBean()方法密切相关。下面我用简化代码解释这个机制：

三级缓存核心原理

Spring在DefaultSingletonBeanRegistry中维护了三个重要的缓存：

// 一级缓存：存储完全初始化的单例bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);// 二级缓存：存储早期曝光的单例bean（未完全初始化）
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);// 三级缓存：存储单例工厂对象，用于创建早期曝光的bean
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

循环依赖的解决过程

当发生循环依赖时，Spring通过以下步骤解决：

1. Bean A创建过程中提前曝光工厂

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {// 1. 实例化Bean（调用构造函数）BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);// 2. 提前曝光一个ObjectFactory，用于解决循环依赖boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences);if (earlySingletonExposure) {addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// 3. 填充属性（可能触发对Bean B的依赖）populateBean(beanName, mbd, instanceWrapper);// 4. 初始化Bean（调用init方法和AOP代理）exposedObject = initializeBean(beanName, exposedObject, mbd);return exposedObject;
}// 将工厂添加到三级缓存
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {synchronized (this.singletonObjects) {if (!this.singletonObjects.containsKey(beanName)) {this.singletonFactories.put(beanName, singletonFactory);this.earlySingletonObjects.remove(beanName);}}
}

2. Bean B创建时发现依赖A，从缓存获取

当populateBean()处理B的依赖时：

protected Object resolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {// 查找依赖的bean（假设这里是A）String dependencyName = descriptor.getDependencyName();// 从三级缓存中获取beanObject bean = getSingleton(dependencyName, false);return bean;
}// 从三级缓存中获取bean的核心方法
protected Object getSingleton(String beanName, boolean allowEarlyReference) {// 1. 先从一级缓存获取Object singletonObject = this.singletonObjects.get(beanName);// 2. 如果一级缓存没有且bean正在创建中if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {// 3. 从二级缓存获取singletonObject = this.earlySingletonObjects.get(beanName);// 4. 二级缓存没有且允许早期引用if (singletonObject == null && allowEarlyReference) {synchronized (this.singletonObjects) {// 5. 从三级缓存获取工厂ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {// 6. 通过工厂创建早期bean实例singletonObject = singletonFactory.getObject();// 7. 放入二级缓存this.earlySingletonObjects.put(beanName, singletonObject);// 8. 从三级缓存移除this.singletonFactories.remove(beanName);}}}}return singletonObject;
}

3. Bean A继续完成初始化

当B完成创建后，A继续完成自己的初始化：

// 完成Bean A的初始化
exposedObject = initializeBean(beanName, exposedObject, mbd);// 将完全初始化的bean放入一级缓存
addSingleton(beanName, exposedObject);protected void addSingleton(String beanName, Object singletonObject) {synchronized (this.singletonObjects) {this.singletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);this.earlySingletonObjects.remove(beanName);}
}

三级缓存的作用总结

一级缓存（singletonObjects）：存储完全初始化的单例bean，可直接使用
二级缓存（earlySingletonObjects）：存储早期曝光的bean（未完成初始化），用于解决循环依赖
三级缓存（singletonFactories）：存储工厂对象，允许在需要时创建早期bean，并支持AOP代理

通过这种机制，Spring允许在bean尚未完全初始化时就将其引用暴露给依赖它的其他bean，从而解决循环依赖问题。注意：只有单例作用域的bean支持循环依赖，原型模式不支持。你的问题非常关键！实际上，二级缓存理论上可以解决循环依赖，但Spring依然使用三级缓存，主要出于AOP代理的考虑。我来详细解释：

二级缓存为何不够解决缓存依赖？

假设只有两级缓存：

singletonObjects（完全初始化的bean）
earlySingletonObjects（早期曝光的bean）

当出现循环依赖时，我们可以在实例化后直接将bean放入earlySingletonObjects。但这样会有一个问题：如果bean需要AOP代理，早期曝光的将是原始对象，而不是代理对象。

举个例子：

// Bean A依赖B，Bean B依赖A
class A {@Autowired private B b;@Transactional public void doSomething() {} // 需要AOP代理
}class B {@Autowired private A a;
}

当A和B循环依赖时：

A实例化后放入二级缓存（此时是原始对象）
B创建时从二级缓存获取A的原始对象
B完成创建，注入A的原始对象
A继续初始化，创建代理对象

最终结果：B持有的是A的原始对象，而不是代理对象，导致AOP失效！

三级缓存如何解决？

Spring通过三级缓存引入了ObjectFactory，将AOP代理的创建延迟到真正需要早期引用时：

// 三级缓存：存储工厂对象，用于创建可能需要代理的早期bean
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);// 添加工厂到三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));// 获取早期引用的方法（可能创建代理）
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {Object exposedObject = bean;if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;// 如果需要代理，这里会创建代理对象exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);}}}return exposedObject;
}

当B需要A的早期引用时：

从三级缓存获取ObjectFactory
通过工厂调用getEarlyBeanReference()，此时才决定是否创建代理
将结果（可能是代理对象）放入二级缓存

这样一来，B持有的就是A的代理对象，保证了AOP的正确性。

为什么不直接在实例化后创建代理？

你可能会问：为什么不直接在实例化A后就创建代理，然后放入二级缓存？这样不就不需要三级缓存了吗？

原因有两点：

性能优化：不是所有bean都需要代理，延迟到真正需要时再创建可以避免不必要的代理
顺序正确性：Spring的后置处理器执行顺序是有规范的。postProcessBeforeInitialization和postProcessAfterInitialization应该在bean初始化阶段执行，而不是实例化阶段。如果提前创建代理，会破坏这个顺序。