Java 动态代理

先了解下代理模式的概念：为其他对象提供一种代理，以控制对这个对象的访问。也就是通过一个新的对象去代表目标对象，再通过新对象间接去访问目标对象的功能，主要的作用有：

• 增强目标对象的功能
• 保护目标对象，屏蔽掉一些敏感的功能

具体的实现可以采用静态代理或者动态代理两种方案，我们增强目标对象的功能为例来学习动态代理。

注意，有些说法是“代理模式一般是内部创建被代理的对象” ，你这例子是装饰者模式，但我认为这并不是必须，更多的时候需要根据业务去权衡，比如在某些场景上要求代理类有一定通用性，目标对象是可以依赖注入的，就需要变通了。

一、静态代理

首先定义一个Shop接口，作用就是售卖物品：

public interface Shop {
    void sale(String name);
}

再定义一个CoffeeShop类，实现Shop接口，专门售卖咖啡：

public class CoffeeShop implements Shop {
    public void sale(String name) {
        System.out.println("开始制作" + name + "......制作完成！");
    }
}

最后定义代理类，需要通过构造函数注入目标对象，调用目标对象的售卖方法，并在售卖的前后添加问候语：

public class StaticProxy implements Shop {
    private Shop shop;

    public StaticProxy(Shop shop) {
        this.shop = shop;
    }

    public void sale(String name) {
        System.out.println("欢迎！");
        shop.sale(name);
        System.out.println("再见！");
    }
}

public class ProxyTest {
    @Test
    public void staticProxyTest() {
        Shop shop = new CoffeeShop();
        StaticProxy staticProxy = new StaticProxy(shop);
        staticProxy.sale("拿铁");
    }
}

测试结果如下：

动态代理我们主要学习两种：JDK动态代理、CGLIB动态代理，在上边的例子基础上进行改进。

二、JDK动态代理

JDK动态代理主要依赖java.lang.reflect包下的相关类实现，但要求被代理类必须最少实现一个接口，来规定类要实现哪些方法，否则无法创建代理对象，所以可以继续使用上边的CoffeeShop类。

public class JdkProxy {
    public Shop createProxy(final Shop shop) {
        ClassLoader loader = shop.getClass().getClassLoader();
        Class[] interfaces = shop.getClass().getInterfaces();
        InvocationHandler h = new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("欢迎！");
                Object result = method.invoke(shop, args);
                System.out.println("再见！");
                return result;
            }
        };
        return (Shop) Proxy.newProxyInstance(loader, interfaces, h);
    }
}

可以看到，上边的Proxy.newProxyInstance()方法就是用来创建代理对象的，需要三个参数：

• ClassLoader ：一般我们使用目标对象的类加载器。
• Class[]：被代理的类实现接口的字节码数组，保证代理对象和目标对象有相同的方法，要不然还怎么代理。这也是为什么要求被代理的类必须最少实现一个接口了。
• InvocationHandler ：一般可以用匿名内部类，在其invoke()回调中完成目标对象的功能增强。

invoke()方法三个参数的作用：

• Object proxy：创建的代理对象。
• Method method：当前调用的代理对象的方法。
• Object[] args：当前调用的代理对象方法传递的参数。

这样就可以通过反射间接调用目标对象的对应方法了：Object result = method.invoke(shop, args)

接下来就是测试代码了：

public class ProxyTest {
    @Test
    public void jdkProxyTest() {
        Shop shop = new CoffeeShop();
        JdkProxy jdkProxy = new JdkProxy();
        Shop shopProxy = jdkProxy.createProxy(shop);
        shopProxy.sale("拿铁");
    }
}

三、CGLIB动态代理

之前提到过，JDK动态代理要求被代理类必须最少实现一个接口，否则无法创建代理对象。但我们并不能要求用到的类都实现了接口，所以就需要第三方的 CGLIB 库来实现动态代理了，jar自行导入即可。下面用 CGLIB 来改造代码：

public class CglibProxy {
    public Object createProxy(final Object shop) {
        Class clazz = shop.getClass();
        Callback callback = new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("欢迎！");
                Object result = method.invoke(shop, args);
                System.out.println("再见！");
                return result;
            }
        };
        return Enhancer.create(clazz, callback);
    }
}

其实和 JDK动态代理的使用步骤类似。

这里用Enhancer.create()方法来创建代理对象，需要两个参数：

• Class ：被代理对象的字节码。
• Callback ：这里用到了它的MethodInterceptor子类，并在intercept()回调中完成目标对象的功能增强，这点和JDK动态代理类似。

通过如下测试代码可以实现相同的效果：

public class ProxyTest {
    @Test
    public void cglibProxyTest() {
        CoffeeShop2 shop = new CoffeeShop2();
        CglibProxy cglibProxy = new CglibProxy();
        CoffeeShop2 shopProxy = (CoffeeShop2) cglibProxy.createProxy(shop);
        shopProxy.sale("拿铁");
    }
}

其实 CGLIB 库也可以用来实现JDK动态代理例子中的功能，因为Enhancer.create()还有其他的重载方法：