spring AOP 总结

• spring AOP 底层是使用动态代理实现的。

• AOP 动态代理实现方式有两种：JDK 动态代理、CGLIB 动态代理。那如何选择动态代理方式呢。
  如果代理类实现了接口，则采用JDK代理模式
  如果代理类没有实现接口，则采用CGLIB动态代理模式
  如果代理类实现了接口，但是强制使用CGLIB代理，则使用CGLIB代理（比如给类注解@EnableAspectJAutoProxy(proxyTargetClass = true)）

• AOP 叠加是使用责任链模式
  Chain.class

package com.example.demo.chain;

import org.springframework.context.annotation.EnableAspectJAutoProxy;

import java.util.List;
public class Chain {
    private List<ChainHandler> handlers;
    private int index = 0;

    public Chain(List<ChainHandler> handlers) {
        this.handlers = handlers;
    }

    public void process(){
        if(index >= handlers.size()){
            return;
        }
        handlers.get(index++).execute(this);
    }
}

ChainHandler.class

package com.example.demo.chain;

public abstract class ChainHandler {

    public void execute(Chain chain){
        this.handlerProcess();
        chain.process();
    }

    public abstract void handlerProcess();
}

ChainClient.class

package com.example.demo.chain;

import java.util.Arrays;

public class ChainClient {
    public static  void main(String[] args) {

         class HandlerA extends ChainHandler{
            @Override
            public void handlerProcess() {
                System.out.println("handler chain A");
            }
        }

        class HandlerB extends ChainHandler{
            @Override
            public void handlerProcess() {
                System.out.println("handler chain B");
            }
        }

        class HandlerC extends ChainHandler{
            @Override
            public void handlerProcess() {
                System.out.println("handler chain C");
            }
        }

        Chain chain = new Chain(
                Arrays.asList(
                        new HandlerA(),
                        new HandlerB(),
                        new HandlerC()
                )
        );

         chain.process();
    }
}

• AOP 通知顺序
  Beforearound
  Before
  do action （动作）
  Afteraround
  After
  AfterReturning