Java手写实现AOP

什么是AOP？

当然AOP的概念网上一查一大堆，我就不在这贴概念了，大家可以自己看看，在这我就说说自己理解的AOP。
AOP（Aspect Oriented Programming)面向切面编程，即在不影响原有功能的情况下，进行的一次横向扩展。
面向切面和横向扩展我们可以这么理解：有一个分装好的类，我们需要在类的方法执行前后插入额外的代码，要求是不破坏原始类，一种方法是我们可以去继承这个类每个方法前面去增强，但是若是多个方法，每个方法前都去写同样的增强代码不符合我们程序人的身份，所以我们使用AOP的方法，将方法（切入点）和通知（增强功能）组成一个切面再去加入这个对象（使用代理）。

代理，大家可以看看博主另一篇关于代理

模拟AOP代码思路

思路如下：

• 抽象类： Interceptor 这个类中的两个成员，决定了该拦截器是拦截哪个类的哪个方法的。给出三种拦截的抽象方法。
• 类： InterceptorAdpter 这个类继承了上面的抽象方法，给出默认拦截处理，以后由工具使用者来决定要覆盖哪种方法。
• 类：Proxy 这个类负责将代理对象，原对象，还有他自己的拦截器链联系起来。我这里实现的AOP较粗糙，每个代理对象拥有一套自己的拦截器链。对拦截器的增加和删除也在这其中完成。
• 类：ProxyFactory 这个类主要是用来生成代理对象（JDK和CGLIB方式）。
• 类：FactoryProxyBean 这个类用来将类名和Proxy联系起来，以及处理其中拦截链的关系。

具体代码

• 拦截器抽象方法 Interceptor

package MyIntrceptor;

import java.lang.reflect.Method;

/**
 * @author quan
 * @create 2020-06-22 10:18
 */
public abstract class Interceptor {
   
    private Class<?> klass;
    private Method method;

    public Interceptor() {
   
    }

    public Interceptor(Class<?> klass, Method method) {
   
        this.klass = klass;
        this.method = method;
    }

    public Class<?> getKlass() {
   
        return klass;
    }

    public void setKlass(Class<?> klass) {
   
        this.klass = klass;
    }

    public Method getMethod() {
   
        return method;
    }

    public void setMethod(Method method) {
   
        this.method = method;
    }

    public abstract boolean before(Object[] args);
    public abstract Object after(Object result);
    public abstract void dealException(Throwable th);

}

• Proxy

package MyProxy;

import MyException.InterceptorAlReadyExistException;
import MyIntrceptor.Interceptor;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * 装着原对象 代理对象 以及拦截器链
 * @author quan
 * @create 2020-06-22 10:26
 */
public class Proxy {
   
    private Object proxy;
    private Object object;
    private List<Interceptor> interceptorList;

    public Proxy() {
   
        interceptorList = new ArrayList<>();
    }

    public Object getProxy() {
   
        return proxy;
    }

    public void setProxy(Object proxy) {
   
        this.proxy = proxy;
    }

    public Object getObject() {
   
        return object;
    }

    public void setObject(Object object) {
   
        this.object = object;
    }

    public List<Interceptor> getInterceptorList() {
   
        return interceptorList;
    }

    public void setInterceptorList(List<Interceptor> interceptorList) {
   
        this.interceptorList = interceptorList;
    }

    //前置拦截
    public boolean doBefore(Method method, Object[] args) {
   
        for (Interceptor interceptor : interceptorList) {
   
            if (!interceptor.getMethod().equals(method)) {
   
                continue;
            }
            if (!interceptor.before(args)) {
   
                return false;
            }
        }
        return true;
    }

    //后置拦截
    public Object doAfter(Method method, Object result