设计模式（七-扩展篇）——动态代理

本文属于系列文章《设计模式》，附上文集链接

本文集代理模式请看此处

前言

上一篇写的那个代理模式，是属于静态代理。假设一种场景，假设我们要为很多类的很多方法添加前置和后置方法（别忘了代理模式是为了控制），按照静态代理的方法，我们就得为所有类的所有方法一个一个地去实现需求，想想这工程量就觉得可怕，所以就有了很优美的实现方式，叫做动态代理。

JDK代理

且看代码

// 抽象接口
public interface MyInterface {
    void hello(int i, int j);
    void hello(int i, int j, int k);
}
// 接口实现类，也是我们的代理目标类
public class MySubject implements MyInterface{
    @Override
    public void hello(int i, int j) {
        System.out.println("hello(): "+i+"-"+j);
    }
    @Override
    public void hello(int i, int j, int k) {
        System.out.println("hello(): "+i+"-"+j+"~"+k);
    }
}
// 这个是关键，被代理对象方法的实际执行地方，通过反射实现
public class MyInvocationHandler implements InvocationHandler{
    // 被代理的目标对象
    private Object target;
    MyInvocationHandler(Object target) {  
        super();  
        this.target = target;  
    } 
    @Override
    /\*\*
     \* proxy 代理的目标对象
     \* method 代理的目标对象的方法
     \*  args，方法的参数
     \*/
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法： " + method.getName() + "执行前");
        StringBuilder sb = new StringBuilder("方法的参数：");
        for (Object arg : args) {
            sb.append(arg.toString()+" ");
        }
        System.out.println(sb.toString());
        Object result = method.invoke(target, args);
        System.out.println("方法： " + method.getName() + "执行后");
        return result;
    }
}
// 场景类
public class Client {
    public static void main(String[] args) {
        MyInterface mySubject = new MySubject();
        MyInvocationHandler handler = new MyInvocationHandler(mySubject);
        MyInterface mySubjectProxy = (MyInterface) Proxy.newProxyInstance(mySubject.getClass().getClassLoader(),  
                mySubject.getClass().getInterfaces(), handler);
proxy.getProxyObject();
        mySubjectProxy.hello(5,98);
        System.out.println("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");
        mySubjectProxy.hello(5, 23, 54);
    }
}
结果：
方法： hello执行前
方法的参数：5 98 
hello(): 5-98
方法： hello执行后
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
方法： hello执行前
方法的参数：5 23 54 
hello(): 5-23~54
方法： hello执行后

比较关键的就三个地方：

• 一、被代理的目标对象必须实现接口，即上文的<code>MySubject</code>和<code>MyInterface</code>。
• 二、实现InvocationHandler接口的handler类，即上文中的<code>public class MyInvocationHandler implements InvocationHandler</code>。方法的参数说明在上面也有了，这里就不在阐述了。
• 三、使用Proxy类获取到目标对象的代理对象，即上文中的Proxy.newProxyInstance(mySubject.getClass().getClassLoader(),mySubject.getClass().getInterfaces(), handler);

之前也想过Proxy是怎么实现这个代理过程的，结果在这里看到了。
回到上面的代码，其实上面的代码还可以封装下，比如变成下面的样子：

// 接口类，接口实现类，handler类都没变化，引入下面的类
// 简单的动态代理类，传入一个目标对象参数，得到其代理对象
public class DynamicProxy{
    private MyInvocationHandler handler;
    private Object target;
    public DynamicProxy(Object _target) {
        this.target = _target;
        handler = new MyInvocationHandler(_target);
    }
    public Object getProxyObject(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
    }
}
// 场景类
public class Client {
    public static void main(String[] args) {
        MyInterface mySubject = new MySubject();
        **DynamicProxy proxy = new DynamicProxy(mySubject);
        MyInterface mySubjectProxy = (MyInterface) proxy.getProxyObject();**
        mySubjectProxy.hello(5,98);
        System.out.println("******************");
        mySubjectProxy.hello(5, 23, 54);
    }
}
结果：
方法： hello执行前
方法的参数：5 98 
hello(): 5-98
方法： hello执行后
*********************
方法： hello执行前
方法的参数：5 23 54 
hello(): 5-23~54
方法： hello执行后

上面场景类的代码，用自然语言解释挺流畅的，就是创建代理类对象，通过代理类对象获取被代理对象的代理对象。反正封装方法多种多样，上面其实其中一种，有意者多试试呗。
上面就是JDK代理，但是JDK代理有一个限制，就是上面说到的关键点的第一点，JDK代理无法脱离接口而实现，要为某个目标对象实现JDK代理，该目标对象至少实现一个接口，那如果要为没实现接口的类实现代理，怎么办，就是我们的Cglib代理。

cglib代理

且看代码

// 我们的代理目标类，这次是没有实现接口的
public class MySubject {
    public void hello(int i, int j) {
        System.out.println("hello(): "+i+"-"+j);
    }
    public void hello(int i, int j, int k) {
        System.out.println("hello(): "+i+"-"+j+"~"+k);
    }
}
// cglib代理类
public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法： " + method.getName() + "执行前");
        StringBuilder sb = new StringBuilder("方法的参数：");
        for (Object arg : args) {
            sb.append(arg.toString() + " ");
        }
        System.out.println(sb.toString());
        Object obj = methodProxy.invokeSuper(o, args);
        System.out.println("方法： " + method.getName() + "执行后");
        return obj;
    }
}
// 场景类
public class Client {
    public static void main(String[] args) {
        CglibProxy cglibProxy = new CglibProxy();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(MySubject.class);
        enhancer.setCallback(cglibProxy);
        // 得到代理对象
        MySubject o = (MySubject) enhancer.create();
        o.hello(5, 98);
        System.out.println("******************");
        o.hello(5, 23, 54);
    }
}
结果：
方法： hello执行前
方法的参数：5 98 
hello(): 5-98
方法： hello执行后
**********************
方法： hello执行前
方法的参数：5 23 54 
hello(): 5-23~54
方法： hello执行后

cglib是提供动态代理的第三方库，并不是jdk给我们代理，所以需要自己解决导包的问题。
这里，cglib设计的几个核心类，分别是：

• net.sf.cglib.proxy.Enhancer – 主要的增强类
• net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现
• net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用

核心方法就是<code>public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable </code>,第一个参数是代理对象，第二和第三个参数分别是拦截的方法和方法的参数，第四个是方法的代理对象。这个就是cglib代理。

以上就是动态代理。

水平有限，难免有错，还请评论区指责下