Spring Aop的方法执行简单模型

用简单的代码模拟了Spring Aop的方法调用流程

主要难点在于责任链模式的执行流程，不太好跟踪代码步骤

其次，各种方法拦截器的执行方式

import java.lang.reflect.Method;

/**
 * aop执行模型
 * @author sunxueqiang
 */
public class AopInvokeModel {
    /**
     *     方法拦截器
     */
    interface MethodInterceptor {
        Object invoke(MethodInvocation mi) throws Throwable;
    }
    
    //前置拦截器：调用下一个拦截器前执行拦截逻辑
    static MethodInterceptor before = (mi)->{
        System.out.println("1:----before------");
        return mi.proceed();
    };
    
    //环绕拦截器：调用下个拦截器前后执行环绕逻辑
    static MethodInterceptor around = (mi)->{
        System.out.println("2:----around before------");
        Object result =  mi.proceed();
        System.out.println("4:----around after------");
        return result;
    };
    
    //后置拦截器：finally中执行拦截逻辑
    static MethodInterceptor after = (mi)->{
        try {
            return mi.proceed();
        } finally {
            System.out.println("5:----after------");
        }
    }; 
    
    //返回拦截器：如果能正常返回执行结果，随后执行拦截逻辑
    static MethodInterceptor afterReturning = (mi)->{
        Object result = mi.proceed();
        System.out.println("6:----after returning------");
        return result;
    }; 
    
    //异常拦截器：catch中执行拦截逻辑
    static MethodInterceptor afterThrowing = (mi)->{
        try {
            return mi.proceed();
        } catch (Exception e) {
            System.out.println("----after throwing------");
            throw e;
        }
    }; 
    
    /**
     *     方法执行
     */
    static class MethodInvocation{
        //方法拦截器链
        private MethodInterceptor[] methodInterceptors; 
        //目标对象
        private Object target;    
        //方法
        private Method method;
        //拦截器链执行位置
        private int index = 0;
        
        public MethodInvocation(Object target,Method method,MethodInterceptor[] methodInterceptors) {
            super();
            this.target = target;
            this.method = method;
            this.methodInterceptors = methodInterceptors;
        }

        /**
         *     责任链模式
         *     执行链中的下一个拦截器
         */
        public Object proceed() throws Throwable {
            if(methodInterceptors.length == index) {
                return method.invoke(target);
            }
            MethodInterceptor methodInterceptor = methodInterceptors[index ++];
            return methodInterceptor.invoke(this);
        }
    }
    
    //测试方法
    public String testMethod() {
        System.out.println("5:----testMethod----------");
        if(true) {
            //throw new RuntimeException("--- exception ---");
        }
        return "result";
    }
    
    public static void main(String[] args) throws Throwable {
        AopInvokeModel aopInvokeModel = new AopInvokeModel();
        Method method = aopInvokeModel.getClass().getMethod("testMethod");
        MethodInterceptor[] methodInterceptors = new MethodInterceptor[] {
                afterReturning,    afterThrowing, before, after, around,
        };//定义拦截器链
        MethodInvocation mi = new MethodInvocation(aopInvokeModel, method, methodInterceptors);
        Object result = mi.proceed();
        System.out.println(result);
    }
    
}

执行结果：

1:----before------
2:----around before------
5:----testMethod----------
4:----around after------
5:----after------
6:----after returning------
result