设计模式 ~ 代理模式

定义：为其他对象提供一种代理以控制这个对象的访问
术语：
- Subject：抽象主题类，声明真实主题与需要代理的方法
- RealSubject：被代理类（委托类），定义了代理所表示的真实对象，客户端通过代理类间接的调用委托类的方法。
- ProxySubject：代理类，持有对委托类的引用，在其所实现的接口方法中调用委托类中相应的被代理方法执行。
- Client：客户端类，调用代理的位置

1、静态代理

创建一个委托类需要委托的抽象方法Subject

/**
 * 定义一个抽象对象接口，抽象方法表示要代理做的事
 *
 * @author LTP  2021/11/9
 */
public interface Subject {
    /**
     * 外国友人找国人代购华为
     */
    void buyHuaWei();
}

创建委托类实现Subject

/**
 * 真实对象类，委托类
 *
 * @author LTP  2021/11/9
 */
public class RealSubject implements Subject {
    @Override
    public void buyHuaWei() {
        System.out.println("我是美国佬，我要买华为");
    }
}

创建静态代理类，构造器中传入具体的实现了委托接口的委托对象

/**
 * 代理类
 *
 * @author LTP  2021/11/9
 */
public class Proxy implements Subject {
    private final Subject subject;

    /**
     * 构造器传入代理对象
     *
     * @param subject 实现代理方法的代理对象
     */
    public Proxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void buyHuaWei() {
        // 收取代购费用
        System.out.println("收取代购费用");
        subject.buyHuaWei();
        // 一些其他的操作
        System.out.println("快递代理货物");
    }
}

客户端具体调用

/**
 * 实际调用静态代理的位置
 * 1个静态代理 只服务1种类型的目标对象(实现了同一种委托接口)，
 * 若要服务多类型的目标对象，则需要为每种目标对象都实现一个静态代理对象
 *
 * @author LTP  2021/11/9
 */
public class Client {
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        // 创建代理类，并将委托类传入构造
        Proxy proxy = new Proxy(subject);
        proxy.buyHuaWei();
    }
}

2、动态代理

创建一个委托类需要委托的抽象方法Subject（具体跟静态代理中相同）
创建委托类实现Subject（具体跟静态代理中相同）
创建动态代理类实现InvocationHandler并重写invoke方法，构造器中传入Object(任意委托类型)，即代理类与具体委托类的关系并未确定

/**
 * 代理类
 *
 * @author LTP  2021/11/9
 */
public class DynamicProxy implements InvocationHandler {
    // 申明被代理的对象,此时并不知道委托类的类型（Object）
    private final Object proxyObject;

    public DynamicProxy(Object proxyObject) {
        this.proxyObject = proxyObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 收取代购费用
        System.out.println("收取代购费用");
        // 利用反射调用被代理对象的方法
        Object result = method.invoke(proxyObject, args);
        // 一些其他的操作
        System.out.println("快递代理货物");
        return result;
    }
}

客户端调用

/**
 * 实际调用动态代理的位置
 * 动态代理中，代理类与委托类的关系是运行时才确定的，
 * 代理对象可同时代理多个任务而不需要修改代理类的源码，只需要添加新的委托类以及委托方法即可，可同时代理多个类型的目标对象
 *
 * @author LTP  2021/11/9
 */
public class Client {
    public static void main(String[] args) {
        // 创建委托类
        RealSubject realSubject = new RealSubject();
        // 创建代理类，并将委托类传入构造
        DynamicProxy dynamicProxy = new DynamicProxy(realSubject);
        ClassLoader classLoader = realSubject.getClass().getClassLoader();
        Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new Class[]{Subject.class}, dynamicProxy);
        subject.buyHuaWei();
    }
}

新需求：新增一个代购小米的需求

/**
 * 定义一个抽象对象接口，抽象方法表示要代理做的事
 *
 * @author LTP  2021/11/9
 */
public interface Subject2 {
    /**
     * 外国友人找国人代购小米
     */
    void buyXiaomi();
}

定义具体的委托对象

/**
 * 真实对象类，委托类
 *
 * @author LTP  2021/11/9
 */
public class RealSubject2 implements Subject2 {
    @Override
    public void buyXiaomi() {
        System.out.println("我是美国佬，我要买小米");
    }
}

在静态代理中，新增一个委托需要更改代理类的源代码，新增实现Subject2，并新增绑定委托类RealSubject2的构造，重写Subject2中需要委托的方法，破坏了开放封闭原则

/**
 * 代理类
 *
 * @author LTP  2021/11/9
 */
public class Proxy implements Subject, Subject2 {
    private Subject subject;
    private Subject2 subject2;

    /**
     * 构造器传入代理对象
     *
     * @param subject 实现代理方法的代理对象
     */
    public Proxy(Subject subject) {
        this.subject = subject;
    }

    /**
     * 构造器传入代理对象
     *
     * @param subject 实现代理方法的代理对象
     */
    public Proxy(Subject2 subject) {
        this.subject2 = subject;
    }

    @Override
    public void buyHuaWei() {
        // 收取代购费用
        System.out.println("收取代购费用");
        subject.buyHuaWei();
        // 一些其他的操作
        System.out.println("快递代理货物");
    }

    @Override
    public void buyXiaomi() {
        // 收取代购费用
        System.out.println("收取代购费用");
        subject2.buyXiaomi();
        // 一些其他的操作
        System.out.println("快递代理货物");
    }
}

在动态代理中，无需修改代理类的源码，直接在调用处添加新的代理即可

/**
 * 实际调用动态代理的位置
 * 动态代理中，代理类与委托类的关系是运行时才确定的，
 * 代理对象可同时代理多个任务而不需要修改代理类的源码，只需要添加新的委托类以及委托方法即可，可同时代理多个类型的目标对象
 *
 * @author LTP  2021/11/9
 */
public class Client {
    public static void main(String[] args) {
        // 创建委托类1
        RealSubject realSubject = new RealSubject();
        // 创建代理类，并将委托类1传入构造
        DynamicProxy dynamicProxy = new DynamicProxy(realSubject);
        ClassLoader classLoader = realSubject.getClass().getClassLoader();
        Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new Class[]{Subject.class}, dynamicProxy);
        subject.buyHuaWei();

        // 创建委托类2
        RealSubject2 realSubject2 = new RealSubject2();
        // 创建代理类，并将委托类2传入构造
        DynamicProxy dynamicProxy2 = new DynamicProxy(realSubject2);
        ClassLoader classLoader2 = realSubject2.getClass().getClassLoader();
        Subject2 subject2 = (Subject2) Proxy.newProxyInstance(classLoader2, new Class[]{Subject2.class}, dynamicProxy2);
        subject2.buyXiaomi();
    }
}

3、静态代理与动态代理的区别

静态代理中，代理类和委托类的关系是编码时运行前就确定了；而动态代理中，代理类与委托类的关系是在运行时通过反射才确定的
静态代理一般只代理一种目标委托对象，而动态代理可同时代理多个委托对象

4、Android中的使用场景

Retrofit
- retrofit.create(ApiService.class)中使用

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

              @Override
              public @Nullable 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);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });
  }