静态代理、jdk动态代理、cglib动态代理

【文档】
https://github.com/Snailclimb/JavaGuide/blob/main/docs/java/basis/%E4%BB%A3%E7%90%86%E6%A8%A1%E5%BC%8F%E8%AF%A6%E8%A7%A3.md

静态代理

/*
/**
 * 静态代理
 * 
 * 步骤：
 *  1.定义一个接口及其实现类；
 *  2.创建一个代理类同样实现这个接口
 *  3.将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。
 *
 * 优点：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件
 *
 * 缺点：比如接口一旦新增加方法，目标对象和代理对象都要进行修改）且麻烦(需要对每个目标类都单独写一个代理类)
 *
 * @author zhannan
 * @version SendMessageInterfaceProxy.java, v 0.1 2021年11月18日 20:44 zhannan
 */
public class SendMessageInterfaceProxy implements SendMessageInterface {

    private SendMessageInterface sendMessageInterface;

    public SendMessageInterfaceProxy(SendMessageInterface sendMessageInterface){
        this.sendMessageInterface = sendMessageInterface;
    }

    @Override
    public String sendMessage(String message) {
        System.out.println("static proxy start to send message : " + message);
        sendMessageInterface.sendMessage(message);
        System.out.println("static proxy end to send message : " + message);
        return null;
    }

    public static void main(String[] args) {
        SendMessageInterfaceProxy proxy = new SendMessageInterfaceProxy(new SendMessageInterfaceImpl());
        proxy.sendMessage("hello mimi");
    }
}

output：

static proxy start to send message : hello mimi
sendMessage：hello mimi
static proxy end to send message : hello mimi

动态代理

相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类( CGLIB 动态代理机制)。

从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

说到动态代理，Spring AOP、RPC 框架应该是两个不得不提的，它们的实现都依赖了动态代理。

动态代理在我们日常开发中使用的相对较少，但是在框架中的几乎是必用的一门技术。学会了动态代理之后，对于我们理解和学习各种框架的原理也非常有帮助。

就 Java 来说，动态代理的实现方式有很多种，比如 JDK 动态代理、CGLIB 动态代理等等。

JDK动态代理

核心是Proxy 类和InvocationHandler 接口，jdk动态代理只能代理已实现接口的类。
【步骤】

• 定义一个接口及其实现类；
• 自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
• 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

【Proxy类】
Proxy类中的newProxyInstance() 这个方法主要用来生成一个代理对象：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    ......
}

这个方法一共有 3 个参数：

• loader :类加载器，用于加载代理对象。
• interfaces : 被代理类实现的一些接口；
• h : 实现了 InvocationHandler 接口的对象；

【InvocationHandler 接口】
要实现动态代理的话，必须需要实现InvocationHandler 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

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

/**
 * @author zhannan
 * @version SendMessageInvocationHandler.java, v 0.1 2021年11月18日 21:20 zhannan
 */
public class SendMessageInvocationHandler implements InvocationHandler {

    /**
     * 代理类中的真实对象
     */
    private Object targetObject;

    public SendMessageInvocationHandler(Object targetObject) {
        this.targetObject = targetObject;
    }


    /**
     * invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。
     *
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("jdk proxy start to do, method: " + method.getName());
        Object result = method.invoke(targetObject, args);
        System.out.println("jdk proxy end to do, method: " + method.getName());
        return result;
    }
}

invoke() 方法有下面三个参数：

• proxy :动态生成的代理类
• method : 与代理类对象调用的方法相对应
• args : 当前 method 方法的参数

也就是说：你通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

【获取代理对象的工厂类】

/*
 * Ant Group
 * Copyright (c) 2004-2021 All Rights Reserved.
 */
package com.alipay.insttrade.biz.service.impl.facade;

import java.lang.reflect.Proxy;

/**
 * 获取代理对象的工厂类
 * @author zhannan
 * @version JdkProxyFactory.java, v 0.1 2021年11月18日 21:27 zhannan
 */
public class JdkProxyFactory {
    public static Object getJdkProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new SendMessageInvocationHandler(target));   // 代理对象对应的自定义 InvocationHandler
    }
}

【实际使用】

public static void main(String[] args) {
    SendMessageInterface sendMessageInterface = (SendMessageInterface)JdkProxyFactory.getJdkProxy(new SendMessageInterfaceImpl());
    sendMessageInterface.sendMessage("hello mimi");
}

output：

jdk proxy start to do, method: sendMessage
sendMessage：hello mimi
jdk proxy end to do, method: sendMessage

CGLIB 动态代理

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。

很多知名的开源框架都使用到了CGLIB， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中核心是： MethodInterceptor 接口和 Enhancer 类

你需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

不同于 JDK 动态代理不需要额外的依赖。CGLIB(Code Generation Library) 实际是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖。

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>

【步骤】

• 定义一个类；
• 自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
• 通过 Enhancer 类的 create()创建代理类；

【重写MethodInterceptor类】

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author zhannan
 * @version SendMessageMethodInterceptor.java, v 0.1 2021年11月18日 21:54 zhannan
 */
public class SendMessageMethodInterceptor implements MethodInterceptor {
    /**
     * @param o           代理对象（增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("jdk proxy start to do, method: " + method.getName());
        Object result = methodProxy.invokeSuper(o, args);
        System.out.println("jdk proxy end to do, method: " + method.getName());
        return result;
    }
}

【用Enhancer获取代理对象的代理工厂】

import net.sf.cglib.proxy.Enhancer;

/**
 * 获取代理对象的工厂类
 *
 * @author zhannan
 * @version JdkProxyFactory.java, v 0.1 2021年11月18日 21:27 zhannan
 */
public class CglibProxyFactory {
    public static Object getJdkProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new SendMessageMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

【实际使用】

//可以发现这里直接给SendMessageService.class就行，而不需要接口的实现类，任何类都可以
public static void main(String[] args) {
    SendMessageService sendMessageService = (SendMessageService) CglibProxyFactory.getJdkProxy(SendMessageService.class);
    sendMessageService.sendMessage("hello mimi");
}

output：

jdk proxy start to do, method: sendMessage
sendMessage：hello mimi
jdk proxy end to do, method: sendMessage

各类对比

【静态代理和动态代理的对比】
灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！

JVM 层面 ：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

【JDK 动态代理和 CGLIB 动态代理对比】
JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。

就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。