Java中静态、动态代理的实现

前言

什么是代理,在Design patterns In java这个本书中是这样描述的，简单的说就是为某个对象提供一个代理，以控制对这个对象的访问。在不修改源代码的基础上做方法增强,代理是一种设计模式，又简单的分为两种。

静态代理:代理类和委托类在代码运行前关系就确定了,也就是说在代理类的代码一开始就已经存在了。
动态代理:动态代理类的字节码在程序运行时的时候生成。


静态代理

先来看一个静态代理的例子，Calculator是一个计算器的接口类，定义了一个加法的接口方法，由CalculatorImpl类实现真正的加法操作.现在如果我们想对这个方法做一层静态的代理，这儿实现了一个简单的代理类实现了计算接口Calculator，构造函数传入的参数是真正的实现类，但是在调用这个代理类的add方法的时候我们在CalculatorImpl的实现方法执行的前后分别做了一些操作。这样的代理方式就叫做静态代理(可以理解成一个简单的装饰模式)。

很明显静态代理的缺点,由于我们需要事先实现代理类,那么每个方法我都都需要去实现。如果我们要实现很多的代理类,那么工作量就太大了。动态代理的产生就是这样而来的。

public interface Calculator {
//需要代理的接口
public int add(int a,int b);
//接口实现类,执行真正的a+b操作
public static class CalculatorImpl implements Calculator{
@Override
public int add(int a, int b) {
System.out.println("doing ");
return a+b;
}
}
//静态代理类的实现.代码已经实现好了.
public static class CalculatorProxy implements Calculator{
private Calculator calculator;
public CalculatorProxy(Calculator calculator) {
this.calculator=calculator;
}
@Override
public int add(int a, int b) {
//执行一些操作
System.out.println("begin ");
int result = calculator.add(a, b);
System.out.println("end ");
return result;
}
}
}


动态代理

使用动态代理可以让代理类在程序运行的时候生成代理类，我们只需要为一类代理写一个具体的实现类就行了，所以实现动态代理要比静态代理简单许多，省了不少重复的工作。在JDK的方案中我们只需要这样做可以实现动态代理了。

public class ProxyFactory implements InvocationHandler {
private Class<?> target;
private Object real;
//委托类class
public ProxyFactory(Class<?> target){
this.target=target;
}
//实际执行类bind
public Object bind(Object real){
this.real=real;
//利用JDK提供的Proxy实现动态代理
return Proxy.newProxyInstance(target.getClassLoader(),new Class[]{target},this);
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
//代理环绕
System.out.println("begin");
//执行实际的方法
Object invoke = method.invoke(real, args);
System.out.println("end");
return invoke;
}

public static void main(String[] args) {
Calculator proxy =(Calculator) new ProxyFactory(Calculator.class).bind(new Calculator.CalculatorImpl());
proxy.add(1,2);
}
}
利用JDK的proxy实现代理动态代理，有几个关键点，一个就是InvocationHandler接口，这个方法中的invoke方法是执行代理时会执行的方法。所以我们所有代理需要执行的逻辑都会写在这里面,invo参数里面的method可以使用java 反射调用真实的实现类的方法，我们在这个方法周围做一些代理逻辑工作就可以了。上面的代码会把Calculator接口的所有方法全部在程序运行时代理。不用我们一个个的去写静态代理的方法。

JDK动态代理的原理

先看Proxy.newProxyInstance(...)方法中的具体实现(省略大部分方法)。在下面的代码中会通过getProxyClass0(…)方法得到class对象，然后给把InvocationHandler已构造参数实例化代理对象。思路还是挺清晰的,但是如果要一探究竟我们还是得知道代理对象到底是什么样的，如何实现的代理呢？

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException
{
//......
/*
*得到代理的对象的class对象。
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* 给class 对象构造函数传入InvocationHandler 实例化对象
*/
//.....
return newInstance(cons, ih);
//....
}
```

在`getProxyClass0（..）`方法中有下面这段代码.顾名思义这段代码应该是对代理的字节码做了缓存.这是显而易见的，我们不会每次调用都去生成代理对象。需要对代理对象缓存。我们发现缓存是用的一个叫`WeakCache`的类。我们不探究这个类具体的工作是怎样的，我们只需要看我们的字节码是如何生成的.注释中`ProxyClassFactory `这个类应该是我们需要寻找的类。

```java
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
```

从ProxyClassFactory中下面的方法可以看到具体生成字节流的方法是`ProxyGenerator.generateProxyClass(..)`.最后通过native方法生成Class对象。同时对class对象的包名称有一些规定比如命名为`com.meituan.Utils$proxy0`。要想得到字节码实例我们需要先下载这部分字节流,然后通过反编译得到java代码。

```java

if (proxyPkg == null) {
//包名称，如com.meituan.com.Utils 用。分割
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* Choose a name for the proxy class to generate. proxyClassNamePrefix=`$proxy` 前缀默认是包名称加$proxy +自增的号码
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
//native 方法
return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
用ProxyGenerator.generateProxyClass(..)方法生成字节流，然后写进硬盘.假设我把proxyName定义为Calcultor$ProxyCode.我们先在https://bitbucket.org/mstrobel/procyon/downloads 下载一个反编译的jar包。然后运行下面的代码，我们得到了一个Calcultor$ProxyCode.class的文件.然后在目录下使用命令java -jar procyon-decompiler-0.5.29.jar Calcultor$ProxyCode.class 就能得到Calcultor$ProxyCode.java文件。 当然也可以实现在线反编译http://javare.cn/网站反编译然后下载文件

public static void main(String[] args) {
//传入Calculator接口
ProxyUtils.generateClassFile(Calculator.class,"Calcultor$ProxyCode");
}
public static void generateClassFile(Class clazz,String proxyName)
{
//根据类信息和提供的代理类名称，生成字节码
byte[] classFile = ProxyGenerator.generateProxyClass(proxyName,new Class[]{clazz});
String paths = clazz.getResource(".").getPath();
System.out.println(paths);
FileOutputStream out = null;

//保留到硬盘中
out = new FileOutputStream(paths+proxyName+".class");
out.write(classFile);
out.flush();
//...
下面的代码是就是反编译过来的Calcultor$ProxyCode类。可以发现这个类实现了我们需要代理的接口Calculator。且他的构造函数确实是需要传递一个InvocationHandler对象,那么现在的情况就是我们的生成了一个代理类,这个代理类是我们需要代理的接口的实现类。我们的接口中定义了add和reduce方法,在这个代理类中帮我们实现了，并且全部变成了final的。同时覆盖了一些Object类中的方法。那我们现在以reduce这个方法举例,方法中会调用InvocationHandler类中的invoke方法(也就是我们实现的逻辑的地方)。同时把自己的Method对象，参数列表等传入进去。

public final class Calcultor$ProxyCode extends Proxy implements Calculator {
private static Method m1;
private static Method m4;
private static Method m0;
private static Method m3;
private static Method m2;

public Calcultor$ProxyCode(InvocationHandler var1) throws {
super(var1);
}

public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}

public final int reduce(int var1, int var2) throws {
try {
return ((Integer)super.h.invoke(this, m4, new Object[]{Integer.valueOf(var1), Integer.valueOf(var2)})).intValue();
} catch (RuntimeException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}

public final int hashCode() throws {
try {
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}

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

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

static {
try {
//static静态块加载每个方法的Method对象
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m4 = Class.forName("jdkproxy.Calculator").getMethod("reduce", new Class[]{Integer.TYPE, Integer.TYPE});
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m3 = Class.forName("jdkproxy.Calculator").getMethod("add", new Class[]{Integer.TYPE, Integer.TYPE});
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
JDK动态代理小结

现在我们对JDK代理有个简单的源码级别的认识,理清楚一下思路:JDK会帮我们在运行时生成一个代理类,这个代理类实际上就是我们需要代理的接口的实现类。实现的方法里面会调用InvocationHandler类中的invoke方法,并且同时传入自身被调用的方法的的Method对象和参数列表方便我们编码实现方法的调用。比如我们调用reduce方法，那么我们就可以通过Method.Invoke(Object obj, Object... args)调用我们具体的实现类,再在周围做一些代理做的事儿。就实现了动态代理。我们对JDK的特性做一些简单的认识：

JDK动态代理只能代理有接口的类,并且是能代理接口方法,不能代理一般的类中的方法
提供了一个使用InvocationHandler作为参数的构造方法。在代理类中做一层包装,业务逻辑在invoke方法中实现
重写了Object类的equals、hashCode、toString，它们都只是简单的调用了InvocationHandler的invoke方法，即可以对其进行特殊的操作，也就是说JDK的动态代理还可以代理上述三个方法
在invoke方法中我们甚至可以不用Method.invoke方法调用实现类就返回。这种方式常常用在RPC框架中,在invoke方法中发起通信调用远端的接口等