代理模式 💣

定义

【结构型】为其他对象提供一种代理以控制对这个对象的访问。

使用场景

当无法或不想直接访问某个对象或者访问某个对象存在困难时，可以通过一个代理对象来间接访问。为了保证客户端使用的透明性，委托对象与代理对象需要使用相同的接口。

角色

• Subject：抽象主题类。声明真实主题与代理的共同接口方法。该类既可以是抽象类也可以是接口。
• RealSubject：真实主题类。也就是被代理类。该类定义了代理所表示的真实对象，由其执行具体的业务逻辑方法，而客户类则通过代理类间接地调用真实主题类中定义的方法。
• ProxySubject：代理类。该类持有一个对 被代理类 的引用。在其所实现的接口方法中调用 被代理类 中相应的接口方法执行，以此起到代理的作用。

实现方式

背景：A君在B公司上班时，老板拖欠工资，直到A君离职时也不发，于是A君请律师代理打官司。
解决方案：代理模式

Subject

// 代理接口
public interface ILawsuit {
    void submit();    // 提交申请
    void burden();    // 进行举证
    void defend();    // 开始辩护
    void finish();    // 诉讼完成
}

RealSubject

// 被代理类（A君）
public class ClientA 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("诉讼成功！判决老板于七日内结清A君工资");
    }
}

ProxySubject

静态代理

// 代理类（律师）
public class Lawyer implements ILawsuit {
    private ILawsuit mLawsuit;  // 持有一个被代理者的引用

    public Lawyer(ILawsuit lawsuit) {
        mLawsuit = lawsuit;
    }

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

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

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

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

动态代理

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

测试

public class ProxyTest {
    public static void main(String[] args) {
        // 被代理者
        ILawsuit clientA = new ClientA();
        // 1. 静态代理者（律师）
        Lawyer lawyer = new Lawyer(clientA);

        /*// 2.1 动态代理类
        DynamicProxy proxy = new DynamicProxy(clientA);
        // 2.2 获取 被代理类 的 ClassLoader
        ClassLoader loader = clientA.getClass().getClassLoader();
        // 2.3 动态代理者（律师）
        ILawsuit lawyer = (ILawsuit) Proxy.newProxyInstance(loader, new Class[] { ILawsuit.class }, proxy);*/

        // 律师提交诉讼申请
        lawyer.submit();
        // 律师进行举证
        lawyer.burden();
        // 律师替A君辩护
        lawyer.defend();
        // 完成诉讼
        lawyer.finish();
    }
}

注意

代理模式应用广泛。Android 源码中 代理模式 实现的应用场景有 ActivityManagerProxy 代理类，以及 Binder 跨进程通信机制等，可以阅读相关源码。

代理模式从适用范围来分类：

• 远程代理（Remote Proxy）：为某个对象在不同内存地址空间提供局部代理。使系统可以将 Server 部分的实现隐藏，以便 Client 可以不用考虑 Server 的存在。（Binder 跨进程通信机制就属于 远程代理）
• 虚拟代理（Virtual Proxy）：使用一个代理对象表示一个十分耗资源的对象，并在真正需要时才创建。
• 保护代理（Protection Proxy）：使用代理控制原始对象的访问。该类型常被用于原始对象有 不同访问权限 的情况。
• 智能引用（Smart Reference）：在访问原始对象时执行一些附加的操作并对指向原始对象的引用计数。