设计模式之代理（Proxy）

介绍

代理模式是一种结构型设计模式，它可以为其他对象提供一种代理以控制对这个对象的访问。

所谓代理，是指具有与被代理对象相同的接口的类，客户端必须通过代理与被代理的目标类进行交互，而代理一般在交互的过程中（交互前后），进行某些特定的处理。

UML类图

代理UML图

代理模式中的角色

• 抽象对象角色：声明了目标类及代理类对象的共同接口，这样在任何可以使用目标对象的地方都可以使用代理对象。
• 目标对象角色：定义了代理对象所代表的目标对象。
• 代理对象角色：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象和目标对象具有统一的接口，以便可以再任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或者之后，执行某些操作，而非单纯的将调用传递给目标对象。

代码示列（静态代理）

首先定义AbstractObject类，在其中定义代理类和目标类共有的接口operation()

public interface AbstractObject {
    void operation();
}

下面定义目标实现类：

public class RealObject implements AbstractObject {

    @Override
    public void operation() {
        System.out.println("do operation...");
    }
}

下面是代理类：

public class ProxyObject implements AbstractObject{

    //对目标类的引用
    private RealObject realObject;

    public ProxyObject(RealObject realObject) {
        this.realObject = realObject;
    }

    @Override
    public void operation() {
        System.out.println("do something before real operation...");
        if (realObject == null) {
            realObject = new RealObject();
        }
        realObject.operation();
        System.out.println("do something after real operation...");
    }
}

下面是测试类：

public class ProxyTest {

    public static void main(String[] args) {
        AbstractObject proxy = new ProxyObject(new RealObject());
        proxy.operation();
    }
}

运行结果：
do something before real operation...
do operation...
do something after real operation...

从这个例子可以看出，代理对象将客户端的调用委派给了目标对象，在调用目标对象之前及之后都可以执行某些特定的操作。

动态代理

介绍：动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式，是通过反射来实现的，借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。

代码示列

其他部分和上面一样，以下示代理对象的代码：

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

public class ProxyHandler implements InvocationHandler {

    Object obj = null;

    public Object newProxyInstance(Object realObj) {
        this.obj = realObj;
        Class<?> classType = this.obj.getClass();
        return Proxy.newProxyInstance(classType.getClassLoader(),
                classType.getInterfaces(),this);
    }

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

测试代码：

public class ProxyTest {

    public static void main(String[] args) {
        AbstractObject proxy = (AbstractObject) new ProxyHandler()
                .newProxyInstance(new RealObject());
        proxy.operation();
    }
}

运行结果：
do operation...

代理模式的使用场景

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

• 修改原有的方法来适应。显然这违反了“对扩展开放，对修改关闭”的原则。
• 采用一个代理类调用原来的方法，且对产生的结果进行控制。这就是代理模式了。

使用代理模式可以将功能划分的更加清晰，有助于后期的维护。