什么是代理模式？
代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。
什么是动态代理？
Java的java.lang.reflect包中有自己的代理支持，利用这个包你可以在运行时动态地创建一个代理类，实现一个或者多个接口，并将方法的调用转发到你所指定的类。因为实际的代理类是运行时创建的，所以称这个Java技术为：动态代理。
为什么需要使用动态代理？
因为传统的代理方式见下图，每次都要自己创建一个实现代理对象的接口的类，当需要很多这样的需求的时候，就会发现这会变得非常复杂。
然后，自然而然的，作为一个程序员，当然要创建一个东西来很好地实现解决这个问题。然后就有了Java内置的动态代理。见下图。通过反射来在运行时，动态地创建想对应的代理对象。
示例代码
/**
* 抽象主题
*/
public interface Subject {
/**
* 声明抽象请求方法
*/
void request();
}
/**
* 真实主题
*/
public class RealSubject implements Subject {
/**
* 实现请求方法
*/
@Override
public void request() {
System.out.println("Request.");
}
}
/**
* 代理主题
*/
public class ProxySubject implements Subject {
/**
* 被代理对象
*/
private RealSubject realSubject;
/**
* 通过被代理对象访问方法
*/
@Override
public void request() {
System.out.println("Start.");
if (realSubject == null) {
realSubject = new RealSubject();
}
realSubject.request();
System.out.println("End.");
}
}
public class Client {
public static void main(String[] args) {
Subject subject = new ProxySubject();
subject.request();
}
}
这里就可以发现使用了代理之后，就可以对原来的主题中的request方法的调用之前和调用之后，都进行相应的行为。其实有点类似于Spring中AOP的意思，和装饰器模式也有点像(都实现了想要代理或者想要装饰的对象的接口)。
但是代理模式的目的是实现访问控制之类的，而装饰器其实更多的是为了改变对象的行为。
动态代理代码
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class LogInvocationHandler implements InvocationHandler {
/**
* 被代理对象
*/
private Object obj;
public LogInvocationHandler(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Start.");
method.invoke(obj, args);
System.out.println("End.");
return null;
}
}
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
//为了获得动态的代理文件
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
Subject subject = new RealSubject();
// 使用 Proxy.newProxyInstance 方法生成代理对象
Subject proxy = (Subject) Proxy.newProxyInstance(subject.getClass()
.getClassLoader(), subject.getClass().getInterfaces(),
new LogInvocationHandler(subject));
System.out.println("自动生成代理类：" + proxy.getClass().getName());
proxy.request();
}
}
如果使用了动态代理的话，那么原来的代理的实现就不需要了，可以有Proxy.newProxyInstance()这个静态方法来动态的生成。但是也是要注意用法，这里需要一个实现了InvocationHandler接口的类。
注意这里动态生成的代理对象继承的Proxy类，然后实现的是给予的接口，所以这里才能够将这个对象转化为Subject对象。这里是必须转化的，不然会出现一个错误就是返回的对象是一个Object类型的。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException
无论调用是代理类的哪一个方法，最后都会去调用InvocationHandler的invoke方法。
理解
到底是怎么通过反射来生成的相对应的代理类的？
网上找了很多资料看这个问题，但是只发现涉及到的知识点有安全机制，缓存，反射，还有很多很多东西，只能看最外层的API大致了解一下了。
/**
* 返回一个指定接口的代理类实例，将方法调用指派到指定的调用处理程序。
*/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces, InvocationHandler h)
throws IllegalArgumentException {
if (h == null) {
throw new NullPointerException();
}
/*
* 调用 getProxyClass 方法查找或生成指定代理类。
用到查找是因为这里内部是有缓存的，用一个Map来维护。
当发现有重复是直接就可以取出来的。
使用类加载器和传入的接口数组(因为可能这个subject会实现多个接口)。
最后就可以得到代理类的Class。
通过下面的代码也可以知道这个Class的构造函数，
是需要一个**InvocationHandler**的引用的。
*/
Class<?> cl = getProxyClass(loader, interfaces);
/*
* 调用构造方法传入构造管理器生成代理类实例。
*/
try {
// constructorParams = { InvocationHandler.class };
Constructor cons = cl.getConstructor(constructorParams);
// 生成实例
return cons.newInstance(new Object[] { h });
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
} catch (IllegalAccessException e) {
throw new InternalError(e.toString());
} catch (InstantiationException e) {
throw new InternalError(e.toString());
} catch (InvocationTargetException e) {
throw new InternalError(e.toString());
}
}
为什么最后无论调用哪一个方法都会去调用InvocationHandler的invoke方法？
其实这个东西看过动态生成的类就会比较清晰。
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.sun.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(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 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 void request() throws {
try {
super.h.invoke(this, m3, (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)).intValue();
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("Subject").getMethod("request", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
这里可以看到使用Java动态代理生成的类，其实传统的实现原理都是一样的。就是覆盖了主题(Subject)接口中的相应方法，然后调用的是super.h.invoke(this, m3, (Object[])null);，虽然这个例子只是写了一个方法，但是可以想象到的时，其实所有的方法都是这个逻辑，都调用了invoke方法，不同的只是传递过去的函数名字是不同的。
m3代表的是request，因为request是一个无参方法，所以有(Object[])null。
疑惑
之前也看到了动态生成的类的源代码，但是当我在Client中对proxy.request()单步调试进入这句话的时候，并没有出现和进入proxy的源代码中，也就是说并没有super.h.invoke(this, m3, (Object[])null);这句话的显示并让我进入，而是直接让我进入了InvocationHandler，理论上不应该呀，那个对象应该已经存在内存中了呀？！！还有待进一步加深理解。
最后：
Java1.8的源码比之前的都要复杂的多，如果1.8的看不懂的话，可以先理解一下1.7的版本。
参考：
java代理模式（proxy）及动态代理的源码分析(讲的Java1.8的源码)
Java API 源码阅读：动态代理（Dynamic Proxy）(讲的1.7,大量引用了例子)
JDK源码分析——动态代理源码(Proxy类)
JDK动态代理实现原理
Java的动态代理(dynamic proxy)
