设计模式(二)代理模式

2023-03-19 本文已影响0人文泰ChrisTwain

1.简介

Provide a surrogate or placeholder for another object to control access to it.为一个对象提供一种代理以控制对该对象的访问
---《Design Patterns: Elements of Reusable Object-Oriented Software设计模式-可复用的面向对象软件元素》

代理模式属于结构型设计模式：代理类和真实类实现同一个接口，代理类持有真实类引用，通过代理对象调用真实对象。类图如下所示：

proxy.png

代理模式与现实场景下的代理服务器类似，客户端无法直接访问目标服务器或不便于访问，通过代理服务器中转，达到访问控制目的。类图中客户端针对抽象主题角色进行编程，增加和更换代理类无须修改旧代码，符合开闭原则，达到降低代码解耦或扩展目标对象功能等目的。
代理模式分类
-- 静态代理：自行编写代理类，即程序运行前就已经存在代理类的字节码文件;
-- 动态代理：代理类在程序运行期间由JVM根据反射等机制动态的生成，不存在代理类的字节码文件

2.静态代理实现

/**
 * 被代理类接口声明
 */
public interface ISubject {
    void request();
}

/**
 * 定义被代理类
 */
public class SubjectImpl implements ISubject {
    @Override
    public void request() {
        Log.d("SubjectImpl", "被代理类");
    }
}

/**
 * 定义代理类
 */
public class Proxy implements ISubject {

    private ISubject subject;

    public Proxy(ISubject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        subject.request();
    }
}

// 客户端调用
ISubject proxy = new Proxy(new SubjectImpl());
proxy.request();

3.动态代理实现

这里通过JDK InvocationHandler实现动态代理，当然也有其它实现方式

public class DynamicProxy implements InvocationHandler {
    private Object proxyObject;

    // 传入被代理类作为参数，生成代理对象。将代理对象与此InvocationHandler关联，代理对象调用代理方法时将调用InvocationHandler#invoke()
    public <T> T newProxyInstance(Object proxyObject) {
        this.proxyObject = proxyObject;
        return (T) Proxy.newProxyInstance(proxyObject.getClass().getClassLoader(),
                proxyObject.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = method.invoke(proxyObject, args);
        // doing somthing else.
        return result;
    }
}

// 客户端调用，复用前面静态代理中定义的接口和被代理类
DynamicProxy dynamicProxy = new DynamicProxy();
ISubject proxy = dynamicProxy.newProxyInstance(new SubjectImpl());
proxy.request();

Proxy#newProxyInstance()参数说明
ClassLoader loader：指定产生代理对象的类加载器，与传入的proxyObject相同的类加载器
Class<?>[] interfaces：指定目标对象的实现接口，即要给目标对象提供一组调用接口
InvocationHandler h：指定关联的InvocationHandler对象，当代理对象proxy调用方法时能关联到invoke()方法
注意
newProxyInstance()方法返回值和invoke(Object proxy, ...)方法的第一个参数是真正生成的代理对象。
自动生成的代理对象实现了ISubject接口，通过proxy.request()调用时，方法的内部实现将调用InvocationHandler#invoke()方法并传递通过反射获取的方法名、参数等，最终在InvocationHandler#invoke()方法中执行自己的逻辑。
动态代理与静态代理相比有如下优点：不用对每个被代理类都手动写一个代理类，所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke），在接口方法数量比较多的时候，可以更灵活处理。
通过JDK提供的动态代理方式可以直接创建一个接口的实例，实际业务中可利用此方式做一些特殊操作，如Retrofit网络请求接口的实现(笔者不认为Retrofit使用了代理模式，只是使用了InvocationHandler的特性构造网络请求参数)：

  @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
  public <T> T create(final Class<T> service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(        // 通过JDK动态代理的方式生成网络请求接口的实例类
            service.getClassLoader(),
            new Class<?>[] {service},
            new InvocationHandler() {
              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;
                Platform platform = Platform.get();
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);    // 解析请求接口的注解和方法参数构造请求参数，生成OkHttp call
              }
            });
  }

通过动态代理方式也能实现如下调用：类似接口回调，调用系统接口时传入动态代理类，底层可反过来通过此代理类控制上层逻辑调用

private void init(Context context) {
    try {
        Class<?> cls = Class.forName("com.me.test.MyManager");  // Framework层提供管理类和接口
        Class callbackCls = Class.forName("com.me.test.MyManager$IMyCallback");
        Constructor constructorMyManager = cls.getConstructor(new Class[] {Context.class, callbackCls});

        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        Object objectCallback = Proxy.newProxyInstance(HostAbility.class.getClassLoader(),
                new Class[] {callbackCls}, myInvocationHandler);  // APK中完成接口实例化

        Object myManager = constructorMyManager.newInstance(new Object[] {context, objectCallback});  // 将生成的接口传给系统层
        RealManager realManager = (RealManager) myManager;  // apk可调用系统提供的管理类达到一定控制，系统被调用后也可控制触发apk相关逻辑在InvocationHandler中
    } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | IllegalArgumentException
            | InvocationTargetException | InstantiationException e) {
        Logger.e(TAG, "exception in reflecting callback");
    }
}

private class MyInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // checking
        if (args == null || args.length < LENGTH) {
            Logger.e(TAG, "unexpected callback!");
            return null;
        }

        // 获取参数
        long p1 = ((Long) args[0]);
        int p2 = ((Integer) args[1]);
        int p3 = ((Integer) args[2]);

        // doing something 由系统在Framework层调用接口后回调到APK中执行，达到由系统层控制上层业务
        return null;
    }
}

参考

refactoringguru-代理模式
 从Retrofit看懂动态代理模式
 一定能看懂的 Retrofit 最详细的源码解析
 深入理解Retrofit动态代理
 枚举、动态代理的原理

设计模式(二)代理模式

1.简介

2.静态代理实现

3.动态代理实现

参考

猜你喜欢

热点阅读