前言
之前已经用了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对象，然后构造其实例