代理模式

定义

为其他对象提供一种代理以控制对这个对象的访问

使用场景

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

角色介绍

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

示例代码：

//抽象主题
public interface ILawsuit {

    //提交申请
    void submit();
    //进行举证
    void burden();
    //开始辩护
    void defend();
    //诉讼完成
    void finish();
}

//真实主题类
public 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("诉讼成功，判决老板即日起七天结算工资");
    }
}
//代理类
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 Client {

    public static void main(String[] args){

        //构造一个小民
        ILawsuit xiaomin = new XiaoMin();
        //构造一个代理律师，并将小民作为构造参数传递进去
        ILawsuit lawyer = new Lawyer(xiaomin);
        //律师提交诉讼申请
        lawyer.submit();
        //律师进行举证
        lawyer.burden();
        //律师代替小民进行辩护
        lawyer.defend();
        //完成诉讼
        lawyer.finish();

    }
}

代理模式分为两种：

• 静态代理：代码运行前代理类的class编译文件就已经存在
• 动态代理：通过反射机制动态地生成代理者的对象，也就是我们在code阶段压根就不需要知道代理谁，代理谁我们将会在执行阶段决定，而Java也给我们提供了一个便捷的动态代理接口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 {

        Object result = method.invoke(obj,args);

        return result;
    }
}

import java.lang.reflect.Proxy;

public class Client {

    public static void main(String[] args){

        //构造一个小民
        ILawsuit xiaomin = new XiaoMin();
//        //构造一个代理律师，并将小民作为构造参数传递进去
//        ILawsuit lawyer = new Lawyer(xiaomin);

        DynamicProxy proxy = new DynamicProxy(xiaomin);

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

        //动态构造一个代理者律师
        ILawsuit lawyer = (ILawsuit) Proxy.newProxyInstance(loader,new Class[]{ILawsuit.class},proxy);

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

    }
}

我们在Android项目中使用第三方库Retrofit，使用就是代理模式

ApiService service = retrofit.create(ApiService.class); //创建一个代理实例
我们点进去create方法看看

@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
  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);
          }
        });
  

可以看到，也是通过Proxy.newProxyInstance生成了一个代理类。