设计模式演化之动态代理

前言

在设计模式演化之代理模式中实现的代理模式是静态代理模式。静态的代理类由我们手动完成，在编译期间，代理类的功能就已经被完全确定下来了。而动态代理的代理类却是在运行期间根据我们给出的规则动态生成的，它可以更加方便的实现对代理类中方法的统一管理。

场景

1.基于静态代理，复杂化一下场景。先任意定义一个Service接口，它具备以下特点。

• 接口中有许多的方法
• 这些方法除各自的功能外，还有一些统一的处理逻辑
• 接口中的方法数量是动态变化的
• 方法的返回类型和参数类型和个数都没有要求

public interface Service {
    void method1(String text);
    void method2(String text);
    // ......
}

2.它有一个实现类MainService，功能很简单，就是把传入的text展示出来。

public class MainService implements Service {
    @Override
    public void method1(String text) {
        System.out.println(text);
    }

    @Override
    public void method2(String text) {
        System.out.println(text);
    }
    // ......
}

3.现在按照要求，需要给它的实现类添加统一的处理逻辑：在输出text之前，先输出数字-1。在这种情况下，想要定义一个Service的代理类，是极其困难的。我们需要在代理类的所有方法中都添加这个统一的实现逻辑。当方法的数量变化时，还需要同时修改代理类和被代理类。

public class ProxyService implements Service {
    
    private Service mService;

    public ProxyService() {
        this.mService = new MainService();
    }

    @Override
    public void method1(String text) {
        System.out.println("-1");
        mService.method1(text);
    }

    @Override
    public void method2(String text) {
        System.out.println("-1");
        mService.method2(text);
    }
       
    // ......
}

在这种情况下，就可以使用动态代理的方式，来简化这个过程。

实现

在Java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口。这二者是实现动态代理的核心部件。
Proxy中有一个newProxyInstance()方法

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
        Objects.requireNonNull(h);
        Class<?> caller = System.getSecurityManager() == null ? null : Reflection.getCallerClass();
        Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
        return newProxyInstance(caller, cons, h);
    }

以要传入的Service接口为例，（注意传入的只能是接口，如果是一个类将会报错）获取动态代理类的方法应该这样写。

public static void display() {
        Class<Service> service = Service.class;
        InvocationHandler serviceHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                return null;
            }
        };
        Service mService = (Service) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service }, serviceHandler);
        
        mService.method1("1");
        mService.method2("2");
    }

当代码运行到newProxyInstance()时，会自动生成一个实现了Service接口的代理类，并创建它的对象，赋值给mService。mService中的所有方法都会被实现， 但mService是自动生成的，我们无法修改。那么如何给代理类添加统一的控制逻辑呢？其实mService中自动实现的方法，实际上都是自动调用了InvocationHandler中的invoke()方法。如例

public final void method1() {
        try {
            // m1 是JVM自动根据method1获取的Method对象 
            this.h.invoke(this, m1, null);
            return;
        } // ...
    }

此时我们就可以通过定义InvocationHandler中的invoke()来实现给Service中的所有方法添加统一的行为了。如打印个数字-1 。

InvocationHandler serviceHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                System.out.println("-1");
                return null;
            }
        };

输出结果…

此时我们发现，我们的被代理类MainService丢失了，因此还需要在invoke()方法中补充对MainService的调用。

public static void display() {
        Class<Service> service = Service.class;

        MainService mainService = new MainService();
        InvocationHandler serviceHandler = new MyInvocationHandler<>(mainService);
        Service mService = (Service) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service}, serviceHandler);

        mService.method1("1");
        mService.method2("2");
    }

    public static class MyInvocationHandler<T> implements InvocationHandler {

        T mTarget;

        public MyInvocationHandler(T mTarget) {
            this.mTarget = mTarget;
        }

        @Override
        public Object invoke(Object o, Method method, Object[] args) throws Throwable {
            // 过滤掉继承自Object的方法 toString()等
            if (method.getDeclaringClass() == Object.class) {
                return null;
            }
            System.out.println("-1");
            // 调用传入的被代理类的方法
            Object result = method.invoke(mTarget, args);
            return result;
        }
    }

输出结果

此时，成功地将输出-1的逻辑插入到了Service的所有方法中去了。调用者以后就只需要关注Service接口和它的实现类了。

扩展

在上一节中，我们发现：使用动态代理可以在一个接口没有任何实现类的情况下，给它的所有方法添加上统一的处理方法。利用这个特性，我们可以让一个接口所有的方法具备我们想要的功能，且接口的方法变更时，再也不用做任何额外的操作了。

实战：简单模拟一下网络请求的功能。假设一个应用中有10个网络接口，请定义这10个网络接口的调用方法。

分析：网络请求的方法可以说是大同小异，差异无非是请求信息的组装过程。如URL，requestbody， 请求方式等，这些参数的组装规则是一定的。如果我们可以用动态代理的方式解析到这些参数进行组装，那么对于调用方来说，他们就可以完全实现以调用接口的形式来发起一个网络请求了。
retrofit2的示例代码如下：

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}

// 这里就是运用了动态代理的原理了
GitHubService service = retrofit.create(GitHubService.class);

它通过注解标注了动态代理时需要的参数信息，在InvocationHandler 中对这些注解进行了解析，组装，以及一次网络请求的后续工作。而对于调用者来说，仅仅是调用了service.listRepos()这个方法就完成了发起网络请求的过程。