JDK动态代理和Cglib动态代理原理与区别

2.2动态代理实现

2.2.1JDK动态代理实现

只能针对接口进行代理

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

        //目标对象
        Targer targer = new Targer();

        //当前类的类加载器
        ClassLoader loader = JDKProxy.class.getClassLoader();

        //Proxy.newProxyInstance : 创建一个新的代理实例,运行期间生成代理类的字节码
        /*
                参数说明：
                loader 加载代理类在运行期间动态生成的字节码
                new Class[]可以代理多个Foo接口
                对行为进行封装
         */
        Foo proxy = (Foo)Proxy.newProxyInstance(loader, new Class[]{Foo.class}, new InvocationHandler() {
            //参数说明：代理对象自己、正在执行的方法对象、方法传来的实际参数
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("before...");
                //目标 方法(参数)
                //方法反射调用目标对象
                //目标对象 和 参数
                Object result = method.invoke(targer, args);
                //让代理也返回目标方法执行的结果
                System.out.println("after...");
                return result;
            }
        });

        //调用代理的父方法
        proxy.foo();
    }
    interface Foo{
        void foo();
    }

    static class Targer implements Foo{

        @Override
        public void foo() {
            System.out.println("target foo");
        }
    }
}

• 代理类和目标类是兄弟关系，所以目标类可以被final修饰

原理：

以下是一个半成品的proxy，可以看到实现的方式很巧妙

• 调用类

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author 我见青山多妩媚
 * @date 2023/4/15 0015 16:06
 * @Description TODO
 */
public class Proxy$0 {
    interface Foo{
        int foo();

        void bar();
    }

    static class Target implements Foo {

        @Override
        public int foo() {
            System.out.println("target foo");
            return 1;
        }

        @Override
        public void bar() {
            System.out.println("bar foo");
        }
    }

    public static void main(String[] args) {
        Foo proxy = new $Proxy0(new InvocationHandler() {
            @Override
            public Object invoke(Object proxy,Method method,Object[] args) throws InvocationTargetException, IllegalAccessException {
                //1.实现功能增强
                System.out.println("before...");
                //2.调用目标
//                new Target().foo();
                //反射调用
                return method.invoke(new Target(),args);
            }
        });
        proxy.foo();
        proxy.bar();
    }

    //抽象成一个代理接口，所有代理的方法就不用写在代理内内部，具体实现具体做，不会写死，成为动态代理
    interface InvocationHandler{
        public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
    }

}

• 代理类

import com.example.springreaddemo.SpringRead.Demo02_SpringAop.proxy.JDK.Proxy$0.Foo;
import com.example.springreaddemo.SpringRead.Demo02_SpringAop.proxy.JDK.Proxy$0.InvocationHandler;

import java.lang.reflect.Method;
import java.lang.reflect.UndeclaredThrowableException;

/**
 * @author 我见青山多妩媚
 * @date 2023/4/15 0015 15:59
 * @Description TODO
 */
//JDK 代理类
public class $Proxy0 implements Foo  {
    private InvocationHandler invocationHandler;

    public $Proxy0(InvocationHandler invocationHandler){
        this.invocationHandler = invocationHandler;
    }

    @Override
    public int foo() {
        try {
            //将foo的方法 以及 方法参数传过去,调用foo方法
            Object invoke = invocationHandler.invoke(this,foo, new Object[0]);
            return (int)invoke;
        } catch (RuntimeException | Error e) {  //运行时异常直接抛出
            throw e;
        } catch (Throwable e){
            throw new UndeclaredThrowableException(e);  //检查异常转化为运行异常抛出
        }
    }

    @Override
    public void bar() {
        try {
            //将foo的方法 以及 方法参数传过去,调用bar方法
            invocationHandler.invoke(this,bar,new Object[0]);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

    static Method foo;
    static Method bar;
    static {
        try {
            foo = Foo.class.getMethod("foo");
            bar = Foo.class.getMethod("bar");
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());  //比较严重的问题
        }
    }

}

JDK生成的代理类，不会有源码阶段，直接到字节码，这个动态生成代理类并且直接到字节码的方式叫ASM

2.2.2cglib代理实现

与JDK不同，可以针对很对进行代理

public class CglibProxy {

    static class Target{
        public void foo(){
            System.out.println("target foo...");
        }
    }

    public static void main(String[] args) {
        Target target = new Target();


        Target proxy = (Target)Enhancer.create(Target.class, new MethodInterceptor() {
            @Override
            /*
                参数：
                        1.o 代理类自己
                        2.method 代理类内执行的方法
                        3.objects 参数
                        4.方法对象，和method参数有些区别
             */
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("before...");
//                method.invoke(target,objects);  //方法反射调用目标
                //methodProxy 可以避免反射调用 内部没有用反射
//                Object result = methodProxy.invoke(target, objects);  //需要目标才能调用自己  spring使用的是这个
                Object result = methodProxy.invokeSuper(o, objects);    //内部没有用反射，需要代理
                System.out.println("after...");
                return result;
            }
        });

        proxy.foo();
    }
}

• 代理类是目标类的子类，所以目标类不能被final修饰，

• 因为是代理，相当于是对目标类的方法重写，所以方法也不能被final修饰

内部实现：

我们知道cglib是根据继承实现的，我们这有个父类

• Target

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

    public void save(int i){
        System.out.println(i+"save");
    }

    public void save(long i){
        System.out.println("save long");
    }
}

• Proxy

public class Proxy extends Target {

    private MethodInterceptor methodInterceptor;

    public void setMethodInterceptor(MethodInterceptor methodInterceptor){
        this.methodInterceptor = methodInterceptor;
    }

    static Method save0;
    static Method save1;
    static Method save2;

    static MethodProxy save0Proxy;
    static MethodProxy save1Proxy;
    static MethodProxy save2Proxy;


    static {
        try {
            save0 = Target.class.getMethod("save");
            save1 = Target.class.getMethod("save", int.class);
            save2 = Target.class.getMethod("save", long.class);

            //参数：
            //目标对象
            //代理对象
            //方法参数描述符
            //带增强功能的方法
            //带原始功能的方法
            save0Proxy = MethodProxy.create(Target.class,Proxy.class,"()V","save","saveSuper");
            //参数类型为整型
            save1Proxy = MethodProxy.create(Target.class,Proxy.class,"(I)V","save","saveSuper");
            //长整型为大写J
            save2Proxy = MethodProxy.create(Target.class,Proxy.class,"(J)V","save","saveSuper");
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }

    //代理原始功能的方法
    public void saveSuper(){
        super.save();
    }

    public void saveSuper(int i){
        super.save(i);
    }

    public void saveSuper(long i){
        super.save(i);
    }


    //属于待增强功能的方法
    @Override
    public void save() {
        try {
            methodInterceptor.intercept(this,save0,new Object[0],save0Proxy);
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    @Override
    public void save(int i) {
        try {
            methodInterceptor.intercept(this,save1,new Object[]{i},save1Proxy);
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    @Override
    public void save(long i) {
        try {
            methodInterceptor.intercept(this,save2,new Object[]{i},save2Proxy);
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }
}

• Main

public class Main {
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        Target target = new Target();
        proxy.setMethodInterceptor(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects,
                                    MethodProxy methodProxy) throws Throwable {
                System.out.println("before...");
                //内部有反射
//                return method.invoke(target,objects);
                //内部无反射调用 结合目标使用
//                return methodProxy.invoke(target,objects);
                //内部无反射
                return methodProxy.invokeSuper(o,objects);
            }
        });
        proxy.save();
        proxy.save(1);
        proxy.save(2L);
    }
}

内部实现，和jdk的区别，他可以做到不使用反射进行动态的代理

不使用反射调用的原理：

package com.example.springreaddemo.SpringRead.Demo02_SpringAop.proxy.Cglib;

import org.springframework.cglib.core.Signature;

/**
 * @author 我见青山多妩媚
 * @date 2023/4/16 0016 20:21
 * @Description TODO
 */
//desc 不用反射实现代理的原理
public class TargetFastClass {

    //将目标对象的方法对应为三个签名
    static Signature s0 = new Signature("save","()V");
    static Signature s1 = new Signature("save","(I)V");
    static Signature s2 = new Signature("save","(J)V");


    /**
     * 根据方法的前面信息，获取目标方法的编号
     *
     * save             0
     * save(int i)      1
     * save(long i)     2
     * @param signature 签名 包括方法的名字、参数、返回值等等
     * @return 编号
     */
    public int getIndex(Signature signature){
        if(s0.equals(signature)){
            return 0;
        }else if (s1.equals(signature)){
            return 1;
        }else if(s2.equals(signature)){
            return 2;
        }else {
            return -1;
        }
    }

    /**
     * 根据获取到的方法编号，调用目标对象中的方法
     * @param index 编号
     * @param target 目标对象
     * @param args 参数列表
     * @return 返回目标对象
     */
    public Object invoke(int index,Object target,Object[] args){
         if(index == 0){
             ((Target) target).save();
             return null;
         }else if(index == 1){
             ((Target) target).save((int) args[0]);
             return null;
         }else if(index == 2){
             ((Target) target).save((long) args[0]);
             return null;
         }else{
             throw new RuntimeException("无此方法");
         }
    }
}

MethodProxy内部不使用反射的原理：

public class ProxyFastClass {
    //将目标对象的方法对应为三个签名
    static Signature s0 = new Signature("saveSuper","()V");
    static Signature s1 = new Signature("saveSuper","(I)V");
    static Signature s2 = new Signature("saveSuper","(J)V");


    /**
     * 根据方法的前面信息，获取目标方法的编号
     *
     * save             0
     * save(int i)      1
     * save(long i)     2
     * @param signature 签名 包括方法的名字、参数、返回值等等
     * @return 编号
     */
    public int getIndex(Signature signature){
        if(s0.equals(signature)){
            return 0;
        }else if (s1.equals(signature)){
            return 1;
        }else if(s2.equals(signature)){
            return 2;
        }else {
            return -1;
        }
    }

    /**
     * 根据获取到的方法编号，调用目标对象中的方法
     * @param index 编号
     * @param proxy 代理对象
     * @param args 参数列表
     * @return 返回目标对象
     */
    public Object invoke(int index,Object proxy,Object[] args){
        if(index == 0){
            ((Proxy) proxy).saveSuper();
            return null;
        }else if(index == 1){
            ((Proxy) proxy).saveSuper((int) args[0]);
            return null;
        }else if(index == 2){
            ((Proxy) proxy).saveSuper((long) args[0]);
            return null;
        }else{
            throw new RuntimeException("无此方法");
        }
    }

    public static void main(String[] args) {
        ProxyFastClass proxyFastClass = new ProxyFastClass();
        int index = proxyFastClass.getIndex(new Signature("saveSuper", "()V"));
        System.out.println(index);
        proxyFastClass.invoke(index,new Proxy(),new Object[0]);
    }
}

实际上就是调用了代理类

区别

jdk在调用第17次时一个方法生成一个代理类，而cglib会给生成一个代理类，对应两个fastClass，一个对应目标代理，一个对代理类代理，生成的代理类数目比jdk少