动态代理的使用示例
说到Java的动态代理相信很多开发者都非常熟悉了，但是为了之后更好的对动态代理的原理和源码进行讲解分析，接下来还是先来了解下动态代理的实际使用示例：
现在有这样一个场景：
- 明星Michel有两个技能，唱歌、跳舞
- 明星都会有个经纪人，他们的工作是帮明星处理各种除了唱歌、跳舞的其他事务
- 演唱会负责人需要邀请明星Michel来现场唱跳，然后联系Michel的经纪人告知请求
下面由代码进行演示，首先创建明星接口，定义唱跳方法：
public interface Starter {
void sing();
void dance();
}
创建具体明星Michel，定义具体的唱跳逻辑：
public class Michel implements Starter{
@Override
public void sing() {
System.out.println("Michel singing...");
}
@Override
public void dance() {
System.out.println("Michel dancing...");
}
}
创建经纪人：
public class Agent implements InvocationHandler {
private Starter starter;
public Agent(Starter starter) {
this.starter = starter; // 设置代理明星
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("我来代理通知Starter...");
Object result = method.invoke(starter, args);
System.out.println("表演结束，谢谢大家...");
return result;
}
}
最后让流程启动：
public class Main {
public static void main(String[] args) {
Starter michel = new Michel(); // 创建明星
Agent agent = new Agent(michel); // 创建经纪人
// 利用经纪人和明星Michel之间的关系生成最终的代理对象
Starter michelProxy = (Starter) Proxy.newProxyInstance(michel.getClass().getClassLoader(), // 被代理人（Michel）
michel.getClass().getInterfaces(), // 代理了哪些接口（唱歌、跳舞)
agent); // 代理人（经纪人）
// 让代理对象进行唱跳
michelProxy.sing();
michelProxy.dance();
}
}
执行结果：
由此可以看到，经过以上的代码程序可以达到代理的效果。
原理&源码分析
上面的代码示例相信大家都很好理解，但是其中的原理并不是表面看得如此简单，首先提出几个问题：
- michelProxy这个代理对象是什么？它是怎么来的？为什么它可以强转为Starter类型？
- 最后执行的是michelProxy的sing、dance方法，为什么它会调用到agent的invoke方法？这个代理对象和agent是什么关系？
为了搞明白第一个问题，我们需要来打印一下Proxy.newProxyInstance这个方法它的返回值，也就是michelProxy具体信息：
public class Main {
public static void main(String[] args) {
Starter michel = new Michel();
Agent agent = new Agent(michel);
// 利用经纪人和明星Michel之间的关系生成最终的代理对象
Starter michelProxy = (Starter) Proxy.newProxyInstance(michel.getClass().getClassLoader(), // 被代理人（Michel）
michel.getClass().getInterfaces(), // 代理了哪些接口（唱歌、跳舞)
agent); // 代理人（经纪人）
// 打印信息
System.out.println("代理对象的类型：" + michelProxy.getClass());
System.out.println("代理对象的父类类型：" + michelProxy.getClass().getSuperclass());
System.out.print("代理对象实现的接口：");
for (Class<?> anInterface : michelProxy.getClass().getInterfaces()) {
System.out.print(anInterface.getName());
}
// 让代理对象进行唱跳
// michelProxy.sing();
// michelProxy.dance();
}
}
打印结果如下：
从上面的结果可以看到，所谓的代理对象其实是$Proxy0类的一个实例对象，而且该类继承了Proxy父类，以及实现了我们自定义的Starter接口
为了更进一步了解代理对象，我们需要打开$Proxy0类文件看下具体的内容。在这个时候，你会发现在项目中找不到 $Proxy0这个类文件？其实那是因为这个代理对象的类文件是在程序运行的过程中所生成的，它是存在于内存当中，所以我们在文件系统或者磁盘中搜索是找不到的。
那有没有办法可以看得到这个类文件呢，答案是肯定的。我们只需要在main方法中加入一句代码：System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”); （将代理对象$Proxy0的类文件从内存输出到硬盘中）。然后再执行一次main方法，然后就可以在一下目录看到：
然后，打开 $Proxy0类文件：
public final class $Proxy0 extends Proxy implements Starter { // 继承父类Proxy，实现自定义接口Starter
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m4;
private static Method m0;
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");
m4 = Class.forName("mike.test.Starter").getMethod("sing");
m3 = Class.forName("mike.test.Starter").getMethod("dance");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
public $Proxy0(InvocationHandler var1) throws { // 构造方法接收代理人，并调用Proxy父类构造方法
super(var1);
}
public final void sing() throws { // 实现唱歌接口，实际上其实是调用了代理人的invoke方法（h属性其实就是我们所创建的agent，下面源码分析会讲解）
try {
super.h.invoke(this, m4, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void dance() throws { // 实现跳舞接口，实际上其实是调用了代理人的invoke方法
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
// 以下就是Object类通用方法的覆盖，不多赘述
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);
}
}
}
相信看到这里，大家对$Proxy0这个类已经有了比较全面的认识，而且同时也解决了为什么代理对象可以对原接口方法进行增强（因为sing、dance方法已经被包装处理，其中直接调用了代理人的invoke方法）
至此，我们了解了代理对象的具体内容，接下来更进一步的了解代理对象的生成逻辑，重点关注Proxy.newProxyInstance方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
{
// 校验参数，以及接口的访问权限
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs); // 生成代理对象$Proxy0类对象（方法很长，不细讲，有兴趣可自行研究）
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl); // 校验代理对象类的接口权限
}
final Constructor<?> cons = cl.getConstructor(constructorParams); // 获取代理对象类的有参构造函数方法
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) { // 代理对象类若不是Public，则开放访问权限
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h}); // 调用代理对象类的有参构造函数，传入代理人，生成并返回代理对象实例
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
将以上的方法进行拆解，其实最核心的代码语句只有这三个：
Class<?> cl = getProxyClass0(loader, intfs); // 生成代理对象$Proxy0类对象（方法很长，不细讲，有兴趣可自行研究）
final Constructor<?> cons = cl.getConstructor(constructorParams); // 获取代理对象类的有参构造函数方法
return cons.newInstance(new Object[]{h}); // 调用代理对象类的有参构造函数，传入代理人，生成并返回代理对象实例
获取到代理类对象后，再通过其获取有参构造函数，至于是哪个有参构造函数，取决于constructorParams：
private static final Class<?>[] constructorParams = { InvocationHandler.class };
constructorParams作为Proxy类的属性其实是固定值{ InvocationHandler.class }（由此我们很容易联想到该接口的实现类——代理人），获取到对应的构造函数后，利用反射传入代理人进行创建并返回代理对象：
public $Proxy0(InvocationHandler var1) throws { // var1其实就是agent对象
super(var1); // 调用父类Proxy对应的构造函数
}
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h; // 最终将代理人赋值为代理对象的属性h
}
到此，一切都真相大白了，Java的动态代理Proxy机制的原理&源码分析完毕。