Spring AOP底层实现原理，使用jdk动态代理以及cglib动态代理

@Meto

已于 2022-09-22 14:42:09 修改

阅读量926

点赞数

文章标签： spring java 后端

于 2022-09-05 00:27:05 首次发布

本文链接：https://blog.csdn.net/qq_45830276/article/details/126697005

版权

Spring AOP底层实现原理，使用jdk动态代理以及cglib动态代理

文章目录

Spring AOP底层实现原理，使用jdk动态代理以及cglib动态代理

Aop底层使用动态代理实现：有两种情况动态代理

第一种：有接口情况，使用jdk动态代理

第二种：没有接口情况，使用cglib动态代理

1、使用jdk动态代理

创建接口实现类的代理对象，增强类的方法

（1）声明接口：

public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

（2）创建接口的实现类：

public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }

    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }

    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

在这里，我们需要创建代理，从这三个方法切入，执行操作

（4）创建代理对象（核心类）

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class TargetProxy {
    public static  <T> Object getTarget(T t) {
        return Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // proxy就是目标对象t，method就是调用目标对象中方法，args就是调用目标对象中方法的参数。
                        //比如说：代理对象.method1(),这时proxy就是目标类，method1就是method,args就是method1方法参数。
                        System.out.println("执行方法前...");
                        Object invoke = method.invoke(t, args);
                        System.out.println("执行方法后...");
                        return invoke;
            }
        });
    }
}

Proxy.newProxyInstance（）三个参数：

ClassLoader loader用来指明生成代理对象使用的类加载器；

Class<?>[ ] interfaces 用来指明目标类实现的所有接口；

InvocationHandler h 用来指明产生的这个代理对象要做的事情。

实现InvocationHandler接口后需要重写invoke方法，代理类调用的所有方法实际上都是通过invoke方法调用的目标方法，invoke方法内部实现了两个逻辑：一个是增强逻辑，一个是执行目标方法。通过method.getName()获取当前调用的是代理对象的哪个方法，如果该方法是要被增强的方法，则进行增强，否则直接执行。

此时我们就已经创建好了代理对象：（同时呢我们也可以自定义一个类，写上我们想要切面的方法，可以自定义在执行方法前和执行方法后去调用我们想要测试的方法）

（4）创建测试类

public class TargetUser {

    public static void main(String[] args) {
        TargetInteface target = (TargetInteface) TargetProxy.getTarget(new Target());
        target.method1();
        System.out.println("-----------------------------");
        target.method2();
        System.out.println("-----------------------------");
        System.out.println(target.method3(3));
        System.out.println("----------------");
    }
}

（5）测试结果

在这里插入图片描述

此时：我们用jdk创建动态代理就ok了，主要还是利用Proxy.newProxyInstance（）对象，此时需要重写Object invoke方法

2、使用cglib动态代理

创建子类的代理对象，增强类中的方法。

CGLib代理不要求目标类一定要实现了接口，它采用非常底层的字节码技术，可以为一个类创建子类，从而解决无接口代理问题。

（1）创建目标类，要增强的类

public class Target {
    public void method1() {
        System.out.println("method1 running ...");
}

    public void method2() {
        System.out.println("method2 running ...");
    }

    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

（2）创建代理对象 (核心类)

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class TargetProxy {

    public static <T> Object getProxy(T t) {
        Enhancer en = new Enhancer(); //帮我们生成代理对象
        en.setSuperclass(t.getClass());//设置要代理的目标类
        en.setCallback(new MethodInterceptor() {//代理要做什么
            @Override
            public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("执行方法前。。。");
                //调用原有方法  
                Object invoke = methodProxy.invokeSuper(object, args);
                // Object invoke = method.invoke(t, args);// 作用等同与上面。
                System.out.println("执行方法后。。。");
                return invoke;
            }
        });
        return en.create();
    }
}

重写：Object intercept（）方法

Enhancer en = new Enhancer(); //帮我们生成代理对象
en.setSuperclass(t.getClass());//设置要代理的目标类
en.setCallback(new MethodInterceptor() {//代理要做什么

return en.create(); 返回代理对象供调用

（3）创建测试类

public class TargetUser {

    public static void main(String[] args) {
        Target target = (Target) TargetProxy.getProxy(new Target());
        System.out.println(target.getClass().getName());
        target.method1();
    }
}