Spring AOP执行顺序、IOC循环依赖

AOP执行顺序

1、aop常用注解:

• @Before
• @After
• @AfterReturning
• @AfterThrowing
• @Around

Sping4 与Spring5 aop对应的执行顺序有所不同。
SpringBoot 1.x.x版本对应的是 Spring4 ，SpringBoot 2.x.x 版本对应Spring5.

---

IOC循环依赖

官网文档:

简单翻译过来:

  									循环依赖

如果主要使用构造函数注入，可能会创建无法解析的循环依赖场景。

例如:类A需要一个类B通过构造函数注入的实例，而类B需要一个类A通过构造函数注入的实例。如果您将bean配置为类A和B相互注入，SpringIoC容器将在运行时检测这个循环引用，并抛出一个BeanCurrentlyInCreationException异常。

一种可能的解决方案是编辑某些类的源代码，由setter注入而不是构造函数来注入。另外，避免构造函数注入，只使用setter注入。换句话说，尽管不建议这样做，但您可以使用setter注入配置循环依赖项。

与典型的情况(没有循环依赖关系)不同，bean A和bean
B之间的循环依赖关系迫使一个bean在完全初始化之前被注入到另一个bean中(典型的先有鸡还是先有蛋的场景)。

构造函数注入:

@Component
public class ServiceA {
    private ServiceB serviceB;

    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

@Component
public class ServiceB {
    private ServiceA serviceA;

    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

public class Test {
    public static void main(String[] args) {
        new ServiceA(new ServiceB(new ServiceA()));
    }
}

上述代码在测试时就会出现问题，就会出现类A和B相互注入的问题。

---

setter注入:

public class A {

    private B b;

    //通过set方法注入
    public void setB(B b) {
        this.b = b;
    }

    public A() {
        System.out.println("创建了 A对象，并成功注入了B:"+this.b);
    }
}

public class B {

    private A a;

    //通过set方法注入
    public void setA(A a) {
        this.a = a;
    }

    public B() {
        System.out.println("创建了 B对象，并成功注入了A:" + this.a);
    }
}

<bean id="a" class="com.CircularDepencies.IOC.A" >
    <property name="b" ref="b"></property>
</bean>

<bean id="b" class="com.CircularDepencies.IOC.B" >
    <property name="a" ref="a"></property>
</bean>

ClassPathXmlApplicationContext classPath = new ClassPathXmlApplicationContext("bean.xml");
A a = classPath.getBean("a", A.class);
B b = classPath.getBean("b", B.class);

当创建的bean对象scope="prototype"时 就会出现 BeanCurrentlyInCreationException异常，当默认时也就是scope="singleton"时，spring就可以很好的解决循环依赖问题。所有非单例的Bean对象不会放到三级缓存中。

---

spring是通过三级缓存来实现解决循环依赖问题，但仅限于创建的bean实例为单例。

三级缓存就是三个Map ，在DefaultSingletonBeanRegistry类中.

/** Cache of singleton objects: bean name --> bean instance */
	一级缓存,表示已经经历了完整生命周期的bean对象。
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/** Cache of singleton factories: bean name --> ObjectFactory */
	三级缓存,表示存放生成bean的工厂。
	单例工厂的高速缓存:bean名称-ObjectFactory。
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** Cache of early singleton objects: bean name --> bean instance */
	二级缓存,表示Bean的生命周期还没走完(Bean的属性还未填充)就把该Bean放入该缓存中,也就是实例化但未初始化的Bean放入该缓存中。
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

---

查看spring源码可以发现，解决循环依赖主要依靠 3个Map和四个方法

---

具体流程:

---

结论：Spring解决循环依赖依靠的是Bean的 中间态这个概念,而这个中间态指的是已经实例化但是还没有初始化的状态(半成品,已经创建但是没有属性赋值)。实例化的过程中又需要构造器创建，如果A还没有创建好怎么可能提前曝光，所以构造器的循环依赖无法解决。
Spring为了解决单例的循环依赖问题，使用了三级缓存。

1. 一级缓存为单例池(singletonObjects)
2. 二级缓存为提前曝光对象(earlySingletonObjects)
3. 三级缓存为提前曝光对象工厂(singletonFactories)

假设A、B循环引用，实例化A的时候就将其放入三级缓存中，接着填充属性的时候又发现依赖B，同样的流程也是实例化后放入三级缓存，接着去填充属性时又发现自己依赖A，这时就从缓存中查找到存放在三级缓存中的A，没有AOP代理的话，直接将A的原始对象注入B中，完成B的初始化后，进行属性填充和初始化，这时B完成后，就去完成剩下的A的步骤，如果 有AOP代理，就进行AOP处理获取代理后的对象A，注入B，走剩下的流程。

附：