代理模式UML

图1-1，代理模式UML建模

什么是代理模式？

给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。

比如说，我想在喝星巴克的咖啡；正常流程下，我要自己去星巴克店里购买，是我执行买这个操作，但现在我通过外卖服务，这个买的人就变成了外卖小哥，而不是我本人，这里的外卖小哥其实就是我的代理，他代我实现了这个买的操作。这里的我相当于Client，买咖啡是一个借口Subject，外卖小哥就是ReallySubject，ProxySubject就是我要买咖啡的一个代理（我并不关心真正的执行者是谁）

一个简单的代理实现代码

public class Delegate {
    public void main() {
        // 真正执行者
        Subject reallySubject =new ReallySubject();
        // 代理执行者
        Subject proxySubject =new ProxySubject(reallySubject);
        // 看似是代理执行者在做事【所谓的代理】
        proxySubject.doSomethings();
    }
}

interface Subject {
    void doSomethings();
}

public class ReallySubjectimplements Subject {
    @Override
    public void doSomethings() {
        Log.e("实际执行人","真正要做事的");
    }
}

public class ProxySubjectimplements Subject {
    private Subjectsubject;
    public ProxySubject(Subject subject) {
        this.subject = subject;
    }
    @Override
    public void doSomethings() {
        Log.e("我是代办人","通知真正办事的者，办事！");
        if (subject !=null)
            subject.doSomethings();
    }
}

什么是静态代理和动态代理？

静态代理：在编译时就将接口、实现类、代理类实现了，说白点就是咱们自己手动全部敲出来。

动态代理：在程序运行时，根据需要动态的创建代理类及相关实例。

都是代理又为什么要区分静态代理和动态代理呢？
当我们遇到某个需求要实现大量的代理的时候，每一个都要手动去敲是一件很费时操作，而且大部分的代码又都是重复的，这个时候就有大神就提出了动态代理的方案，来简化这些没有营养的操作了，即动态代理的出现。

动态代理的实现

public class DelegateSubject implements InvocationHandler {
    private Subject subject;

    public DelegateSubject(Subject subject) {
        this.subject = subject;
    }

    /**
     *
     * @param proxy 代理对象（表示哪个代理对象调用了method方法）
     * @param method 调用方法
     * @param args 调用方法参数
     * @return 代理实例调用具体的方法返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object object = null;
        // 添加自己的代码1
        // 根据自己的需要甚至可以不调用method.invoke()方法
        object = method.invoke(subject, args);
        // 添加自己的代码2
        return object;
    }

}

public class Delegate {

    public void main() {
        // 真正执行者
        ReallySubject reallySubject = new ReallySubject();
        // 代理执行器
        DelegateSubject delegateSubject = new DelegateSubject(reallySubject);
        // 构造动态代理
        // 第一个参数 真正执行者加载器
        // 第二个参数 真正执行者实现的接口
        // 第三个参数 代理执行器
        Subject subject = (Subject) Proxy.newProxyInstance(
                ReallySubject.class.getClassLoader(),
                ReallySubject.class.getInterfaces(),  // 或者 new Class<?>[] { Subject.class },
                delegateSubject);
        // 通过代理执行对象方法
        // 调用此方法执行 DelegateSubject的invoke()
        subject.doSomethings();
    }

}

看看retrofit是怎么使用动态代理

  public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
              throws Throwable {
            // If the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

看了retrofit的代码你会不会产生疑问，retrofit只有接口没并没有具体的执行者啊！！！
还记得上面的这段代码么？

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object object = null;
        // 添加自己的代码1
        // 根据自己的需要甚至可以不调用method.invoke()方法
        object = method.invoke(subject, args);
        // 添加自己的代码2
        return object;
    }

中提到过 “根据需要你甚至可以不调用method.invoke()”，没错retrofit就这么干的

ServiceMethod<Object, Object> serviceMethod =
     (ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);

这段代码只要是使用OkHttp进行网络请求，并将OkHttp的返回结果作为最终函数的返回结果。

设计模式—代理