Android中的代理模式

代理的概念：为某个对象提供一个代理，以控制对这个对象的访问。 代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

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

静态代理

代理类在程序运行前已经存在的代理方式称为静态代理。

/** * 定义Demo接口 */public interface Demo {      public void save();}

/** * DemoImpl实现Demo接口并覆写save()方法 * 真实主题，执行具体业务 */public class DemoImpl implements Demo {      public void save() {        System.out.println("调用save()方法");    }}

/** * DemoImplProxy 也实现了Demo接口，并覆写了save()方法，增加了自己的业务  * 代理主题，负责其他业务的处理 */public class DemoImplProxy implements Demo {      Demo demoImpl = new DemoImpl();    public void save() {        System.out.println("开始记录日志");        demoImpl.save();        System.out.println("开始结束日志");    }}

静态代理有一个缺点，每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类。

动态代理

代理类在程序运行前不存在、运行时由程序动态生成的代理方式称为动态代理。

实现动态代理包括三步：

(1). 新建代理类和委托类共同的接口以及委托类；
(2). 实现InvocationHandler接口，这是负责连接代理类和委托类的中间类必须实现的接口；
(3). 通过Proxy类新建代理类对象。

第一步：新建代理类和委托类共同的接口以及委托类

public interface Operate {    public void operateMethod1();    public void operateMethod2();    public void operateMethod3();}

public class OperateImpl implements Operate {    @Override    public void operateMethod1() {        System.out.println("Invoke operateMethod1");        sleep(110);    }    @Override    public void operateMethod2() {        System.out.println("Invoke operateMethod2");        sleep(120);    }    @Override    public void operateMethod3() {        System.out.println("Invoke operateMethod3");        sleep(130);    }    private static void sleep(long millSeconds) {        try {            Thread.sleep(millSeconds);        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

第二步：实现InvocationHandler接口

java.lang.reflect.InvocationHandler接口的定义如下：

/****Object proxy:被代理的对象*Method method:要调用的方法*Object[] args:方法调用时所需要参数*/public interface InvocationHandler {      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;}

实现 InvocationHandler 接口

public class TimingInvocationHandler implements InvocationHandler {    private Object target;    public TimingInvocationHandler() {}    public TimingInvocationHandler(Object target) {        this.target = target;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        long start = System.currentTimeMillis();        Object obj = method.invoke(target, args);        System.out.println(method.getName() + " cost time is:" + (System.currentTimeMillis() - start));        return obj;    }}

第三步：通过Proxy类新建代理类对象

java.lang.reflect.Proxy类的定义如下：

/***CLassLoader loader:类的加载器*Class<?> interfaces:得到全部的接口*InvocationHandler h:得到InvocationHandler接口的子类的实例*/public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException  

public class Main {    public static void main(String[] args) {        // create proxy instance        TimingInvocationHandler timingInvocationHandler = new TimingInvocationHandler(new OperateImpl());        Operate operate = (Operate)(Proxy.newProxyInstance(Operate.class.getClassLoader(), new Class[] {Operate.class},                timingInvocationHandler));        // call method of proxy instance        operate.operateMethod1();        System.out.println();        operate.operateMethod2();        System.out.println();        operate.operateMethod3();    }}

下面总结一下动态代理对象创建过程

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); // 通过反射从生成的类对象获得构造函数对象Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); // 通过构造函数对象创建动态代理类实例Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

从上面可以看到，实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 直接创建动态代理类实例Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,  new Class[] { Interface.class },  handler );

参考文章：

Java 动态代理机制分析

公共技术点之 Java 动态代理

代理模式和android插件化

Android设计模式源码解析之Proxy模式