Spring中JDK与Cglib动态代理的区别

靠Spring吃饭的小伙伴一定经常听说动态代理这个词，没错，Aop就是靠它来实现的。Spring提供了两种代理模式：JDK动态代理、Cglib动态代理，供我们选择，那他们有啥区别呢？Sping为啥不自己从中挑选一个作为代理模式呢？还让我们选干啥，这不是给我们增加负担嘛

要搞懂为啥Spring不自己选（其实Spring现在也会自己推断用哪种代理方式，但我们也可以指定代理模式），那还得从JDK、Cglib动态代理的实现方式说起：
（1）JDK动态代理：会生成一个代理类，这个代理类实现了被代理类上的所有接口，代理类的每个方法都是空壳方法，在方法内部调用invoke方法来执行实际操作，类似于请求转发。
（2）Cglib动态代理：同样会生成一个代理类，这个代理类继承被代理类，并且重写被代理类的方法（不能是final修饰的方法，这也是Cglib不同通用的原因之一），代理类的每个方法都是空壳方法，在方法内部调用invoke方法来执行实际操作。
一、源码分析

1. 源码
   1.1 接口Bird

interface Bird{  // 我们想要代理的接口类，大鸟
    void fly();
}

1.2 接口的实现类HuangLi

class HuangLi implements Bird{
    @Override
    public final void fly() {
        System.out.println("黄鹂fly()...");
    }
    public void sound(){
        System.out.println("黄鹂sound()...");
    }
}

1.3 方法的执行处理器 JdkProxyHuangLiInvocation

public class JdkProxyHuangLiInvocation implements InvocationHandler {
    private Object target;
    public JdkProxyHuangLiInvocation(Object target){
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 我们需要增强的功能
        System.out.println("doBefore...");
        Object result = method.invoke(target, args);
        System.out.println("doAfter..");
        return result;
    }
}

1.4 主类 MyJdkDynamicProxy

public class MyJdkDynamicProxy {
    public static void main(String[] args) {
    //    让jdk把生成的jdk动态代理类保存到文件中
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles",true);
        // 1. JDK动态代理
        HuangLi huangLi = new HuangLi(); // 需要被代理的对象
         // JDK动态代理， 只能代理某个接口,但可以代理final修饰的方法
        Bird huangLiProxy = (Bird)Proxy.newProxyInstance(huangLi.getClass().getClassLoader(),
                huangLi.getClass().getInterfaces(), new JdkProxyHuangLiInvocation(huangLi));
        huangLiProxy.fly();
        // huangLiProxy.sound();

   //  2. cglib动态代理
        // 继承HuangLi这个类的同时，实现了HuangLi这个类实现的接口
        // 由于cglib 是通过继承重写父类的方法实现的，所以代理不了被final修饰的方法
        // 如果调用fianl方法将直接调用被代理对象的方法，而不走代理逻辑
        // Cglib动态代理,
//        HuangLi cglibProxy = (HuangLi) Enhancer.create(huangLi.getClass(), huangLi.getClass().getInterfaces(), new InvocationHandler() {
//            @Override
//            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
//                System.out.println("doBefore...");
//                Object result = method.invoke(huangLi, args);
//                System.out.println("doAfter..");
//                return result;
//            }
//        });
//        cglibProxy.fly();
//        cglibProxy.sound();
    }
}

2. 所自动生成的代理类
   2.1 JDK动态代理所生成字节码

// 继承Proxy，同时实现Bird接口
final class $Proxy0 extends Proxy implements Bird {
// 会被调用的Method对象
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
    // 将 执行处理器传给父类Proxy的h属性
        super(var1);
    }
    // 空壳方法，转发到invocationHandler.invoke方法
    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
   // 空壳方法，转发到invocationHandler.invoke方法
    public final void fly() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
   // 空壳方法，转发到invocationHandler.invoke方法
    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
   // 空壳方法，转发到invocationHandler.invoke方法
    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
        // jdk通过反射可以确定我们需要用到哪些方法，然后拿到对应的Method对象
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.anhui.service.demo.proxy.Bird").getMethod("fly");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

2.2 Cglib动态代理

public class HuangLi$$EnhancerByCGLIB$$fdee7116 extends HuangLi implements Bird, Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private InvocationHandler CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$sound$0;
    private static final Method CGLIB$equals$1;
    private static final Method CGLIB$toString$2;
    private static final Method CGLIB$hashCode$3;
    private static final Method CGLIB$clone$4;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$sound$0 = Class.forName("com.anhui.service.demo.proxy.HuangLi").getDeclaredMethod("sound");
        CGLIB$equals$1 = Class.forName("java.lang.Object").getDeclaredMethod("equals", Class.forName("java.lang.Object"));
        CGLIB$toString$2 = Class.forName("java.lang.Object").getDeclaredMethod("toString");
        CGLIB$hashCode$3 = Class.forName("java.lang.Object").getDeclaredMethod("hashCode");
        CGLIB$clone$4 = Class.forName("java.lang.Object").getDeclaredMethod("clone");
    }
    
   //   sound方法被以重写的方式代理了
   //  而 fly方法被final修饰了，无法被代理=》调用代理对象的 fly()方法将不会走代理逻辑
    public final void sound() {
        try {
            InvocationHandler var10000 = this.CGLIB$CALLBACK_0;
            if (var10000 == null) {
                CGLIB$BIND_CALLBACKS(this);
                var10000 = this.CGLIB$CALLBACK_0;
            }
            var10000.invoke(this, CGLIB$sound$0, new Object[0]);
        } catch (Error | RuntimeException var1) {
            throw var1;
        } catch (Throwable var2) {
            throw new UndeclaredThrowableException(var2);
        }
    }





}