浅谈设计模式之代理模式

定义：

代理模式(Proxy Pattern)为其他对象提供一种代理以控制对这个对象的访问。代理对象起到中介作用，可去掉功能服务或增加额外的服务。

类图：

根据以上类图，可以知道在代理模式中的角色有以下三种：

1. 抽象对象角色：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。

2. 目标对象角色：定义了代理对象所代表的目标对象。

3. 代理对象角色：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。

分类：

1. 远程代理(Remote Proxy)：为不同地理的对象提供局域网代表对象
2. 虚拟代理(Virtual Proxy)：根据需要将资源消耗很大的对象进行延迟，真正需要的时候再创建
3. 保护代理(Protect Proxy)：控制用户的访问权限
4. 智能引用代理(Smart Reference Proxy)：提供对目标对象额外的服务

在使用代理模式的时候，九成以上使用到的都是智能引用代理，故以下案例都围绕智能代理展开。

代理模式实现的两种方式：

• 静态代理
• 动态代理

首先我们先来看看静态代理的实现原理。

静态代理(Static Proxy)

定义：

代理和被代理对象在代理之前都是确定的。他们都实现相同的接口或者继承相同的抽象类。

静态代理实现方法：

• 继承法：代理类直接继承被代理类，实现其原有方法，并添加一些额外功能
• 聚合法：代理类实现相同的功能接口（很重要，相同接口，不同代理也可以进行相互代理），并在内声明一个被代理类的对象（类似封装），通过内部对象实现其原有方法，并添加额外功能

静态代理实现代码

首先定义一个接口，这里我们来拿汽车的行驶举例。

public interface Moveable {
    void move();
}

然后弄一个车，实现这个接口。Car这个类就是即将要被代理的对象。

import java.util.Random;

public class Car implements Moveable {

    @Override
    public void move() {
        //实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

先来看看继承法实现静态代理。

public class Car2 extends Car {

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶....");
        super.move();
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶....  汽车行驶时间：" + (endtime - starttime) + "毫秒！");
    }
}

再来看看聚合法实现静态代理。

public class Car3 implements Moveable {

    public Car3(Car car) {
        super();
        this.car = car;
    }

    private Car car;

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶....");
        car.move();
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶....  汽车行驶时间：" + (endtime - starttime) + "毫秒！");
    }

}

最后提供一个客户端的测试类。

public class Client {

    public static void main(String[] args) {
        //使用继承方式实现静态代理
        Moveable m1 = new Car2();
        m1.move();
        //使用聚合方式实现静态代理
        Car car = new Car();
        Moveable m2 = new Car3(car);
        m2.move();
    }

}

那么继承法和聚合法何者更优呢？

结论是聚合比继承更适合实现代理。

如果我们要实现功能的叠加，比如增加方法运行时间处理，增加权限管理，增加日志处理等，或者调整这些功能的实现顺序，如果有一百种实现顺序，我们用继承法就要实现100个代理子类，这显然是不现实的，如果需要修改也是极其繁琐的。而如果使用聚合法，只要一个代理类管理一个功能，在维护和调整顺序上都是最优的。这里就不再举例了。

动态代理(Dynamic Proxy)

类图：

首先看一下动态代理的类图。

定义：

所谓Dynamic Proxy是这样一种class：

它是在运行时生成的class，该class需要实现一组interface，使用动态代理类时，必须实现InvocationHandle接口。

实现步骤：

1. 创建一个实现接口InvocationHandler的类，它必须实现invoke方法
2. 创建被代理的类以及接口
3. 调用Proxy的静态方法（newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)），创建一个代理类
4. 通过代理调用方法

动态代理实现方法：

• JDK动态产生代理
• cglib动态产生代理

动态代理实现代码：

JDK动态代理：

public interface Moveable {
    void move();
}

import java.util.Random;

public class Car implements Moveable {

    @Override
    public void move() {
        //实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

动态代理类：

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

public class TimeHandler implements InvocationHandler {

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }

    private Object target;

    /*
     * 参数：
     * proxy  被代理对象
     * method  被代理对象的方法
     * args 方法的参数
     * 
     * 返回值：
     * Object  方法的返回值
     * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶....");
        method.invoke(target);
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶....  汽车行驶时间：" 
                + (endtime - starttime) + "毫秒！");
        return null;
    }

}

测试类：

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

public class Test {

    /**
     * JDK动态代理测试类
     */
    public static void main(String[] args) {
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Class<?> cls = car.getClass();
        /**
         * loader  类加载器
         * interfaces  实现接口
         * h InvocationHandler
         */
        Moveable m = (Moveable)Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), h);
        m.move();
    }
}

cglib动态代理：

首先需要导入第三方jar包——cglib-nodep-2.2.jar

创建一个火车类。

public class Train {

    public void move(){
        System.out.println("火车行驶中...");
    }
}

cglib动态代理类：

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxy implements MethodInterceptor {

    private Enhancer enhancer = new Enhancer();

    public Object getProxy(Class clazz){
        //设置创建子类的类
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);

        return enhancer.create();
    }

    /**
     * 拦截所有目标类方法的调用
     * obj  目标类的实例
     * m   目标方法的反射对象
     * args  方法的参数
     * proxy代理类的实例
     */
    @Override
    public Object intercept(Object obj, Method m, Object[] args,MethodProxy proxy) throws Throwable {
        System.out.println("日志开始...");
        //代理类调用父类的方法
        proxy.invokeSuper(obj, args);
        System.out.println("日志结束...");
        return null;
    }

}

测试类：

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {

        CglibProxy proxy = new CglibProxy();
        Train t = (Train)proxy.getProxy(Train.class);
        t.move();
    }

}

参考资料：

• 慕课网——模式的秘密---代理模式