1. 定义

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

2. UML类图

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

3. 使用场景

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

4. 代理模式之静态代理

现在有一个场景：一个海外留学者想在中国买一部华为手机，自己回来买显然成本很大，所以他需要找一个在国内专门代购华为手机的人帮忙代购，这便可以用到代理模式来实现
这里抽象主题类里的抽象方法便是购买华为手机

/**
 * 定义一个抽象对象接口，抽象方法表示要代理做的事
 *
 * @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("我是美国佬，我要买华为Mate40");
    }
}

同时代理类（国内代购）也得实现该方法，并持有委托类（留学者）的引用，是实现具体的抽象类（购买华为），实现除了满足留学者的需求外，还需要做一些额外的操作，譬如收取代购费，买完后得寄国际物流等

/**
 * 代理类
 *
 * @author LTP  2021/11/9
 */
public class Proxy implements Subject {
    // 持有接口类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();
    }
}

执行结果：
收取代购费用
我是美国佬，我要买华为
快递代理货物

这样整个代理逻辑就结束了，假如还有另外的购买华为的留学者，直接让他去实现Subject抽象代理类，在客户端调用新增一个委托类对象给代理类代理购买即可，整个过程无需修改代理类的代码（代理类都实现了Subject接口）
但现在面临一个新的需求，有的留学者想购买小米（假设一个代购只代购一种品牌的手机），就得新增一个Subject接口、这样就必须新增一个新的代理类持有新增的Subject引用，这样便会新增更多的Proxy，或是修改原有的Proxy实现新的需求Subject，这也正是静态代理的弊端
为了解决每新增一个Subject都要新增一个代理类/修改代理类代码的弊端，就可以用到动态代理的方式了，他可以只用一种代理来满足你更多新的需求（subject）

5. 代理模式之动态代理

为了更方便的实现动态代理，Java也提供了一个方便实现这种需求的动态代理接口InvocationHandler，让代理类实现它即可

/**
 * 代理类
 *
 * @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;
    }
}

这样一个动态代理类便完成了，动态代理类持有的引用是一个Java祖先类Object类型的引用，所以便可以为任何委托类实现代理
新增一个购买小米的需求Subject类

/**
 * 定义一个抽象对象接口，抽象方法表示要代理做的事
 *
 * @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("我是美国佬，我要买小米12pro");
    }
}

使用了动态代理后，就无需再新建一个代理类/修改原有代理类代码来完成对购买小米的代理，直接使用动态代理类即可
使用动态代理的客户端调用当然也会有所改变，它会使用到反射的方式去调用

/**
 * 实际调用动态代理的位置
 * 动态代理中，代理类与委托类的关系是运行时才确定的，
 * 代理对象可同时代理多个任务而不需要修改代理类的源码，只需要添加新的委托类以及委托方法即可，可同时代理多个类型的目标对象
 *
 * @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();
    }
}

执行结果：
收取代购费用
我是美国佬，我要买华为
快递代理货物
收取代购费用
我是美国佬，我要买小米
快递代理货物

客户端中会借助Java提供的Proxy类调用newProxyInstance()方法去获取Subject实现类，然后调用实现方法即可，比较完整个过程便会发现静态代理与动态代理的区别就是代理类是否需要针对新的需求（Subject）而创建新的代理类/修改代理类的区别

5. 代理模式的类型

静态代理与动态代理是从编码方式来区分代理模式的两种区别，我们也可按照适用范围来区分不同类型的代理实现

远程代理：为一个对象在不同的地址空间提供局部代理，使系统可以将Server部分的事项隐藏，以便Client可以不必考虑Server的存在
虚拟代理：使用一个代理对象表示一个十分耗资源的对象并在真正需要时才创建
保护代理：使用代理控制对原始对象的访问，该类型的代理常被用于原始对象有不同访问权限的情况
智能代理：当调用真实的对象时，代理处理另外一些事，比如计算真实对象的引用计数，当该对象没有引用时，可以自动释放它；或者访问一个实际对象时，检查是否已经能够锁定它，以确保其他对象不能改变它。

6. 静态代理与动态代理的区别总结

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

7. 源码中的使用场景

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);
              }
            });
  }

ActivityManagerProxy代理ActivityManagerService

8. 优缺点

优点：
- 通过代理可以间接地访问无法被访问或不想直接被访问或被访问有困难的对象
缺点：
- 产生多余的代理类

设计模式~代理模式

1. 定义

2. UML类图

3. 使用场景

4. 代理模式之静态代理

5. 代理模式之动态代理

5. 代理模式的类型

6. 静态代理与动态代理的区别总结

7. 源码中的使用场景

8. 优缺点