设计模式

一、代理模式的定义

为其他对象提供一种代理以控制对这个对象的访问
1、可以在执行前后增加一些逻辑比如 统计、log，
2、可以对参数进行优化或更改

二、代理模式的使用场景

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

三、静态代理模式

只能为给定接口的实现类做代理，如果接口不同则需要重新定义不同的代理类。（在代码运行前代理类的class编译文件就已经存在）
特点

• 1个静态代理 只服务1种类型的目标对象
• 若要服务多类型的目标对象，则需要为每种目标对象都实现一个静态代理对象

不足：
在目标对象较多的情况下，若采用静态代理，则会出现 静态代理对象量多、代码量大，从而导致代码复杂的问题

3.0 UML类图 & 组成

944365-3e4cc2f9c34a64cc.png
场景：

• 背景：小成希望买一台最新的顶配Mac电脑
• 冲突：国内还没上，只有美国才有
• 解决方案：寻找代购进行购买

代购（代理对象） 代替 我（真实对象） 去买Mac（间接访问的操作）

3.1给定代理的接口

public interface ICode {
    void code();
}

3.2 接口实现类

public class XiaoMin implements ICode {
    @Override
    public void code() {
        System.out.print("码代码");
    }
}

3.3 代理类

public class RobotProxy implements ICode {
    private ICode mCode;

    public RobotProxy(ICode code) {
        this.mCode = code;
    }

    @Override
    public void code() {
        before();
        mCode.code();
        after();
    }
    void before() {
        System.out.println("概要设计");
    }

    void after() {
        System.out.println("测试");

    }
}

3.4 客户端使用

public class Client {
    public static void main(String[] args){
        //构造小民
        XiaoMin xiaoMin = new XiaoMin();
        //构造代理机器 将小民作为参数传递进去
        RobotProxy robot = new RobotProxy(xiaoMin);
        //机器代小民码代码
        robot.code();
    }
}

3.5 优缺点

优点

• 协调调用者和被调用者，降低了系统的耦合度
• 代理对象作为客户端和目标对象之间的中介，起到了保护目标对象的作用

缺点

• 由于在客户端和真实主题之间增加了代理对象，因此会造成请求的处理速度变慢；

• 实现代理模式需要额外的工作（有些代理模式的实现非常复杂），从而增加了系统实现的复杂度。

  
  944365-6ab7f58ee0497fdd.png

四、动态代理

• 设计动态代理类（DynamicProxy）时，不需要显式实现与目标对象类（RealSubject）相同的接口，而是将这种实现推迟到程序运行时由 JVM来实现
• 通过Java反射机制的method.invoke（），通过调用动态代理类对象方法，从而自动调用目标对象的方法

4.0 优缺点

优点

• 只需要1个动态代理类就可以解决创建多个
• 静态代理的问题，避免重复、多余代码
  更强的灵活性

1. 设计动态代理类（DynamicProxy）时，不需要显式实现与目标对象类（RealSubject）相同的接口，而是将这种实现推迟到程序运行时由 JVM来实现
2. 在使用时（调用目标对象方法时）才会动态创建动态代理类 & 实例，不需要事先实例化

缺点

• 效率低
  相比静态代理中 直接调用目标对象方法，动态代理则需要先通过java反射机制 从而 间接调用目标对象方法
• 应用场景局限
  因为Java的单继承特性（每个代理类都继承了 Proxy 类），即只能针对接口创建 代理类，不能针对类 创建代理类

即只能动态代理 实现了接口的类

4.1应用场景

• 基于静态代理应用场景下，需要代理对象数量较多的情况下使用动态代理
• AOP 领域

1. 定义：即 Aspect Oriented Programming= 面向切面编程，是OOP的延续、函数式编程的一种衍生范型
2. 作用：通过预编译方式和运行期动态代理实现程序功能的统一维护。
3. 优点：降低业务逻辑各部分之间的耦合度 、 提高程序的可重用性 & 提高了开发的效率
4. 具体应用场景：日志记录、性能统计、安全控制、异常处理等

4.2 动态代理与静态代理模式的区别

动态代理与静态代理模式的区别.png

4.3 具体应用

4.1 实例概况

• 背景：小成 希望买一台最新的顶配 Mac 电脑；小何希望买一台 iPhone
• 冲突：国内还没上，只有美国才有
• 解决方案：寻找一个代购一起进行购买

1. 即1个代购（动态代理对象）同时 代替 小成 & 小何（目标对象） 去买Mac（间接访问的操作）
2. 该代购是代购任何商品 = 什么人有什么需求就会去代购任何东西（动态代理）

4.2 使用步骤

1. 声明 调用处理器类
2. 声明目标对象类的抽象接口
3. 声明目标对象类
4. 通过动态代理对象，调用目标对象的方法

4.3 步骤详解

步骤1： 声明 调用处理器类DynamicProxy.java

<-- 作用 -->
// 1.  生成 动态代理对象
// 2.  指定 代理对象运行目标对象方法时需要完成的 具体任务
// 注：需实现InvocationHandler接口 = 调用处理器 接口
// 所以称为 调用处理器类

 public class DynamicProxy implements InvocationHandler {

    // 声明代理对象
    // 作用：绑定关系，即关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke（）
    private Object ProxyObject;

    public Object newProxyInstance(Object ProxyObject){
        this.ProxyObject =ProxyObject;
        return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
                ProxyObject.getClass().getInterfaces(),this);
        // Proxy类 = 动态代理类的主类 
        // Proxy.newProxyInstance（）作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类实例，并最终返回
        // 参数说明：
        // 参数1：指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
        // 参数2：指定目标对象的实现接口
        // 即要给目标对象提供一组什么接口。若提供了一组接口给它，那么该代理对象就默认实现了该接口，这样就能调用这组接口中的方法
        // 参数3：指定InvocationHandler对象。即动态代理对象在调用方法时，会关联到哪个InvocationHandler对象

    }

    //  复写InvocationHandler接口的invoke（）
    //  动态代理对象调用目标对象的任何方法前，都会调用调用处理器类的invoke（）
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            // 参数说明：
            // 参数1：动态代理对象（即哪个动态代理对象调用了method（）
            // 参数2：目标对象被调用的方法
            // 参数3：指定被调用方法的参数
            throws Throwable {
                System.out.println("代购出门了");
                Object result = null;
                 before();
                // 通过Java反射机制调用目标对象方法
                result = method.invoke(ProxyObject, args);
                after();
        return result;
    }
    void before() {
        System.out.println("概要设计");
    }

    void after() {
        System.out.println("测试");

    }

}

步骤2： 声明目标对象的抽象接口Subject.java

public interface Subject {
    // 定义目标对象的接口方法
    // 代购物品
    public  void buybuybuy();

}

步骤3： 声明目标对象类
Buyer1.java

// 小成，真正的想买Mac的对象 = 目标对象 = 被代理的对象
// 实现抽象目标对象的接口
public class Buyer1 implements Subject  {

    @Override
    public void buybuybuy() {
        System.out.println("小成要买Mac");
    }

}

Buyer2.java

// 小何，真正的想买iPhone的对象 = 目标对象 = 被代理的对象
// 实现抽象目标对象的接口
public class Buyer2 implements Subject  {

    @Override
    public void buybuybuy() {
        System.out.println("小何要买iPhone");
    }

}

步骤4： 通过动态代理对象，调用目标对象的方法
MainActivity.java

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 1. 创建调用处理器类对象
        DynamicProxy DynamicProxy = new DynamicProxy();

        // 2. 创建目标对象对象
        Buyer1 mBuyer1 = new Buyer1();

        // 3. 创建动态代理类 & 对象：通过调用处理器类对象newProxyInstance（）
        // 传入上述目标对象对象
        Subject Buyer1_DynamicProxy = (Subject) DynamicProxy.newProxyInstance(mBuyer1);

        // 4. 通过调用动态代理对象方法从而调用目标对象方法
        // 实际上是调用了invoke（），再通过invoke（）里的反射机制调用目标对象的方法
        Buyer1_DynamicProxy.buybuybuy();
        // 以上代购为小成代购Mac

        // 以下是代购为小何代购iPhone
        Buyer2 mBuyer2 = new Buyer2();
        Subject Buyer2_DynamicProxy = (Subject) DynamicProxy.newProxyInstance(mBuyer2);
        Buyer2_DynamicProxy.buybuybuy();
    }
}

4.5 源码分析

• 在经过上面的实例后，你是否会对以下问题好奇：

1. 动态代理类 及其对象实例是如何生成的？
2. 如何通过调用动态代理对象方法，从而调用目标对象方法？

4.5.1 newProxyInstance()

总结

• 通过调用处理器类对象的.newProxyInstance()创建动态代理类 及其实例对象（需传入目标类对象）
• 具体过程如下：

1. 通过 为Proy类指定类加载器对象 & 一组接口，从而创建动态代理类的字节码；再根据类字节码创建动态代理类
2. 通过反射机制获取动态代理类的构造函数（参数类型 = 调用处理器接口类型
3. 通过动态代理类的构造函数 创建 代理类实例（传入调用处理器对象

<-- 关注2：newProxyInstance（）源码解析-->
// 作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类及其对象实例，并最终返回
      
public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException { 
  // 参数说明：
        // 参数1：指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
        // 参数2：指定目标对象的实现接口
        // 即要给目标对象提供一组什么接口。若提供了一组接口给它，那么该代理对象就默认实现了该接口，这样就能调用这组接口中的方法
        // 参数3：指定InvocationHandler对象。即动态代理对象在调用方法时，会关联到哪个InvocationHandler对象

    ...  
    // 仅贴出核心代码

    // 1. 通过 为Proxy类指定类加载器对象 & 一组interface，从而创建动态代理类
    // >>关注3
    Class cl = getProxyClass(loader, interfaces); 

    // 2. 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
    Constructor cons = cl.getConstructor(constructorParams); 

    // 3. 通过动态代理类的构造函数 创建 代理类实例（传入调用处理器对象
    return (Object) cons.newInstance(new Object[] { h }); 

// 特别注意 
// 1. 动态代理类继承 Proxy 类 & 并实现了在Proxy.newProxyInstance()中提供的一系列接口（接口数组）
// 2. Proxy 类中有一个映射表
  // 映射关系为：(<ClassLoader>,(<Interfaces>,<ProxyClass>) )
  // 即：1级key = 类加载器，根据1级key 得到 2级key = 接口数组
  // 因此：1类加载器对象 + 1接口数组 = 确定了一个代理类实例
...

// 回到调用关注2的原处
}

<-- 关注3：getProxyClass（）源码分析 -->
// 作用：创建动态代理类

public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)  
throws IllegalArgumentException { 
    
  ...
  // 仅贴出关键代码
  
<-- 1. 将目标类所实现的接口加载到内存中 -->
    // 遍历目标类所实现的接口  
    for (int i = 0; i < interfaces.length; i++) {  
          
        // 获取目标类实现的接口名称 
        String interfaceName = interfaces[i].getName();  
        Class interfaceClass = null;  
        try {  
        // 加载目标类实现的接口到内存中  
        interfaceClass = Class.forName(interfaceName, false, loader);  
        } catch (ClassNotFoundException e) {  
        }  
        if (interfaceClass != interfaces[i]) {  
        throw new IllegalArgumentException(  
            interfaces[i] + " is not visible from class loader");  
        }  
    }  
       
<-- 2. 生成动态代理类 -->       
        // 根据传入的接口 & 代理对象 创建动态代理类的字节码 生成的动态类记为 ：`$Proxy0`,实现：与目标对象一样的接口(重点)
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(  
            proxyName, interfaces);  

            // 根据动态代理类的字节码 生成 动态代理类
            proxyClass = defineClass0(loader, proxyName,  
            proxyClassFile, 0, proxyClassFile.length);  
       
        }  
    // 最终返回动态代理类
    return proxyClass;  
    }  

// 回到调用关注3的原处

JDK动态代理[4]----ProxyGenerator生成代理类的字节码文件解析

/* renamed from: $Proxy0 */
public final class $Proxy0 extends Proxy implements Programmer {
    private static Method m0;
    private static Method m1;
    private static Method m2;
    private static Method m3;

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.example.proxy.Programmer").getMethod("code", new Class[]{Class.forName("java.lang.String")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        } catch (ClassNotFoundException e2) {
            throw new NoClassDefFoundError(e2.getMessage());
        }
    }

    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }

    public final void code(String str) {
        try {
            this.h.invoke(this, m3, new Object[]{str});
        } catch (Error | RuntimeException e) {
            throw e;
        } catch (Throwable e2) {
            UndeclaredThrowableException undeclaredThrowableException = new UndeclaredThrowableException(e2);
        }
    }

    public final boolean equals(Object obj) {
        try {
            return ((Boolean) this.h.invoke(this, m1, new Object[]{obj})).booleanValue();
        } catch (Error | RuntimeException e) {
            throw e;
        } catch (Throwable e2) {
            UndeclaredThrowableException undeclaredThrowableException = new UndeclaredThrowableException(e2);
        }
    }

    public final int hashCode() {
        try {
            return ((Integer) this.h.invoke(this, m0, null)).intValue();
        } catch (Error | RuntimeException e) {
            throw e;
        } catch (Throwable e2) {
            UndeclaredThrowableException undeclaredThrowableException = new UndeclaredThrowableException(e2);
        }
    }

    public final String toString() {
        try {
            return (String) this.h.invoke(this, m2, null);
        } catch (Error | RuntimeException e) {
            throw e;
        } catch (Throwable e2) {
            UndeclaredThrowableException undeclaredThrowableException = new UndeclaredThrowableException(e2);
        }
    }
}

4.5.2 通过调用动态代理对象方法从而调用目标对象方法

即，如何通过调用动态代理对象方法，从而调用目标对象方法？

// 使用代码
Buyer1_DynamicProxy.buybuybuy();

在关注1中的 DynamicProxy.newProxyInstance()生成了一个动态代理类 及其实例

该动态代理类记为 ：$Proxy0
下面我们直接看该类实现及其 buybuybuy()
总结

• 动态代理类实现了与目标类一样的接口，并实现了需要目标类对象需要调用的方法
• 该方法的实现逻辑 = 调用父类 Proxy类的h.invoke（）

其中h参数 = 在创建动态代理实例中newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象

• 在 InvocationHandler.invoke（） 中通过反射机制，从而调用目标类对象的方法

• 该方法的逻辑如下：

<-- 动态代理类 $Proxy0 实现-->
// 继承：Java 动态代理机制的主类：java.lang.reflect.Proxy
// 实现：与目标对象一样的接口（即上文例子的Subject接口）
public final class $Proxy0 extends Proxy implements Subject {

// 构造函数
public ProxySubject(InvocationHandler invocationhandler)   
    {   
        super(invocationhandler);   
    }  

 // buybuybuy（）是目标对象实现接口（Subject）中的方法
 // 即$Proxy0类必须实现
 // 所以在使用动态代理类对象时，才可以调用目标对象的同名方法（即上文的buybuybuy（））
 public final void buybuybuy（） {
        try {
            super.h.invoke(this, m3, null); 
            // 该方法的逻辑实际上是调用了父类Proxy类的h参数的invoke（）
            // h参数即在Proxy.newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象
            // 即调用了调用处理器的InvocationHandler.invoke（）
            // 而复写的invoke（）利用反射机制：Object result=method.invoke(proxied,args)
            // 从而调用目标对象的的方法 ->>关注4
            return;
        } catch (Error e) {
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

<-- 关注4：调用处理器 类复写的invoke（） -->
// 即步骤1中实现的类：DynamicProxy
// 内容很多都分析过了，直接跳到复写的invoke（）中

 public class DynamicProxy implements InvocationHandler {

    private Object ProxyObject;

    public Object newProxyInstance(Object ProxyObject){
        this.ProxyObject =ProxyObject;
        return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
                ProxyObject.getClass().getInterfaces(),this);
     

    }

    //  复写InvocationHandler接口的invoke（）
    //  动态代理对象调用目标对象的任何方法前，都会调用调用处理器类的invoke（）
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            // 参数说明：
            // 参数1：动态代理对象（即哪个动态代理对象调用了method（）
            // 参数2：目标对象被调用的方法
            // 参数3：指定被调用方法的参数
            throws Throwable {
                System.out.println("代购出门了");
                Object result = null;
                // 通过Java反射机制调用目标对象方法
                result = method.invoke(ProxyObject, args);
        return result;
    }

4.6 原理总结

944365-cc589d9cdacb5425.png

代理模式的应用场景

1. 业务系统的非功能性需求开发

在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。

我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只需要关注业务方面的开发。

2. 代理模式在 RPC、缓存中的应用

RPC 框架也可以看作一种代理模式，

代理模式。它在不改变原始类（或者叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。

代理模式中，代理类附加的是跟原始类无关的功能，

retrofit中动态代理使用

通过动态代理Class<T> service的代理对象。
在进行方法调用时，解析参数，生成OkHttpCall对象进行请求
动态代理可以动态生成服务对象代理类，对方法进行统一实现和策略修改

retrofit2.6.0
举例服务对象

public interface AuthenticationService {
    /**
     * 设备鉴权
     */
    @POST("device/auth")
    Observable<Authentication> deviceAuthentication(@QueryMap Map<String, String> map);
}

RetrofitManager.getInstance().create(AuthenticationService.class);

[Retrofit.java]

  @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
  public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      // 是否立即对 Service 方法的内容进行解析
      eagerlyValidateMethods(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 {
            // 该方法是 Object 的方法，直接触发该方法
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            //如果是 default 方法，那么使用该 Java8 平台的方法执行
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });
  }

ServiceMethod是缓存到了一个Map中，首先会通过Map获取其实例，如果Map中有其实例，就直接返回，否者创建一个缓存到Map中
[Retrofit.java]

  ServiceMethod<?> loadServiceMethod(Method method) {
    //如果缓存中有则直接取缓存，否则创建
    ServiceMethod<?> result = serviceMethodCache.get(method);
    if (result != null) return result;
    //加锁
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        //根据method得到对应的ServiceMethod，并加入缓存
        result = ServiceMethod.parseAnnotations(this, method);
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

[ServiceMethod.java]

  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(method,
          "Method return type must not include a type variable or wildcard: %s", returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }

    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

核心是调用HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
[ServiceMethod.java]

  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(method,
          "Method return type must not include a type variable or wildcard: %s", returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }

    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    ...
}

来看一下
[ServiceMethod.java]

  abstract @Nullable T invoke(Object[] args);

[HttpServiceMethod.java]

//abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT>
  @Override final @Nullable ReturnT invoke(Object[] args) {
    Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    return adapt(call, args);
  }

参考

代理模式（Proxy Pattern）：动态代理 - 最易懂的设计模式解析
代理模式（Proxy Pattern）：静态代理 - 最易懂的设计模式解析