Java动态代理——框架中的应用场景和基本原理

前言

之前已经用了5篇文章完整解释了java动态代理的原理，本文将会为这个系列补上最后一块拼图，展示java动态代理的使用方式和应用场景

主要分为以下4个部分

1.为什么要使用java动态代理

2.如何使用java动态代理

3.框架中java动态代理的应用

4.java动态代理的基本原理

1.为何要使用动态代理

在设计模式中有一个非常常用的模式：代理模式。学术一些来讲，就是为某些对象的某种行为提供一个代理对象，并由代理对象完全控制该行为的实际执行。

通俗来说，就是我想点份外卖，但是手机没电了，于是我让同学用他手机帮我点外卖。在这个过程中，其实就是我同学（代理对象）帮我（被代理的对象）代理了点外卖（被代理的行为），在这个过程中，同学可以完全控制点外卖的店铺、使用的APP，甚至把外卖直接吃了都行（对行为的完全控制）。

因此总结一下代理的4个要素：

代理对象

被代理的行为

被代理的对象

行为的完全控制

从实际编码的角度来说，我们假设遇到了这样一个需求，需要记录下一些方法的执行时间，于是最简单的方式当然就是在方法的开头记录一个时间戳，在return之前记录一个时间戳。但如果方法的流程很复杂，例如：

public class Executor {
    public void execute(int x, int y) {
        log.info("start：{}", System.nanoTime());
        if (x == 3) {
            log.info("end：{}", System.nanoTime());
            return;
        }
        for (int i = 0; i < 100; i++) {
            if (y == 5) {
                log.info("end：{}", System.nanoTime());
                return;
            }
        }
        log.info("end：{}", System.nanoTime());
        return;
    }
}

我们需要在每一个return前都增加一行记录时间戳的代码，很麻烦。于是我们想到可以由方法的调用者来记录时间，例如：

public class Invoker {
    private Executor executor = new Executor();

    public void invoke() {
        log.info("start：{}", System.nanoTime());
        executor.execute(1, 2);
        log.info("end：{}", System.nanoTime());
    }
}

我们又遇到一个问题，如果该方法在很多地方调用，或者需要记录的方法有多个，那么依然会面临重复手动写log代码的问题。

于是，我们就可以考虑创建一个代理对象，让它负责帮我们统一记录时间戳，例如：

public class Proxy {
    Executor executor = new Executor();

    public void execute(int x, int y) {
        log.info("start：{}", System.nanoTime());
        executor.execute(x, y);
        log.info("start：{}", System.nanoTime());
    }
}

而在Invoker中，则由直接调用Executor中的方法改为调用Proxy的方法，当然方法的名字和签名是完全相同的。当其他地方需要调用execute方法时，只需要调用Proxy中的execute方法，就会自动记录下时间戳，而对于使用者来说是感知不到区别的。如下示例：

public class Invoker {
    private Proxy executor;

    public void invoke() {
        executor.execute(1, 2);
    }
}

上面展示的代理，就是一个典型的静态代理，“静态”体现在代理方法是我们直接编码在类中的。

接着我们就遇到了下一个问题，如果Executor新增了一个方法，同样要记录时间，那我们就不得不修改Proxy的代码。并且如果其他类也有同样的需求，那就需要新建不同的Proxy类才能较好的实现该功能，同样非常麻烦。

那么我们就需要将静态代理升级成为动态代理了，而“动态”正是为了优化前面提到的2个静态代理遇到的问题。

2.如何使用java动态代理

创建java动态代理需要使用如下类

java.lang.reflect.Proxy

调用其newProxyInstance方法，例如我们需要为Map创建一个代理：

Map mapProxy = (Map) Proxy.newProxyInstance(
        HashMap.class.getClassLoader(),
        new Class[]{Map.class},
        new InvocationHandler(){...}
);

我们接着就来分析这个方法。先查看其签名：

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

ClassLoader类型的loader：被代理的类的加载器，可以认为对应4要素中的被代理的对象。

Class数组的interfaces：被代理的接口，这里其实对应的就是4要素中的被代理的行为，可以注意到，这里需要传入的是接口而不是某个具体的类，因此表示行为。

InvocationHandler接口的h：代理的具体行为，对应的是4要素中的行为的完全控制，当然也是java动态代理的核心。

最后返回的对象Object对应的是4要素中的代理对象。

接着我们来示例用java动态代理来完成记录方法执行时间戳的需求：

首先定义被代理的行为，即接口：

public interface ExecutorInterface {
    void execute(int x, int y);
}

接着定义被代理的对象，即实现了接口的类：

public class Executor implements ExecutorInterface {
    public void execute(int x, int y) {
        if (x == 3) {
            return;
        }
        for (int i = 0; i < 100; i++) {
            if (y == 5) {
                return;
            }
        }
        return;
    }
}

接着是代理的核心，即行为的控制，需要一个实现了InvocationHandler接口的类：

public class TimeLogHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
    }
}

这个接口中的方法并不复杂，我们还是先分析其签名

Object类型的proxy：最终生成的代理对象

Method类型的method：被代理的方法。这里其实是2个要素的复合，即被代理的对象是如何执行被代理的行为的。因为虽然我们说要对行为完全控制，但大部分时候，我们只是对行为增添一些额外的功能，因此依然是要利用被代理对象原先的执行过程的。

Object数组的args：方法执行的参数

因为我们的目的是要记录方法的执行的时间戳，并且原方法本身还是依然要执行的，所以在TimeLogHandler的构造函数中，将一个原始对象传入，method在调用invoke方法时即可使用。

定义代理的行为如下：

public class TimeLogHandler implements InvocationHandler {
    private Object target;

    public TimeLogHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("start：{}", System.nanoTime());
        Object result = method.invoke(target, args);
        log.info("end：{}", System.nanoTime());
        return result;
    }
}

接着我们来看Invoker如何使用代理，这里为了方便演示我们是在构造函数中实例化代理对象，在实际使用时可以采用依赖注入或者单例等方式来实例化：

public class Invoker {
    private ExecutorInterface executor;

    public Invoker() {
        executor = (ExecutorInterface) Proxy.newProxyInstance(
                Executor.class.getClassLoader(),
                new Class[]{ExecutorInterface.class},
                new TimeLogHandler(new Executor())
        );
    }

    public void invoke() {
        executor.execute(1, 2);
    }
}

此时如果Exector新增了任何方法，那么Invoker和TimeLogHandler将不需要任何改动就可以支持新增方法的的时间戳记录，有兴趣的同学可以自己尝试一下。

另外如果有其他类也需要用到时间戳的记录，那么只需要和Executor一样，通过Proxy.newProxyInstance方法创建即可，而不需要其他的改动了。

3.框架中java动态代理的应用

接着我们看一下java动态代理在现在的一些常用框架中的实际应用

Spring AOP

spring aop是我们spring项目中非常常用的功能。

例如我们在获取某个数据的时候需要先去redis中查询是否已经有缓存了，如果没有缓存再去读取数据库。我们就可以定义如下的一个切面和行为，然后在需要该功能的方法上增加相应注解即可，而不再需要每个方法单独写逻辑了。如下示例：

@Aspect
@Component
public class TestAspect {
    /**
     * 表示所有有cn.tera.aop.RedisPoint注解的方法
     * 都会执行先读取Redis的行为
     */
    @Pointcut("@annotation(cn.tera.aop.RedisPoint)")
    public void pointCut() {
    }

    /**
     * 实际获取数的流程
     */
    @Around("pointCut()")
    public Object advise(ProceedingJoinPoint joinPoint) {
        try {
            /**
             * 先去查询redis
             */
            Object data = RedisUtility.get(some_key);
            if (data == null) {
                /**
                 * joinPoint.proceed()表示执行原方法
                 * 如果redis中没有缓存，那么就去执行原方法获取数据
                 * 然后塞入redis中，下次就能直接获取到缓存了
                 */
                data = joinPoint.proceed();
                RedisUtility.put(some_key, data);
            }
            return data;
        } catch (Throwable r) {
            return null;
        }
    }
}

而其背后的原理使用的就是java动态代理。当然这里要求被注解的方法所在的类必须是实现了接口的（回想下Proxy.newProxyInstance方法的签名），否则就需要使用另外一个GCLib的库了，不过这就是另外一个故事了，这里就不展开了。

Spring AOP中大部分情况下都是给原执行逻辑添加一些东西。

RPC框架

在一些rpc框架中，客户端只需要关注接口的的调用，而具体的远程请求则由框架内部实现，例如我们模拟一个简单的rpc 请求，接口如下：

public interface OrderInterface {
    /**
     * 生成一张新订单
     */
    void addOrder();
}

rpc框架可以生成接口的代理对象，例如：

public class SimpleRpcFrame {
    /**
     * 创建一个远程请求代理对象
     */
    public static <T> T getRemoteProxy(Class<T> service) {
        return (T) Proxy.newProxyInstance(service.getClassLoader(),
                new Class<?>[]{service},
                new RpcHandler(service));
    }

    /**
     * 处理具体远程调用的类
     */
    static class RpcHandler implements InvocationHandler {
        private Class service;

        public RpcHandler(Class service) {
            this.service = service;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            /**
             * 根据接口名和方法名，发起一次特定的网络请求，获取数据
             */
            Object result = RemoteCallUtility.request(service.getName(), method.getName(), args);
            return result;
        }
    }
}

而客户端调用的时候不需要接口的具体实现，只需要通过rpc框架获取接口的代理即可，此时究竟是采用http协议或者直接通过socket请求数据都交由框架负责了，例如：

public class RpcInvoker {
    public void invoke() {
        OrderInterface order = SimpleRpcFrame.getRemoteProxy(OrderInterface.class);
        order.addOrder();
    }
}

RPC中的代理则是完全不需要原执行逻辑，而是完全地控制了行为的执行过程

那么框架使用java动态代理的示例就介绍到此。

4.java动态代理的基本原理

之前我已经通过5篇文章完整介绍了java动态代理的实现原理，不过因为实在有些晦涩，所以这里我抛弃细节代码的解析，使得大家尽量从直觉的角度来理解其基本原理。

假设我们还是实现一开始的添加时间戳的功能，此时，我们需要如下代码获取其代理：

ExecutorInterface executor = (ExecutorInterface) Proxy.newProxyInstance(
                Executor.class.getClassLoader(),
                new Class[]{ExecutorInterface.class},
                new TimeLogHandler()
        );
        executor.execute(1, 2);

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

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

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

1.继承了Proxy类

2.实现了我们传入的接口

3.以$Proxy+随机数字的命名

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

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.获取类的构造函数

3.将InvocationHandler作为参数传入构造函数，实例化代理对象的实例，并将其返回

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

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

如果对这个byte数组是如何构建的有兴趣，那么欢迎看一下我之前写的5篇文章，里面不仅介绍了动态代理的源码，还能深入了解一下class字节码更细节的结构

1.https://www.cnblogs.com/tera/p/13267630.html

2.https://www.cnblogs.com/tera/p/13280547.html

3.https://www.cnblogs.com/tera/p/13336627.html

4.https://www.cnblogs.com/tera/p/13419025.html

5.https://www.cnblogs.com/tera/p/13442018.html

最后，我们来看一下这个生成出来的代理类究竟长啥样，正符合我们之前总结出的代理对象的3个特点（在之前的文章中也有展示如何看到该内容）。特别注意的是因为所有的类都是继承自Object，因此除了我们自己接口中定义的方法，还会有Object类的种的方法：

public final class $Proxy11 extends Proxy implements ExecutorInterface {
    private static Method m1;
    private static Method m2;
    private static Method m0;
    private static Method m3;

    public $Proxy11(InvocationHandler var1) throws  {
        super(var1);
    }

    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);
        }
    }

    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);
        }
    }

    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);
        }
    }

    public final void execute(int var1, int var2) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("cn.tera.aopproxy.proxyuse.ExecutorInterface").getMethod("execute", Integer.TYPE, Integer.TYPE);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

到此，java动态代理的基本介绍就结束了

最后我们总结一下java动态代理的思想和原理

1.代理的4要素：代理对象、被代理的行为、被代理的对象、行为的完全控制

2.代理的应用：方便地为某些行为添加一些共同的逻辑（Spring AOP）或者是将行为的执行完全交由代理控制（RPC）

3.java动态代理的原理：在运行时构建一个class字节码数组，并将其转换成一个运行时的Class对象，然后构造其实例