代理技术简介(二):JDK动态代理

在上一篇文章中简单介绍一个代理:代理技术简介(一):代理概述，也写了一个代理程序，不过那是”静态代理”，下面说说动态代理里面的JDK动态代理。下面用JDK提供的动态代理方案写一个DynamicProxy：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler {

    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    @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...");
    }
}

在DynamicProxy类中，定义了一个Object类型的target变量，它就是被代理的目标对象，通过构造函数来初始化，现在流行叫做”注入”。DynamicProxy实现了InvocationHandler接口，那么必须实现该接口的invoke方法，参数不再做解释，望文生义，它是JRE给我们”射”进来的。在该方法中，直接通过反射去invoke method，在调用前后分别处理before和after，最后返回result。

下面写一个main方法看看实际怎么使用：

import java.lang.reflect.Proxy;

import org.light4j.proxy.dynamicProxy.DynamicProxy;
import org.light4j.proxy.impl.HelloImpl;

public class Main {
    public static void main(String[] args) {
        Hello hello = new HelloImpl();

        DynamicProxy dynamicProxy = new DynamicProxy(hello);

        Hello helloProxy = (Hello)Proxy.newProxyInstance(
                hello.getClass().getClassLoader(),
                hello.getClass().getInterfaces(),
                dynamicProxy);

        helloProxy.say("longjiazuo");
    }
}

意思就是用这个通用的DynamicProxy类去包装HelloImpl实例，然后再调用JDK给我们提供的Proxy类的工厂方法newProxyInstance去动态地创建一个Hello接口的代理类，最后调用这个代理类的say方法。

运行一下程序，结果和之前说的”静态代理”一样，动态代理成功了。其实，动态代理就是帮我们自动生成XxxProxy类的法宝。

需要注意的是，Proxy.newProxyInstance方法的参数实在是让人”醉了”！包含了三个参数：

参数1：ClassLoader；
参数2：该实现类的所有接口；
参数3：动态代理对象

调用完了还需要来一个强制类型转换。这块一定要想办法封装一下，避免再次出现到处都是Proxy.newProxyInstance方法的情况。于是将这个DynamicProxy重构一下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxy implements InvocationHandler {

    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        before();
        Object result = method.invoke(target, args);
        after();
        return result;
    }

    @SuppressWarnings("unchecked")
    public <T> T getProxy(){
        return (T)Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }

    private void before() {
        System.out.println("Before...");
    }

    private void after() {
        System.out.println("After...");
    }
}

在DynamicProxy里添加一个getProxy方法，无须传入任何参数，将刚才所说的那一块代码放入这个方法中，并且该方法返回一个泛型类型，就不会强制转换类型了。方法头上加上@SuppressWarnings("unchecked")注解表示忽略编译时的警告(因为Proxy.newProxyInstance方法返回的是一个Object，这里强制转换为T了，这是向下转型，IED中就会有警告，编译时也会出现提示)。
现在使用DynamicProxy就简单了：

import org.light4j.proxy.dynamicProxy.DynamicProxy;
import org.light4j.proxy.impl.HelloImpl;

public class Main {
    public static void main(String[] args) {
        DynamicProxy dynamicProxy = new DynamicProxy(new HelloImpl());
        Hello helloProxy = dynamicProxy.getProxy();

        helloProxy.say("longjiazuo");
    }
}

确实比较简单，用2行代理就去掉了前面的7行代码，省掉了5行代码，但是JDK动态代理也有局限，接下来的文章说说解决这种局限的方案，也就是CGLib动态代理。