Java知识体系之动态代理

Java知识体系

代理模式

代理模式，简单来说，就是我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

举个例子：你喜欢小芳，你让小红去帮忙带话，这个小红就是代理对象，代理你去问话。

代理模式有静态代理和动态代理两种实现方式。

静态代理

静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改）且麻烦(需要对每个目标类都单独写一个代理类)。

从 JVM 层面来说，静态代理在编译期就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

例子

静态代理实现步骤:

• 定义一个接口及其实现类；
• 创建一个代理类同样实现这个接口
• 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。

// 定义发送短信的接口
public interface SmsService {
    String send(String message);
}
// 实现发送短信的接口
public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}
// 创建代理类
public class SmsProxy implements SmsService {
    private final SmsService smsService;
    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }
    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}
// 实际使用
public class Main {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.send("java");
    }
}

动态代理

动态代理更加灵活，我们不需要针对每个目标类都单独创建一个代理类，而是通过某种方式自动生成代理类。

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

动态代理的实现方式一般来说有两种：JDK 动态代理和Cglib 动态代理。

JDK动态代理

在 Java 动态代理机制中 InvocationHandler 接口和Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

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

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

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

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

public interface InvocationHandler {
    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

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

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

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

例子

JDK 动态代理类使用步骤

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

// 定义发送短信的接口
public interface SmsService {
    String send(String message);
}
// 实现发送短信的接口
public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}
// JDK 动态代理类
public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;
    public DebugInvocationHandler(Object target) {
        this.target = target;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return result;
    }
}
// 获取代理对象的工厂类
public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
        );
    }
}
// 实际使用
public class Main {
    public static void main(String[] args) {
        SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
        smsService.send("java");
    }
}

Cglib动态代理

JDK 动态代理有一个最致命的问题是针对接口。

为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。
CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。
CGLIB 通过继承方式实现代理。

JDK动态代理 VS Cglib动态代理

• JDK 动态代理只能代理接口，而 CGLIB 可以代理未实现任何接口的类。
  另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
• 就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

静态代理 VS 动态代理

• 灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类；静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！
• JVM 层面 ：静态代理在编译期就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行期动态生成类字节码，并加载到 JVM 中的。

JDK动态代理原理

SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());

我们打印一下smsService的实际类名、所实现的接口和父类的名称，得到结果如下：

类名：com.sun.proxy.$Proxy11
父类：java.lang.reflect.Proxy
实现接口：SmsService

因此，生成的代理类有如下3个特点：

1.继承了Proxy类
2.实现了我们传入的接口
3.以$Proxy+随机数字的命名

接着我们还是需要略微查看一下newProxyInstance方法的源码，只需要关心下面几行核心代码，如下：

// 代理类的构造方法参数类型数组，可见代理类的构造参数只有InvocationHandler类型
private static final Class<?>[] constructorParams = { InvocationHandler.class };
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    ...
    /**
     * 根据我们传进来的接口创建一个类
     */
    Class<?> cl = getProxyClass0(loader, intfs);
    ...
    /**
     * 找到类的构造方法，该构造方法获取一个InvocationHandler类型的参数
     */
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    ...
    /**
     * 通过构造方法生成代理类的实例
     */
    return cons.newInstance(new Object[]{h});
}

因此总结一下动态代理对象创建的过程

1.根据我们传入的接口动态地创建一个Class
2.获取类的构造函数，且该构造函数有唯一的InvocationHandler类型参数
3.将InvocationHandler作为参数传入构造函数，实例化代理对象的实例，并将其返回

当然，这里最核心的方法自然是类的创建，简而言之，就是在运行时，一个字节一个字节地构造一个字节数组，而这个字节数组正是一个.class字节码，然后通过一个native方法，将其转化为我们运行时的Class类。

再通俗一些来说：平时我们使用的类都是预先编译好的.class文件，而动态代理则是直接在运行时通过组装一个byte数组的方式创建一个.class文件，这样应该就是比较好理解了吧。

最后，我们来看一下这个生成出来的代理类究竟长啥样，正符合我们之前总结出的代理对象的3个特点。

// 注意类是final的
public final class $Proxy11 extends Proxy implements SmsService {
    private static Method m3;
    // 构造函数，参数为InvocationHandler
    public $Proxy11(InvocationHandler var1) throws  {
        super(var1);
    }
    // 方法是final
    public final String send(String var1)  {
        // 调用InvocationHandler#invoke
        return super.h.invoke(this, m3, new Object[]{var1});
    }
    static {
        try {
            m3 = Class.forName("cn.xxx.SmsService").getMethod("send", String.TYPE);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

参考

https://javaguide.cn/java/basis/proxy.html#_1-%E4%BB%A3%E7%90%86%E6%A8%A1%E5%BC%8F
https://www.cnblogs.com/tera/p/13911819.html