动态代理概述

动态代理是相对静态代理而言。静态代理是代理类在代码运行前已经创建好，并生成class文件；动态代理类是指代理类在程序运行时创建的代理模式。动态代理类的代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成。
相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。 在实际调用中，根本不关心代理类的创建与销毁，使用动态代理不仅可以屏蔽代理类的编写。
在说明代理前，先介绍几个基本概念：

委托类，指的是代理模式中的被代理对象
代理类，指的是生成的代表委托类的一个角色

静态代理

静态代理是代理类在编译期间就创建好了，注意，这里的代理类不是编译器生成的代理类，而是手动创建的类。在编译时就已经将接口，被代理类，代理类等确定下来。其实现主要分以下四个步骤：
(1) 定义需要代理的接口并声明接口方法；
(2) 定义上述接口的实现类，也即委托类；
(3) 定义代理类，实现上述接口，接口方法通过转调委托类实例的方法实现；
(4) 创建代理类实例，实现接口调用。
示例代码如下：
(1) 定义接口

public interface ICustomService {
    String sayHello(String str);
}

(2) 定义委托类

public class CustomService implements ICustomService {
    @Override
    public String sayHello(String str) {
        return "Hello " + str;
    }
}

(3) 定义代理类

public class CustomServiceStaticProxy implements ICustomService {
    private CustomService customService = new CustomService();

    @Override
    public String sayHello(String str) {
        return customService.sayHello(str);
    }
}

(4) 创建代理类实例并转调接口

public class CustomServiceStaticProxyTest {
    @Test
    public void sayHello() {
        CustomServiceStaticProxy customServiceStaticProxy = new CustomServiceStaticProxy();
        Assert.assertEquals("Hello World", customServiceStaticProxy.sayHello("World"));
    }
}

代理类持有委托类的实例，代为执行具体类实例方法。代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。这里的间接性就是指客户端不直接调用实际对象的方法，客户端依赖公共接口并使用代理类。 那么我们在代理过程中就可以加上一些其他用途。 代理类存在的意义是为了增加一些公共的逻辑代码。代理类可以解除方法间的依赖，并可实现方法增强。

动态代理

动态代理的常见实现方式有两种：JDK动态代理和CGLIB动态代理。JDK动态代理技术生成的代理类（$Proxy0 extends Proxy implements XXX）时，继承了Proxy类，所以JDK动态代理类们无法实现对类的动态代理。如果需要实现对类的动态代理，可以使用CGlib技术。

JDK动态代理

JDK为实现动态代理，在java的java.lang.reflect包中提供了Proxy类和InvocationHandler接口。其中，类Proxy定义了生成JDK动态代理类的方法 getProxyClass(ClassLoader loader,Class… interfaces)生成动态代理类，返回class实例代表一个class文件。可以保存该 class 文件查看jdk生成的代理类文件。InvocationHandler接口是被动态代理类回调的接口，我们所有需要增加的针对委托类的统一处理逻辑都增加到invoke方法里面，在调用委托类接口方法之前或之后实现自定义功能。JDK动态代理主要有以下四个步骤：
(1) 定义需要代理的接口并声明接口方法；
(2) 定义上述接口的实现类，也即委托类；
(3) 实现InvocationHandler接口并新增newProxyInstance方法；
(4) 创建InvocationHandler实现类的实例，并转调接口。
注意，在动态代理中，没有手动创建代理类的代码，这是与静态代理的本质区别。
示例代码如下：
(1) 定义接口

public interface ICustomService {
    String sayWorld(String str);
}

(2) 定义委托类

public class CustomService implements ICustomService {
    @Override
    public String sayWorld(String str) {
        String result = str + " " + "World";
        System.out.println(result);
        return result;
    }
}

(3) 实现InvocationHandler接口并新增newProxyInstance方法

public class CustomServiceInvocationHandler implements InvocationHandler {
    /**
     * 中间类持有委托类对象的引用,这里会构成一种静态代理关系
     */
    private Object obj ;

    /**
     * 有参构造器,传入委托类的对象
     * @param obj 委托类的对象
     */
    public CustomServiceInvocationHandler(Object obj) {
        this.obj = obj;
    }

    /**
     * 动态生成代理类对象,Proxy.newProxyInstance
     * @return 返回代理类的实例
     */
    public Object newProxyInstance() {
        return Proxy.newProxyInstance(
                // 指定代理对象的类加载器
                obj.getClass().getClassLoader(),
                // 代理对象需要实现的接口，可以同时指定多个接口
                obj.getClass().getInterfaces(),
                // 方法调用的实际处理者，代理对象的方法调用都会转发到这里
                this
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invoke before");
        Object result = method.invoke(this.obj, args);
        // 死循环
        // https://blog.csdn.net/jilindaxue/article/details/105156989
        // Object result = method.invoke(proxy, args);
        System.out.println("invoke after");
        return result;
    }
}

(4) 创建InvocationHandler实现类的实例，并转调接口

public class Main {
    public static void main(String[] args) {
        CustomServiceInvocationHandler proxyInvocationHandler = new CustomServiceInvocationHandler(new CustomService());
        // 动态创建代理对象
        ICustomService customService = (ICustomService) proxyInvocationHandler.newProxyInstance();
        customService.sayWorld("Hello");
    }
}

在基于JDK动态代理创建对象过程可分为以下四个步骤：
1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(…);
2、通过为Proxy类指定ClassLoader对象和一组interface代理类需要实现的接口，创建动态代理类类文件，默认JDK并不会保存这个文件到文件中；可以保存起来观察生成的代理类结构Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…});
3、通过上面新建的代理clazz的反射机制获取动态代理类的一个构造函数，其构造函数入参类型是调用处理器接口(IvocationHandler)类型 Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4、通过构造函数实例创建代理类实例，此时需将调用处理器对象作为参数被传入 Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
为了简化对象创建过程，Proxy类中的newInstance工具方法封装了2~4，只需两步即可完成代理对象的创建。

CGLIB动态代理

CGLIB(Code Generation Library)是一个功能强大，高性能的方案。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。在实现动态代理时，优先使用Java的动态代理机制创建代理，但当要代理的对象是类或者为了更好的性能，CGLIB是一个好的选择。
简言之，JDK动态代理技术只能实现接口代理，无法实现类代理。CGLIB可实现类代理。注意，因为CGLIB采用的是继承，所以不能对final修饰的类进行代理。final修饰的类不可继承。同样的，对于私有方法，因为不可继承，所以也无法实现动态代理。
在使用CGLIB实现动态代理前，需要引入CGLIB的jar包。使用Maven方式引入如下：

<dependency>
    <groupId>cglibgroupId>
    <artifactId>cglibartifactId>
    <version>3.3.0version>
dependency>

使用CGLIB实现动态代理主要由以下三个步骤：
(1) 定义需要代理的类，也即委托类；
(2) 实现MethodInterceptor接口并新增CglibProxyFactory方法（封装增强器的实例化）；
(3) 创建MethodInterceptor接口实现类的实例，并转调接口。
示例代码如下：
(1) 定义委托类

public class CustomService {
    public String sayHelloWorld(String somebody) {
        return "Hello World to " + somebody;
    }
}

(2) 实现MethodInterceptor接口

public class CglibMethodInterceptor implements MethodInterceptor {
    public Object CglibProxyFactory(Class target) {
        // 创建加强器，用来创建动态代理类
        Enhancer enhancer = new Enhancer();
        // 设置委托类
        enhancer.setSuperclass(target);
        // 设置方法拦截器回调引用，对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept() 方法进行拦截
        enhancer.setCallback(this);
        // 创建代理类
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("before");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("after");
        return result;
    }
}

(3) 创建MethodInterceptor接口实现类的示例并转调接口

public class Main {
    public static void main(String[] args) {
        // 方式一：创建加强器，用来创建动态代理类
        Enhancer enhancer = new Enhancer();        // 为代理类指定需要代理的类，也即是父类
        enhancer.setSuperclass(CustomService.class);        // new 一个新的方法拦截器
        CglibMethodInterceptor cglibMethodInterceptor = new CglibMethodInterceptor();       // 设置方法拦截器回调引用，对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept() 方法进行拦截
        enhancer.setCallback(cglibMethodInterceptor);        // 获取动态代理类对象并返回
        CustomService customService = (CustomService) enhancer.create();
        System.out.println(customService.sayHelloWorld("You"));

        // 方式二： new 一个新的方法拦截器，该拦截器还封装一个用于创建代理类的方法
        cglibMethodInterceptor = new CglibMethodInterceptor();
        customService = (CustomService) cglibMethodInterceptor.CglibProxyFactory(CustomService.class);
        System.out.println(customService.sayHelloWorld("You"));
    }
}

CGlib可以传入接口也可以传入普通的类，接口使用实现的方式,普通类使用会使用继承的方式生成代理类。
由于是继承方式，如果是static方法，private方法，final方法等描述的方法是不能被代理的。
做了方法访问优化，使用建立方法索引的方式避免了传统JDK动态代理需要通过Method方法反射调用。
提供callback 和filter设计，可以灵活地给不同的方法绑定不同的callback。编码更方便灵活。
CGLIB会默认代理Object中equals，toString，hashCode，clone等方法。比JDK代理多了clone。

静态代理、JDK动态代理、CGLIB动态代理说明

静态代理是通过在代码中显式编码定义一个业务实现类的代理类，在代理类中对同名的业务方法进行包装，用户通过代理类调用被包装过的业务方法；
JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；
CGLIB动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理；
静态代理在编译时产生class字节码文件，可以直接使用，效率高。
JDK动态代理和CGLIB代理区别：
JDK动态代理必须实现InvocationHandler接口，通过invoke调用被委托类接口方法是通过反射方式，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
CGLIB代理无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题，但CGLIB会继承目标对象，需要重写方法，所以目标对象不能为final类。

参考

https://www.cnblogs.com/sandaman2019/p/12636727.html
https://cloud.tencent.com/developer/article/1461796
https://www.runoob.com/w3cnote/cglibcode-generation-library-intro.html

原创不易，如果本文对您有帮助，欢迎关注我，谢谢 ~_~