今天看Java核心卷时，看到代理这一部分很晕，虽然之前对代理有一些基本了解，但并没有深入了解，而且代理的内容也是我们后期看框架源码的一个基础，所以打算专门来学习一下代理，并将学成果记录在此。
一、何为代理
代理概念
比如你想买一双美国产的球鞋，假设你有两种选择，一种是自己去美国买，另一种方式是你找你的朋友小王（从事代购工作的人）帮你买。小王就是代理。所以在这个场景中，主要涉及到三个对象，一个是购买球鞋的你，一个是做代理生意的小王，另一个是美国买球鞋的店。在你眼中，小王和美国买球鞋的专卖店并没有多大的区别，而这种情况的原因是小王和美国买球鞋都能提供买鞋这样的服务（功能），甚至小王可以提供更丰富一些的服务，比如送一些小礼品什么的,而小王自己没办法生产鞋，所有他提供的卖鞋服务是从美国买鞋店中获得的。因此可以从这个场景中画出其UML图，可以发现它就是代理模式的UML图：
代理场景.jpg
之后又来了一个小张的客户想要找小王代购电脑，但小王并不擅长这一块业务
，假设小张不着急，那么小王通过努力学习习得了电脑这块的业务，于是可以帮小张代购了，但如果下次来了一个小文要买其他的，而且时间比较赶，小王根本就无法处理过来。上面这个过程就是称之为静态代理。小王代购生意做得越来越好了，成立了一家代购公司，整合了大大小小的各种专业的代购人，有人需要代购东西，则找到小王对应的专业的代购人为其服务。上面这个过程称之为动态代理。
Java中代理概念：给目标对象提供一个代理对象，并由代理对象控制目标对象的引用。主要有两点目的：通过引入代理对象的方式来简介访问目标对象，防止直接访问目标对象给系统带来不必要的复杂性；其次通过代理对象对原有的业务逻辑增强。
二、Java对象的生命周期
- 这里简单的说一下，Java对象的生命周期，有助与我们进一步了解Java的代理。
Java文件（.java文件）经过java -c编译成Java字节码（.class文件）通过类加载器将.class文件（一种元数据）加载到元空间（JDK1.8之前称为方法区）中构造出class对象，通过class对象实例化对象，此时，对象便产生了，当没有引用指向该对象时，该对象可能会被卸载掉，释放其占用的资源。 - 生成字节码文件的方式
一种方式：Java编译器将Java文件编译成class文件。另一种方式：在程序中写代码，让代码（这部分代码主要是指实现代理类接口的方法）在内存中构建出字节码。 - Java动态生成代理类的过程
通过java反射包中提供的Proxy类创建代理类，主要使用其newProxyInstance静态方法，在该静态方法中getProxyClass0方法获取代理类类对象，它首先在缓冲中进行查找，找到直接返回，如果没有找到，就ProxyGenerator的generateProxyClass在内存中构建出一个代理的字节码文件，通过类加载器形成Class对象，在通过Class对象进行实例化。生成的这个代理类会代理Object类中的全部方法例如toString()，equals等。
//第一个参数为指定类加载器（null的话为默认的类加载器）
//第二个参数为代理类需要实现的接口类型对象
//第三个参数调度处理器，用来选择那个代理对象
Object proxy = Proxy.newProxyInstance(null,new Class[]{Comparable.class},handler);
/*
* 生成指定代理类的字节码文件
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
/*
* 根据字节码文件生成代理类
*/
Class<?> cl = getProxyClass0(loader, intfs);
可能你对Java的代理还是有些模糊，没关系，接下来，我们来看看java核心卷的中的一个例子。ProxyUtils类主要是将动态构建在内存中的字节码写到磁盘上去，看看这个动态生成的代理类的内容,这里选择第一个代理对象，也就是 elements[0].
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Random;
public class ProxyTest {
public static void main(String[] args){
Object[] elements = new Object[1000];
for(int i=0;i<elements.length;i++){
Integer value = i+1;
InvocationHandler handler = new TraceHandler(value);
Object proxy = Proxy.newProxyInstance(null,new Class[]{Comparable.class},handler);
elements[i] = proxy;
}
Integer key = new Random().nextInt(elements.length)+1;
int result = Arrays.binarySearch(elements,key);
ProxyUtils.generateClassFile(elements[0].getClass(),elements[0].getClass().getSimpleName());
if(result >=0 ) System.out.println(elements[result]);
}
}
class TraceHandler implements InvocationHandler{
private Object target;
public TraceHandler(Object target){
this.target = target;
}
//定义代理对象调用方法时，希望执行的动作
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//print implicit argument
System.out.print(target);
//print method name
System.out.print("."+ method.getName()+"(");
if(args != null){
for(int i=0;i<args.length;i++){
System.out.print(args[i]);
if(i < args.length - 1){
System.out.print(", ");
}
}
}
System.out.println(")");
return method.invoke(target,args);
}
}
以下代码是将Proxy生成的代理对象
import sun.misc.ProxyGenerator;
import java.io.FileOutputStream;
public class ProxyUtils {
/**
* byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
* proxyName, interfaces, accessFlags);
* */
public static void generateClassFile(Class clazz,String proxyName){
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, new Class[]{clazz});
String paths = clazz.getResource("/").getPath();
System.out.println(paths);
FileOutputStream out = null;
try {
out = new FileOutputStream(paths+proxyName+".class");
out.write(proxyClassFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
}
生成的的名字为$Proxy0.class,它后面的0是由一个计数器产生的，其代码如下：
public final class $Proxy0 extends Proxy implements Proxy0 {
private static Method m1;
private static Method m5;
private static Method m2;
private static Method m6;
private static Method m11;
private static Method m13;
private static Method m0;
private static Method m8;
private static Method m3;
private static Method m12;
private static Method m7;
private static Method m10;
private static Method m4;
private static Method m9;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
//代理了Object的equals方法
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 InvocationHandler getInvocationHandler(Object var1) throws IllegalArgumentException {
try {
return (InvocationHandler)super.h.invoke(this, m5, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
//代理了Object的toString方法
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 Class getProxyClass(ClassLoader var1, Class[] var2) throws IllegalArgumentException {
try {
return (Class)super.h.invoke(this, m6, new Object[]{var1, var2});
} catch (RuntimeException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}
//代理了Object的getClass()方法
public final Class getClass() throws {
try {
return (Class)super.h.invoke(this, m11, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
////代理了Object的方法
public final void notifyAll() throws {
try {
super.h.invoke(this, m13, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
//代理了Object的方法
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);
}
}
//代理了Object的方法
public final void wait() throws InterruptedException {
try {
super.h.invoke(this, m8, (Object[])null);
} catch (RuntimeException | InterruptedException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int compareTo(Object var1) throws {
try {
return (Integer)super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
//代理了Object的方法
public final void notify() throws {
try {
super.h.invoke(this, m12, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final Object newProxyInstance(ClassLoader var1, Class[] var2, InvocationHandler var3) throws IllegalArgumentException {
try {
return (Object)super.h.invoke(this, m7, new Object[]{var1, var2, var3});
} catch (RuntimeException | Error var5) {
throw var5;
} catch (Throwable var6) {
throw new UndeclaredThrowableException(var6);
}
}
//代理了Object的方法
public final void wait(long var1) throws InterruptedException {
try {
super.h.invoke(this, m10, new Object[]{var1});
} catch (RuntimeException | InterruptedException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}
public final boolean isProxyClass(Class var1) throws {
try {
return (Boolean)super.h.invoke(this, m4, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
//代理了Object的方法
public final void wait(long var1, int var3) throws InterruptedException {
try {
super.h.invoke(this, m9, new Object[]{var1, var3});
} catch (RuntimeException | InterruptedException | Error var5) {
throw var5;
} catch (Throwable var6) {
throw new UndeclaredThrowableException(var6);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m5 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getInvocationHandler", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m6 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getProxyClass", Class.forName("java.lang.ClassLoader"), Class.forName("[Ljava.lang.Class;"));
m11 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getClass");
m13 = Class.forName("com.sun.proxy.$Proxy0").getMethod("notifyAll");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
m8 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait");
m3 = Class.forName("com.sun.proxy.$Proxy0").getMethod("compareTo", Class.forName("java.lang.Object"));
m12 = Class.forName("com.sun.proxy.$Proxy0").getMethod("notify");
m7 = Class.forName("com.sun.proxy.$Proxy0").getMethod("newProxyInstance", Class.forName("java.lang.ClassLoader"), Class.forName("[Ljava.lang.Class;"), Class.forName("java.lang.reflect.InvocationHandler"));
m10 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait", Long.TYPE);
m4 = Class.forName("com.sun.proxy.$Proxy0").getMethod("isProxyClass", Class.forName("java.lang.Class"));
m9 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait", Long.TYPE, Integer.TYPE);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
从上述代码可以验证Proxy代理类生成的代理对象，代理了Object中的所有方法，以及指定接口(这里为Comparable接口）所需要的全部方法。当然我们还看到一些额外的方法，这几个方法是为获取代理对象做准备的，client访问代理对象时，代理对象（只有一个调用处理器的字段，它在定义在父类Proxy中）会使用InvocationHandler对象的invoke去处理，InvocationHandler对象里面的invoke代理了接口和Object中的方法。
三、总结
动态代理的关键在于，你给定Proxy类一个类加载器，以及要是实现的接口，以及调用处理器，那么他就可以在内存中构建出你所需的代理类，如果参数相同，那么Proxy类返回的代理对象是同一个代理类的对象。在InvocationHandler的invoke方法中，你可以很好的控制客户端的访问。再将我们的概念映射到 之前的那个例子中，小王代表的就是Proxy类，当有一个客户提出xxx需求（相当于提供了构造代理类的参数），小王就根据客户的要求在公司找到了一类擅长这方面的人（相当于构造出了一个适合当前客户需求的一个代理类），小王在这一类人中选择小李去处理（相当于生成该代理类的对象，该代理对象通过他的InvocationHandler来处理）。
