动态代理是JDK 1.3以上的版本里的一个特性，实现了代理模式。通过JDK的动态代理特性，可以为任意Java对象创建代理对象，对于具体使用来说，这个特性是通过Java Reflection API来完成的，可以在java.lang.reflect中找到Proxy对象。
在Spring AOP实现中，核心技术就是动态代理，学习动态代理，也能让我们更好地理解面向切面思想。本文先介绍代理模式，然后再介绍静态代理，再由静态代理的缺点、问题引出动态代理。

一、代理模式

1.1 代理模式介绍

代理模式就是给某一个对象创建一个代理对象，由这个代理对象控制对原对象的引用，而创建这个代理对象后可以在调用原对象时增加一些额外的操作。代理模式结构图如下：

代理模式结构图.png

• 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()中的代理逻辑。