代理模式

本文参考《Android源码设计模式解析与实战第2版》

• 代理模式的定义

代理模式也称为委托模式，是为其他对象提供代理以控制这个对象的访问。

• 代理模式的使用场景

无法或不想直接访问某个对象，或者访问某个对象困难时可以通过代理对象来实现间接访问。

• 代理模式的角色

• Subject：抽象主题-声明真实主题和代理的共同接口方法（事情执行步骤）
• RealSubject：真实主题类-该类表示所代理的真实对象（事情执行步骤的具体实现）
• ProxySubject：代理类-该类持有真实主题类的引用，在其所实现的接口方法中调用真实主题类中相应的接口方法执行，以实现代理的目的
• Client：代理模式的执行逻辑

• 代理模式的简单实现

使用代理模式实现一个诉讼过程，律师极为代理
定义诉讼流程（抽象主题-Subject）可以是接口也可以是抽象方法

/**
 * 抽象主题：
 * 定义诉讼的流程
 */

interface ILawsuit {
    /**
     * 提交申请
     */
    void submit();

    /**
     * 进行举证
     */
    void burden();

    /**
     * 开始辩护
     */
    void defend();

    /**
     * 诉讼完成
     */
    void finish();
}

定义具体对象(真实主题类-RealSubject)，即被代理对象

/**
 * 真实主题类：
 * 被代理的真实对象，执行步骤的具体实现
 */

class XiaoMin implements ILawsuit {


    @Override
    public void submit() {
        System.out.println("申请仲裁！");
    }

    @Override
    public void burden() {
        System.out.println("证据充足！");
    }

    @Override
    public void defend() {
        System.out.println("进行辩护！");
    }

    @Override
    public void finish() {
        System.out.println("诉讼成功！");
    }
}

定义代理律师（代理类-ProxySubject）代理类中需要持有真实对象的实现，并且实现诉讼流程接口

/**
 * 代理类
 * 通过持有的真实对象和实现事件流程接口来实现代理功能
 */

class Lawyer implements ILawsuit{

    private XiaoMin xiaoMin;//持有真实对象的引用

    public Lawyer(XiaoMin xiaoMin) {
        this.xiaoMin = xiaoMin;
    }

    @Override
    public void submit() {
        xiaoMin.submit();
    }

    @Override
    public void burden() {
        xiaoMin.burden();
    }

    @Override
    public void defend() {
        xiaoMin.defend();
    }

    @Override
    public void finish() {
        xiaoMin.finish();
    }
}

定义代理模式的执行逻辑(具体执行-Client)

class Client {

    public static void main(String[] args) {
        initStaticProxy();
    }
    /**
     * 静态代理使用
     */
    private static void initStaticProxy(){
        //构建具体对象
        XiaoMin xiaoMin = new XiaoMin();
        //构造代理律师对象
        ILawsuit lawyer = new Lawyer(xiaoMin);

        //通过代理律师执行具体诉讼逻辑
        lawyer.submit();
        lawyer.burden();
        lawyer.defend();
        lawyer.finish();
    }
}

• 动态代理的实现

动态代理是通过实现InvocationHandler接口，反射调用被代理者方法，使得编译阶段不需要知道具体代理谁，运行时阶段再确定代理谁，实现了代理类的复用。
动态代理类的具体实现：

**
 * 动态代理的实现
 * 主要是实现InvocationHandler接口
 * 通过invoke方法反射调用具体对象（被代理的对象）的方法
 */

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 {
        //调用被代理对象的方法
        Object result = method.invoke(obj,args);
        return result;
    }
}

动态代理的具体使用：

class Client {
    public static void main(String[] args) {
        initDynamicProxy();
    }

    /**
     * 动态代理的使用
     */
    private static void initDynamicProxy(){
        //构造具体对象
        XiaoMin xiaoMin = new XiaoMin();

        //构造动态代理
        DynamicProxy dynamicProxy = new DynamicProxy(xiaoMin);

        //获取被代理类的classLoader
        ClassLoader loader = xiaoMin.getClass().getClassLoader();

        //构造具体的代理律师
        ILawsuit lawyer = (ILawsuit) Proxy.newProxyInstance(loader,new Class[]{ILawsuit.class},dynamicProxy);
        //通过代理律师执行具体诉讼逻辑
        lawyer.submit();
        lawyer.burden();
        lawyer.defend();
        lawyer.finish();
    }
}

静态代理和动态代理的区别：
本质区别：静态代理的代理者一般由程序员手动实现，也就是编译阶段class的的编译文件就已经存在，动态代理是通过反射机制动态地生成代理者对象，所以
编译阶段根本不知道代理谁，到底代理谁是在运行时阶段决定。
具体区别：
1.动态代理代理对象不明确，可以复用，一个代理类可以代理多个被代理类
2.动态代理通过反射调用被代理对象方法，需要实现InvocationHandler接口
总结：
不论是静态代理还是动态代理只是实现手法不同，其思想都是一致的，简单说就是：
真实对象的所有事物，全权交给代理对象去处理。