背景：学习spring的AOP或者EasyMock的源码时，需要对java的动态代理有深刻的了解
关于cglib的动态代理实现可以参考：
Java动态代理(cglib)
java中可以通过jdk中的java.lang.reflect.Proxy类来实现动态代理，但是我们需要先了解下什么是代理模式和静态代理
1.代理模式简介、目的，以及静态代理简介
代理模式构成要素通常是1个接口Subject，2个类RealSubject、Proxy，通用的类图如下：
范例代码如下：
- Subject接口
public interface Subject {
void play();
void upgrade(Integer level);
void rest();
}
- RealSubject类
public class RealSubject implements Subject {
@Override
public void play() {
System.out.println("the client is playing");
}
@Override
public void upgrade(Integer level) {
System.out.println("the client is upgrading");
}
@Override
public void rest() {
System.out.println("the client is resting");
}
}
- Proxy类
public class ProxySubject implements Subject {
private Subject proxied = null;
/**
* bind the proxied object
*
* @param client
*/
public ProxySubject(Subject client) {
this.proxied = client;
}
@Override
public void play() {
// do something before play
System.out.println("before the client is playing");
this.proxied.play();
System.out.println("after the client is playing");
// do something after play
}
@Override
public void upgrade(Integer level) {
// do something before upgrade
System.out.println("before the client is upgrading");
this.proxied.upgrade(level);
System.out.println("before the client is upgrading");
// do something after upgrade
}
@Override
public void rest() {
// do something before rest
System.out.println("before the client is resting");
this.proxied.rest();
System.out.println("before the client is resting");
// do something after rest
}
}
- 调用代码：
public class TestMain {
public static void main(String[] args) {
ProxySubject proxy = new ProxySubject(new RealSubject());
proxy.play();
proxy.rest();
proxy.upgrade(1);
}
}
- 运行结果：
代理模式就是当我们对RealSubject的行为进行增强，但是我们又不希望直接修改RealSubject的代码而给出的一种无侵入式方案
1.代理模式讲清楚了，那么什么是静态代理？
当我们对一个RealSubject类进行强化时，写一个代理类Proxy就可以了，这就是静态代理。
2.为什么要有动态代理？
但是如果我们需要对成千上万个RealSubject类进行强化时，是不可能去写这么多代理类的，会造成项目代码量暴增，代码难于管理，这时候就需要动态代理了
动态代理的含义：在jvm中动态创建一个Proxy类，使用完之后，立即销毁Proxy类，你在项目代码中是看不到这个Proxy类的源码的
2.如何实现动态代理？
动态代理的原理就是：在jvm的运行时动态创建一个类，并实例化
- 在java中，创建一个类的流程如下：
1.source经过编译变成.class文件
2.java应用在启动时，通过类加载器（ClassLoader）加载.class文件到jvm中并转换为对应的class类实例
3.通过class类实例new一个对象
这里"class类实例"指的是public final class Class
动态代理希望能省略source编译成.class文件的过程，在runtime中直接生成.class文件并通过自定义ClassLoader加载.class文件到jvm，后续的流程和正常类加载流程没有区别
- 有哪些方法可以在运行时的代码中生成二进制字节码？
Java字节码生成开源框架：JavaAssist和ASM（可以单开一文来讲这2个框架是如何使用的）
JavaAssist和ASM相当于通过编写java代码生成class文件，当需要生成的class文件业务逻辑较复杂时，需要编写的java代码量较大，难于规模应用，那么我们java当前是通过什么方式实现动态代理的？
3.jdk的动态代理
jdk的动态代理实现中，相对于代理模式通用的Subject，RealSubject，Proxy，还多了一个InvocationHandler接口，它的用途是：
当Proxy需要调用RealSubject的方法时，不再直接调用，而是将方法对应的Method变量和RealSubject实例传入InvocationHandler，由InvocationHandler来负责调用，并由InvocationHandler对方法调用进行增强
InvocationHandler的加入有什么好处？
我们思考这样一种场景，RealSubject有20个方法，现在需要对这20个方法做同样的强化逻辑，原本的经典代理模式是怎么做的？需要重复写20次强化逻辑代码
有了InvocationHandler之后，我们在Proxy的方法重写处调用InvocationHandler的invoke方法，强化逻辑都是在invoke方法中实现
4.jdk动态代理范例代码
- Subject和RealSubject代码不变，只是Proxy类不用再手动去写，而是通过Proxy.newProxyInstance()的方法去实现
- InvocationHanlder实现：
public class MyInvocationHandler implements InvocationHandler {
private RealSubject subject = null;
public MyInvocationHandler(RealSubject subject) {
this.subject = subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before the method is invoked");
if (method.getName().equals("upgrade")) {
method.invoke(this.subject, args);
} else {
method.invoke(this.subject, null);
}
System.out.println("after the method is invoked");
return null;
}
}
- 测试代码：
public class TestMain {
public static void main(String[] args) {
RealSubject subject = new RealSubject();
// 生成InvocationHandler实例
MyInvocationHandler h = new MyInvocationHandler(subject);
// 获取被代理对象实现的接口列表
Class[] interfaces = subject.getClass().getInterfaces();
// 获取被代理对象的classloader
ClassLoader classLoader = subject.getClass().getClassLoader();
Subject proxy = (Subject) Proxy.newProxyInstance(classLoader, interfaces, h);
proxy.play();
proxy.rest();
proxy.upgrade(1);
}
}
其中Proxy.newProxyInstance(classLoader,interfaces,h)实现了创建Proxy类的功能
可以看到，jdk的动态代理，是对接口中定义方法的强化，如果要直接实现对某个类的强化，而这个类又没有实现任何接口，就需要借助cglib了
这跟newProxyInstance的实现有关系，newProxyInstance的参数是：classLoader，interfaces，h，可以理解是这个方法是基于interfaces去创建的动态代理，如果我们能够在Proxy类中新建一个创建动态代理的方法，用realSubject作为参数，基于realSubject去创建代理类，那么我们也就在jdk中实现了对具体某个类的动态代理实现
下面的代码是对上面测试代码的修改，动态代理的创建完全跟RealSubject这个类没有关系了，也可以看出来jdk的基于接口的动态代理的含义了：
public class TestMain {
public static void main(String[] args) {
Subject subject = new Subject() {
@Override
public void play() {
}
@Override
public void upgrade(Integer level) {
}
@Override
public void rest() {
}
};
// 生成InvocationHandler实例
MyInvocationHandler h = new MyInvocationHandler(subject);
// 获取被代理对象实现的接口列表
Class[] interfaces = new Class[]{Subject.class};
// 获取被代理对象的classloader
ClassLoader classLoader = subject.getClass().getClassLoader();
Subject proxy = (Subject) Proxy.newProxyInstance(classLoader, interfaces, h);
proxy.play();
proxy.rest();
proxy.upgrade(1);
}