代理模式

定义

代理（Proxy）模式是设计模式中结构型模式的一种，即通过代理对象访问目标对象。这样做的好处是可以在目标对象实现的基础上，对目标对象进行扩展，比如增加日志打印等。

现实中有很多代理模式的例子。比如过年的时候买不到火车票怎么办？找黄牛啊，这个时候黄牛就是一个代理，我们只需要和这个代理去打交道，剩下买票工作交给黄牛去做。

代理模式的通用UML图如下：

涉及到以下几个角色

• Subject抽象角色：定义被代理角色和代理角色要实现接口。

• RealSubject目标角色：实现抽象角色，即具体业务逻辑。

• Proxy代理角色：实现抽象角色，持有目标角色的引用。

接下来看一下具体的代码实现：

静态代理实现

Subject抽象角色Subject.java

public interface Subject {	
    void operation();	
    void operation2();	
}

RealSubject目标角色RealSubject.java

public class RealSubject implements Subject {	
    @Override	
    public void operation() {	
        System.out.println("我是真实操作");	
    }	
    @Override	
    public void operation2() {	
        System.out.println("我是真实操作2");	
    }	
}

Proxy代理角色StaticProxy.java

public class StaticProxy implements Subject {	
    private Subject realSubject;	
    public StaticProxy(Subject subject) {	
        this.realSubject = subject;	
    }	
    @Override	
    public void operation() {	
        System.out.println("我是代理操作");	
        realSubject.operation();	
    }	
    @Override	
    public void operation2() {	
        System.out.println("我是代理操作2");	
        realSubject.operation();	
    }	
}

测试类Test.java

public class Test {	
    public static void main(String args[]) {	
        /**	
         * 静态代理	
         */	
        Subject subject = new RealSubject();	
        Subject proxy = new StaticProxy(subject);	
        proxy.operation();	
        proxy.operation2();	
    }	
}

打印结果

我是代理操作	
我是真实操作	
我是代理操作2	
我是真实操作

可以看到，在真实要操作的对象前，可以输出一些我们定义好的逻辑，这就是代理模式的实现。代理模式实现的方式有几种。以上是静态代理，还有一种是动态代理，在运行时生成代理对象。接下来看一下动态代理如何实现。

动态代理的实现

在Java中要想实现动态代理机制，需要用到java.lang.reflect.InvocationHandler和 java.lang.reflect.Proxy。

代理类要实现InvocationHandler接口，重写invoke，可以在这里对目标角色进行增强，比如这里打印了一条日志。

public class DynamicProxy implements InvocationHandler {	
    private Object obj;	
    public DynamicProxy(Object obj) {	
        this.obj = obj;	
    }	
    @Override	
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {	
        System.out.println("我是代理操作" + method.getName());	
        Object result = method.invoke(obj, args);	
        return result;	
    }	
}

测试类Test.java

Subject subject1 = new RealSubject();	
DynamicProxy handler = new DynamicProxy(subject1);	
Subject proxy1 = (Subject) Proxy.newProxyInstance(subject1.getClass().getClassLoader(), subject1.getClass().getInterfaces(), handler);	
proxy1.operation();	
proxy1.operation2();

可以看到，通过反射得到了一个代理对象，执行结果的静态代理类似，如下：

打印结果

我是代理操作operation	
我是真实操作	
我是代理操作operation2	
我是真实操作2

小结

无论是静态代理还是动态代理，都是对被代理对象进一步的包装。

静态代理

优点：目标类无需关系代理类实现逻辑，只需知道有代理类即可。 缺点：目标类和代理类实现相同的接口，代码量变大。如果接口增加了一个方法，那么目标类和代理类都需要增加这个方法的实现。

动态代理

优点：代码量少 缺点：只能代理实现接口的类，没有实现接口的类就不能实现动态代理。通过反射会有性能消耗。

one more thing

在Android性能监控开发中，我们可能对网络库的请求进行监控，在请求之前或之后做一些统计，接下来我们就以OkHttp为例，对网络请求进行代理（当然OkHttp自己有一套拦截器机制也可以实现对请求拦截，不在我们讨论范围内）。

静态代理

一般情况下，OkHttp的请求是这样的

OkHttpClient client = new OkHttpClient();	
Request request = new Request.Builder().get().url("https://democome.com/").build();	
Call call = client.newCall(request);	
call.enqueue(new Callback() {	
    @Override	
    public void onFailure(Call call, IOException e) {	
    }	
    @Override	
    public void onResponse(Call call, Response response) throws IOException {	
        Log.d(TAG, response.body().string());	
    }	
});

我们要做的就是代理Callback，在返回之前打一些日志。按照代理模式的定义实现如下：

代理类CallbackProxy

public class CallbackProxy implements Callback {	
    public static final String TAG = CallbackProxy.class.getSimpleName();	
    private Callback realCallback;	
    public CallbackProxy(Callback realCallback) {	
        this.realCallback = realCallback;	
    }	
    @Override	
    public void onFailure(Call call, IOException e) {	
        Log.d(TAG, "请求失败先搞点事情" + e.toString());	
        realCallback.onFailure(call, e);	
    }	
    @Override	
    public void onResponse(Call call, Response response) throws IOException {	
        Log.d(TAG, "请求成功先搞点事情" + response.toString());	
        realCallback.onResponse(call, response);	
    }	
}

调用工具类

public class StaticUtil {	
    public static void proxyRequest(Call call, Callback callback) {	
        CallbackProxy callbackProxy = new CallbackProxy(callback);	
        call.enqueue(callbackProxy);	
    }	
}

调用

StaticUtil.proxyRequest(call, new Callback() {	
    @Override	
    public void onFailure(Call call, IOException e) {	
        e.printStackTrace();	
    }	
    @Override	
    public void onResponse(Call call, Response response) {	
        try {	
            Log.d(TAG, response.body().string());	
        } catch (IOException e) {	
            e.printStackTrace();	
        }	
    }	
});

动态代理

调用工具类

public class DynamicUtil {	
    public static final String TAG = DynamicUtil.class.getSimpleName();	
    public static class ResponseHandler implements InvocationHandler {	
        private Object obj;	
        public ResponseHandler(Object obj) {	
            this.obj = obj;	
        }	
        @Override	
        public Object invoke(Object proxy, Method method, Object[] args)	
                throws Throwable {	
            Log.d(TAG, "要请求了 搞事搞事搞事" + method.toString());	
            Object result = method.invoke(obj, args);	
            return result;	
        }	
    }	
    /**	
     * @param call	
     * @param callback	
     */	
    public static void proxyRequest(Call call, Callback callback) {	
        ResponseHandler handler = new ResponseHandler(callback);	
        Callback proxy = (Callback) Proxy.newProxyInstance(callback.getClass().getClassLoader(), callback.getClass().getInterfaces(), handler);	
        call.enqueue(proxy);	
    }	
}

调用

DynamicUtil.proxyRequest(call, new Callback() {	
    @Override	
    public void onFailure(Call call, IOException e) {	
    }	
    @Override	
    public void onResponse(Call call, Response response) throws IOException {	
        try {	
            Log.d(TAG, response.body().string());	
        } catch (IOException e) {	
            e.printStackTrace();	
        }	
    }	
});

以上就是代理模式的的讲解，从静态、动态的实现，到以 okttp 框架为案例实现拦截网络请求。

--END--

识别二维码，关注我们