动态代理是JDK 1.3以上的版本里的一个特性，实现了代理模式。通过JDK的动态代理特性，可以为任意Java对象创建代理对象，对于具体使用来说，这个特性是通过Java Reflection API来完成的，可以在java.lang.reflect中找到Proxy对象。
在Spring AOP实现中，核心技术就是动态代理，学习动态代理，也能让我们更好地理解面向切面思想。本文先介绍代理模式，然后再介绍静态代理，再由静态代理的缺点、问题引出动态代理。
一、代理模式
1.1 代理模式介绍
代理模式就是给某一个对象创建一个代理对象，由这个代理对象控制对原对象的引用，而创建这个代理对象后可以在调用原对象时增加一些额外的操作。代理模式结构图如下：
- Subject：抽象主题，它是代理对象的真实对象要实现的接口。
- RealSubject：被代理的类，即目标对象。
- ProxySubject：代理类，除了实现抽象主题定义的接口外，还必须持有它所代理对象的引用。
在ProxySubject的调用过程中，如果客户调用ProxySubject的request方法，会在调用目标对象的request方法的前后调用一系列的处理，而这一系列的处理相对于目标对象来说是透明的，目标对象对这些处理可以毫不知情。
1.2 代理的作用
为什么要用代理？举个栗子，以明星为例，明星要做的事情就是唱歌、跳舞。而对于去哪唱歌、跳舞等等琐碎的事情，这种事显然明星不会自己安排，交给他的经纪人（即代理对象）来完成。这样把两者管理的内容抽离开，条理很清晰，明星就做明星该做的事，经纪人就做经纪人该做的事。
之所以要用到代理，是因为我们需要扩展目标对象的一些功能，但是这些功能与目标对象要完成的内容又关系不大，或者我们不想改动目标对象实现的功能，而只愿在其事件发生前后加入相应的扩展内容，比如，在某一事件发生的前后，用日志记录下来。
二、静态代理
以一个简单例子进行介绍：
public interface Greeting {
void sayHello(String name);
}
这是一个Greeting接口，即Subject。以下是实现类：
public class GreetingImpl implements Greeting {
@Override
public void sayHello(String name) {
System.out.println("Hello! "+name);
}
}
以下是代理类：
public class GreetingProxy implements Greeting {
private GreetingImpl greetingImpl;
public GreetingProxy(GreetingImpl greetingImpl) {
this.greetingImpl = greetingImpl;
}
@Override
public void sayHello(String name) {
before();
greetingImpl.sayHello(name);
after();
}
private void before() {
System.out.println("Before");
}
private void after() {
System.out.println("After");
}
}
测试类及测试结果：
public class Client {
public static void main(String[] args){
Greeting greetingProxy = new GreetingProxy(new GreetingImpl());
greetingProxy.sayHello("Tom");
}
}
\\测试结果
Before
Hello! Tom
After
上面的HelloProxy就是一个静态代理的例子。它的特点：
- 一个静态代理只能服务于一种类型的目标对象；
- 若要服务于多类型的目标对象，则需要为每种目标对象都实现一个静态代理对象。
这样，很容易就能发现静态代理的问题，如果我们要代理的目标对象较多的情况下，使用静态代理将会造成代理对象多、代码量大的问题。
三、JDK动态代理
为了解决静态代理类存在的问题，我们采用JDK动态代理进行修改。以下是动态代理类：
public class DynamicProxy implements InvocationHandler {
private Object target;
public DynamicProxy(Object target) {
this.target = target;
}
@SuppressWarnings("unchecked")
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(target,args);
after();
return result;
}
private void before() {
System.out.println("Before");
}
private void after() {
System.out.println("After");
}
}
通过定义一个代理类，实现InvocationHandler接口，该接口位于JDK反射包中，需要实现invoke方法，在该方法中，直接通过反射去invoke method，在调用前后分别处理before和after，最后将result返回。同时，我们在类中添加了getProxy方法，封装了获取代理对象的过程，主要是通过Proxy.newProxyInstance进行获取。这样就完成了动态代理类的定义，在该类中，我们没有实现任何一个目标对象的抽象接口，也就是说，我们可以通过该类代理多种目标对象类。测试类及结果如下：
public static void main(String[] args){
DynamicProxy dynamicProxy = new DynamicProxy(new GreetingImpl());
Greeting greetingProxy = dynamicProxy.getProxy();
greetingProxy.sayHello("Tom");
}
\\测试结果
Before
Hello! Tom
After
四、CGlib动态代理
相比较静态代理，上面的动态代理类算是方便了很多，当接口变了，代理类不用动。然而，该类却也有它搞不定的地方，比如要代理一个没有任何接口的类，它就没办法实现了。
而CGLib这个类库恰恰能够解决这个问题，它是一个在运行期间动态生成字节码的工具，也就是动态生成代理类了。
以下是利用CGLib写的动态代理类：
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CGLibProxy implements MethodInterceptor {
private static CGLibProxy instance = new CGLibProxy();
private CGLibProxy() {
}
public static CGLibProxy getInstance() {
return instance;
}
@SuppressWarnings("unchecked")
public <T> T getProxy(Class<T> cls) {
return (T) Enhancer.create(cls,this);
}
@Override
public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
before();
Object result = methodProxy.invokeSuper(target,args);
after();
return result;
}
private void before() {
System.out.println("Before");
}
private void after() {
System.out.println("After");
}
}
通过实现CGLib给我们提供的MethodInterceptor实现类，并实现intercept方法，完成代理类的编写。测试类及测试结果如下：
public class Client {
public static void main(String[] args){
Greeting greeting = CGLibProxy.getInstance().getProxy(GreetingImpl.class);
greeting.sayHello("Tom");
}
}
\\测试结果，需要注意，这里还需要导入asm包到项目中，不然会报错
Before
Hello! Tom
After
与动态代理不同的是，这里不需要任何的接口信息，对谁都可以生成动态代理对象。
五、总结
代理模式的应用，能够帮助我们对某一类的功能进行扩展。虽然静态代理类能够帮我们实现，但由于其只能对一种类型的目标对象服务，所以在目标对象较多的情况下，我们需要用到动态代理。动态代理分JDK动态代理和CGLib动态代理，JDK动态代理需要代理的对象实现一个接口，而CGLib不需要。CGLib创建代理的速度比较慢，但创建代理后运行的速度却非常快，而JDK动态代理正好相反。
顺便提一下：JDK动态代理类的实现代码是，为传入接口中的每一个方法，以及从java.lang.Object中继承来的equals()、hashCode()、toString()方法都生成了对应的实现，并且统一调用了InvocationHandler对象的invoke()方法来实现这些方法的内容，各个方法的区别不过是传入的参数和Method对象有所不同而已，所以无论调用动态代理的哪一个方法，实际上都是在执行InvocationHandler.invoke()中的代理逻辑。
