Spring循环依赖导致的@PostConstruct顺序没有按

背景

bean的生命周期如下图所示：

image.png

@PostConstruct注解是会被一个专门的BeanPostProcessor接口的具体实现类来处理的，实现类是：InitDestroyAnnotationBeanPostProcessor。

按照加载顺序，@PostConstruct也会按照依赖顺序执行。

但是在代码里并没有按照期望顺序执行，依赖关系如下：

@Service
@Slf4j
public class A {
    @Resource
    private B b;

    @PostConstruct
    public void init(){
        log.info("A PostConstruct");
        b.test();
    }
}



@Service
@Slf4j
public class B {
    @Resource
    private C c;

    @PostConstruct
    public void init(){
        log.info("B PostConstruct");
    }

    public void test(){
        log.info("B Test");
    }
}


@Service
public class C {

    @Resource
    private A a;
}

A对象里依赖了B对象，并且A的@PostConstruct方法依赖了B的@PostConstruct生成的数据，但是A的@PostConstruct，导致拿到的数据为空

问题分析

经过debug，发现是由于循环依赖导致，B先加载并且提前暴露，导致A执行@PostConstruct时B还没有初始化完成

为解决循环依赖，spring采用三级缓存机制，将实例化成功的对象加载到三级缓存，

这三级缓存的作用分别是：

singletonFactories ： 进入实例化阶段的单例对象工厂的cache （三级缓存）

earlySingletonObjects ：完成实例化但是尚未初始化的，提前暴光的单例对象的Cache （二级缓存）

singletonObjects：完成初始化的单例对象的cache（一级缓存）

我们在创建bean的时候，会首先从cache中获取这个bean，这个缓存就是sigletonObjects。主要的调用方法是：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    //isSingletonCurrentlyInCreation()判断当前单例bean是否正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            //allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    //其实也就是从三级缓存移动到了二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

从上面三级缓存的分析，我们可以知道，Spring解决循环依赖的诀窍就在于singletonFactories这个三级cache。这个cache的类型是ObjectFactory，定义如下：

public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

这个接口在AbstractBeanFactory里实现，并在核心方法doCreateBean（）引用下面的方法:

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

这段代码发生在createBeanInstance之后，populateBean（）之前，也就是说单例对象此时已经被创建出来(调用了构造器)。这个对象已经被生产出来了，此时将这个对象提前曝光出来

所以在发生循环依赖时，B还未初始化，所以@PostConstruct方法还未执行

解决方案

• 解决循环依赖

• 将逻辑从@PostConstruct里抽出来