Java AOP的实现原理和手写实现,支持JDK动态代理,Javassist代理,Cglib代理

Java AOP的实现原理和手写实现,支持JDK动态代理和Cglib代理

概述

面向切面编程已经在我们的平常工作中经常会用到, 平常我们在使用的都是使用spring封装的aop模块, 使用的时候只要配置几个注解就能实现逻辑了,非常的方便. 但是使用的方便也就意味着其封装的复杂, 另外spring的aop也是有其的演进,从最早的只能通过实现接口+xml配置,到现在@Aspect的支持来实现声明式的变成方式.

为什么要手写实现一遍

你能手写出来,自然证明你已经对其的很了解了, 那么再手写一遍更能加深你的印象, 下面我将会从原理介绍->类设计->接口设计->代码实现几个步骤来讲述手写的过程,顺便会讲一下我在写的过程中遇到的坑.

设计

下面是我设计的uml类图,因为受spring aop的设计实现,所以在命名上进行了一定程度的借鉴.

主要的接口设计是跟AOP的概念想对应的,比如pointcut对应切点,advice对应增强(也就是横切逻辑),ProxyFactory对应织入器

接口设计和实现

接口或者类的设计还是比较简单的,下面看一下具体的接口和实现

// 切点接口
public interface PointCut {
    Boolean match(Object object);
}
//目前就实现了切对应的类 和对应方法
public class MethodPointCut implements PointCut {
    private Method method;
...
    @Override
    public Boolean match(Object object) {
        return method.equals(object);
    }
}
public class ClassPointCut<T> implements PointCut{
    private Class<T> clazz;
   ...
    @Override
    public Boolean match(Object object){
        if (object.getClass().equals(clazz)) return true;
        for (Class<?> anInterface : object.getClass().getInterfaces()) {
            if (anInterface.equals(clazz)) return true;
        }
        return false;
    }
}

下面是横切逻辑的接口实现

//增强接口
public interface Advice {
}
//前置增强
public interface BeforeAdvice extends Advice{
    
    <T> void invokeBefore(Class<T> clazz, Method method, Object[] args);
}
public interface AroundAdvice extends Advice{
    // 注意这里使用了函数接口, 源方法的执行结果通过supplier.get() 进行获取结果
    <T>Object invoke(Class<T> clazz, Method method, Object[] args, Supplier<Object> supplier) throws Exception;
}
public interface AfterAdvice extends Advice {
    
    <T> Object invokeAfter(Class<T> clazz, Method method, Object[] args, Object result, Exception exception);
}

下面是用于汇聚切点和横切逻辑的类, 我实现了默认的实现,主要只是针对固定类和方法的aop增强

public interface Advisor {
}
// 这是默认的实现, 这个类主要是汇聚切点个横切逻辑的
public class DefaultAdvisor implements Advisor {
    //类必须要匹配的,不然就不需要进行代理了
    private ClassPointCut classPointCut;
    //在拦截方法时,如果不包含在内就不进行前后增强,如果为空就默认全部都要增强
    private List<MethodPointCut> methodPointCuts;
    //增强列表
    private List<Advice> adviceList;
    
    public DefaultAdvisor(ClassPointCut classPointCut) {
        this.classPointCut = classPointCut;
        this.methodPointCuts = new ArrayList<>();
        this.adviceList = new ArrayList<>();
    }
    
    /**
     * 构建横切逻辑调用链
     * @param supplier
     * @return
     */
    public AdviceChain buildChain(Supplier<Object> supplier) {
        AdviceChain adviceChain = new AdviceChain(supplier);
        for (Advice advice : adviceList) {
            if (advice instanceof BeforeAdvice) {
                adviceChain.addBeforeAdvice((BeforeAdvice) advice);
            }
            if (advice instanceof AroundAdvice) {
                adviceChain.addAroundAdvice((AroundAdvice) advice);
            }
            if (advice instanceof AfterAdvice) {
                adviceChain.addAfterAdvice((AfterAdvice) advice);
            }
        }
        return adviceChain;
    }
    
    /**
     * 添加方法切点,如果为空则默认拦截全部方法
     * @param methodPointCut
     * @return
     */
    public DefaultAdvisor addMethodPointCut(MethodPointCut methodPointCut) {
        methodPointCuts.add(methodPointCut);
        return this;
    }
    

    public DefaultAdvisor addAdvice(Advice advice) {
        adviceList.add(advice);
        return this;
    }
    
    /**
     * 判断是否需要构造代理对象
     *
     * @param object
     * @return
     */
    public Boolean matchClass(Object object) {
        return classPointCut == null || classPointCut.match(object);
    }
    
    /**
     * 判断是否需要拦截
     *
     * @param method
     * @return
     */
    public Boolean matchMethod(Method method) {
        if (methodPointCuts.isEmpty()) return true;
        for (MethodPointCut methodPointCut : methodPointCuts) {
            Boolean match = methodPointCut.match(method);
            if (match) return true;
        }
        return false;
    }
}

下面是一个比较重要的类,就是横切逻辑的链,也就是责任链模式的实现

public class AdviceChain {
    
    private List<BeforeAdvice> beforeAdvices;
    private List<AroundAdvice> aroundAdvices;
    private List<AfterAdvice> afterAdvices;
    private Supplier<Object> supplier;
    
    public AdviceChain( Supplier<Object> supplier) {
        this.beforeAdvices = new ArrayList<>();
        this.aroundAdvices =new ArrayList<>();
        this.afterAdvices =new ArrayList<>();
        this.supplier = supplier;
    }
    
    public void addBeforeAdvice(BeforeAdvice beforeAdvice){
        beforeAdvices.add(beforeAdvice);
    }
    public void addAroundAdvice(AroundAdvice aroundAdvice){
        aroundAdvices.add(aroundAdvice);
    
    }
    public void addAfterAdvice(AfterAdvice afterAdvice){
        afterAdvices.add(afterAdvice);
    }
    
    public <T>Object doInvoke(Class<T> clazz, Method method, Object[] objects){
    	//首先执行所有的前置增强
        beforeAdvices.forEach(e->e.invokeBefore(clazz, method, objects));
    
        Object object = null;
        Exception exception = null;
        // 最初生产者指向原方法的执行
        Supplier<Object> finalObjectSupplier = supplier;
        for (AroundAdvice aroundAdvice : aroundAdvices) {
            Supplier<Object> temp = finalObjectSupplier;
            //替换旧的给下一个AroundAdvice使用
            finalObjectSupplier = () -> {
                try {
                    return aroundAdvice.invoke(clazz, method, objects, temp);
                } catch (Exception e) {
                    return e;
                }
            };
        }
        //执行最后一个生成者
        Object result = finalObjectSupplier.get();
        if (result instanceof Exception) {
            exception = (Exception) result;
        } else {
            object = result;
        }
    
        Exception finalException = exception;
        Object finalObject = object;
        //后置增强的顺序执行
        afterAdvices.forEach(e->e.invokeAfter(clazz, method, objects, finalObject, finalException));
        
        return object;
    }
}

好了还剩下最后的织入器

public interface ProxyFactory {
    <T> T generateProxy(T target, Advisor advisor);
    
    default  <T> Object doInterceptor(T target, DefaultAdvisor advisor, Method method, Object[] args) throws IllegalAccessException, InvocationTargetException {
        String methodName = method.getName();
        Class<?>[] parameterTypes = method.getParameterTypes();
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(target, args);
        }
        if ("toString".equals(methodName) && parameterTypes.length == 0) {
            return target.toString();
        }
        if ("hashCode".equals(methodName) && parameterTypes.length == 0) {
            return target.hashCode();
        }
        if ("equals".equals(methodName) && parameterTypes.length == 1) {
            return target.equals(args[0]);
        }
        
        if (!advisor.matchMethod(method)) return method.invoke(target, args);
        
        Supplier<Object> supplier = () -> {
            try {
                return method.invoke(target, args);
            } catch (Throwable throwable) {
                return new RuntimeException(throwable);
            }
        };
        AdviceChain adviceChain = advisor.buildChain(supplier);
        
        return adviceChain.doInvoke(target.getClass(), method, args);
    }
    
}

//jdk动态代理实现的织入器
public class JDKProxyFactory implements ProxyFactory {
    
    
    @Override
    public <T> T generateProxy(T target, Advisor advisor) {
        DefaultAdvisor defaultAdvisor = (DefaultAdvisor) advisor;
        if (!((DefaultAdvisor) advisor).matchClass(target)) return target;
    
        Object proxyInstance = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                target.getClass().getInterfaces(),
                (proxy, method, args) -> doInterceptor(target, (DefaultAdvisor) advisor, method, args));
        return (T)proxyInstance;
    
    }
    
   
}

//cglib实现逻辑类似
public class CglibProxyFactory implements ProxyFactory{
    
    
    @Override
    public <T>T generateProxy(T target , Advisor advisor){
        DefaultAdvisor defaultAdvisor = (DefaultAdvisor) advisor;
        if (!((DefaultAdvisor) advisor).matchClass(target)) return target;
        
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        // methodProxy.invokeSuper(o, objects);
        enhancer.setCallback((MethodInterceptor) (o, method, args, methodProxy) ->
                doInterceptor(target, (DefaultAdvisor) advisor, method, args));
    
        return (T)enhancer.create();
    }
    
}

// Javassist实现
public class JavassistProxyFactory implements ProxyFactory {
    
    
    @Override
    public <T> T generateProxy(T target, Advisor advisor) {
        DefaultAdvisor defaultAdvisor = (DefaultAdvisor) advisor;
        if (!((DefaultAdvisor) advisor).matchClass(target)) return target;
        
        
        javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory();
        factory.setInterfaces(target.getClass().getInterfaces());
        Class<?> proxyClass = factory.createClass();
        ProxyObject javassistProxy;
        try {
            javassistProxy = (ProxyObject) proxyClass.newInstance();
            javassistProxy.setHandler((self, method, proceed, args) ->
                    doInterceptor(target, (DefaultAdvisor) advisor, method, args));
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        return (T) javassistProxy;
    }
    
}

这里提醒一下,之前写jdk动态代理的使用,没有使用target作为执行的对象,然后遇到了未知错误, 所以要千万注意,不能写的太快了, 然后cglib那里我将原来的执行改成了method.invoke, 是因为cglib的增强是支持方法嵌套增强的, 而jdk不支持, 所以为了统一就用method.invoke了, 另外cglib的底层是asm, javassist底层也是asm, 性能上的话我没有对比多.

测试

测试类代码如下

public interface Sleep {
    int sleep(int time);
}
public class SleepImpl  implements Sleep{
    @Override
    public int sleep(int time) {
        System.out.println(time);
        return time;
    }
}
public class MainTest {
    
    public static void main(String[] args) {
        Sleep sleep = new SleepImpl();
    
        DefaultAdvisor advisor = new DefaultAdvisor(new ClassPointCut(Sleep.class)).addAdvice(new BeforeAdvice() {
            @Override
            public <T> void invokeBefore(Class<T> clazz, Method method, Object[] args) {
                System.out.println("before");
            }
        }).addAdvice(new AfterAdvice() {
            @Override
            public <T> Object invokeAfter(Class<T> clazz, Method method, Object[] args, Object result, Exception exception) {
                System.out.println("after");
                return result;
            }
        }).addAdvice(new AroundAdvice() {
            @Override
            public <T> Object invoke(Class<T> clazz, Method method, Object[] args, Supplier<Object> supplier) throws Exception {
                System.out.println("around before");
                Object result = supplier.get();
                System.out.println("around after");
                return result;
            }
        }).addAdvice(new AroundAdvice() {
            @Override
            public <T> Object invoke(Class<T> clazz, Method method, Object[] args, Supplier<Object> supplier) throws Exception {
                System.out.println("around before2");
                Object result = supplier.get();
                System.out.println("around after2");
                return result;
            }
        });
    
        ProxyFactory proxyFactory = new JavassistProxyFactory();
//        ProxyFactory proxyFactory = new JDKProxyFactory();
//        ProxyFactory proxyFactory = new CglibProxyFactory();
    
        Sleep sleep1 = proxyFactory.generateProxy(sleep, advisor);
    
        sleep1.sleep(100);
    
    }
}

执行的结果如下

before
around before2
around before
100
around after
around after2
after
Process finished with exit code 0

可以看到执行的结果就是我想要的,进行aop增强后的结果, 虽然使用的时候用没有 spring的aop那么好用,但是实际上spring在启动的时候也会将基于注解的aop逻辑进行转换成具体的类, 所以让我们用的时候才会这么简单, 有了上面的这一套代码,就可以做很多的事情了,比如自己实现以个声明式的事务管理, 方法参数的日志打印等,都是可以的.