阅读 52

设计模式之代理模式

代理模式为另一个对象提供一个替身以控制对这个对象的访问。从定义可以看出,1. 代理模式提供了一个替身,即代理对象 2. 代理对象是为了控制对另一个对象(真实对象)的访问,控制可以理解为做权限检查、可行性判断等。举个例子,代理对象 = 经纪人,真实对象 = 明星,如果某剧组想邀请明星出演电影,先将剧本给经纪人,经纪人先判断剧组的真实性以及剧本的价值,如果是无良剧组或者垃圾剧本直接怼回去,这便是控制。如果剧组和剧本靠谱便转交给明星处理,明星确定演不演把结果反馈给经纪人,经纪人再反馈结果给剧组,这个过程就可以理解为代理模式。代理模式有很多种,包括动态代理、远程代理、虚拟代理等等,本章我们详细介绍动态代理(Java版),简单介绍远程代理和虚拟代理。

动态代理

之所以叫动态是因为运行时才将代理类创建出来。我们先由一个简单的需求引入动态代理技术,同时也会介绍面向对象设计原则。需求如下:在我们的业务当中,需要将某些数据写入本地磁盘做持久化,因此程序中需要封装一个写文件的类来满足业务需求。前期的业务很简单,我们只需要定义能够提供写入文件的方法即可。因此,首先定义一个 Writer 接口,包含不同的写方法,其次定义一个该接口的实现类,实现该接口定义的方法。

package com.cnblogs.duma.dp.proxy.dynamic;

public interface Writer {
    public void write(String fileName, String str);
    public void write(String fileName, byte[] bs);
}复制代码
package com.cnblogs.duma.dp.proxy.dynamic;

public class FileWriter implements Writer {
    @Override
    public void write(String fileName, String str) {
        System.out.println("call write str in FileWriter");
    }

    @Override
    public void write(String fileName, byte[] bs) {
        System.out.println("call write bytes in FileWriter");
    }
}复制代码

之后我们用 Writer writer = new FileWriter(); 就可以完成向本地文件写数据的功能了。这里其实不定义接口也能实现这个功能,至于为什么要定义接口下文会有解释。至此,我们的小需求完成了,也上线了并能正常运行。突然有一天运维小哥说了,为了保证 xxx ,需要在服务器预留 100G 磁盘空间, 也就是说我们的应用程序写磁盘的时候要判断已有的磁盘空间,如果快到了 100G 临界值,就不能再写了。因此,我们需要改代码,写之前加上一个判断当前可用的磁盘空间的逻辑,本来我们可以直接改 FileWriter 的代码。但存在两个问题 1. 改现有代码风险高,可能改动过程中影响原有逻辑,并且要重新进行单元测试 2. 这个需求比较牵强,跟我们的实际业务无关,直接放在业务代码里面导致耦合度比较大,不利于维护。因此,我们可以考虑使用代理模式解决这个问题,即可以保证现有代码不动,又可以低耦合地实现目前的需求。

package com.cnblogs.duma.dp.proxy.dynamic;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class FileWriterInvocationHandler implements InvocationHandler {
    Writer writer = null;

    public FileWriterInvocationHandler(Writer writer) {
        this.writer = writer;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
        boolean localNoSpace = false;
        System.out.println("check local filesystem space."); //检测磁盘空间代码,返回值可以更新 localNoSpace 变量
        if (localNoSpace) {
            throw new Exception("no space."); //如果空间不足,抛出空间不足的异常
        }
        return method.invoke(writer, args); //调用真实对象(FileWriter)的方法
    }
}复制代码

可以看到只增加了一个类,这个类有个特点 1. 它实现了 InvocationHandler 接口 2. 它的 invoke 方法实现了我们的需求并控制是否要调用真实对象。InvocationHandler 是 Java 动态代理定义的一个接口,接口中定义了一个 invoke 方法,我们调用代理对象的任何方法都会变成对 FileWriterInvocationHandler 对象的 invoke 方法的调用, invoke 方法就是代理要做的事情。如果看到你觉得一头雾水,没关系继续向下看将豁然开朗。

到目前为止我们只看到新增了一个 InvocationHandler 接口的实现类,并没有看到代理对象。之前说过之所以是动态代理是因为在运行时才创建代理类,因此我们需要编写一个驱动程序,动态创建代理对象,完成动态代理的后半部分。

package com.cnblogs.duma.dp.proxy.dynamic;

import java.lang.reflect.Proxy;

public class DynamicProxyDriver {
    public static void main(String[] args) {
        /**
         * Proxy.newProxyInstance 包括三个参数
         * 第一个参数:定义代理类的 classloader,一般用被代理接口的 classloader
         * 第二个参数:需要被代理的接口列表
         * 第三个参数:实现了 InvocationHandler 接口的对象
         * 返回值:代理对象
         */
        Writer writer = (Writer) Proxy.newProxyInstance(
                Writer.class.getClassLoader(),
                new Class[]{Writer.class},
                new FileWriterInvocationHandler(new FileWriter())); //这就是动态的原因,运行时才创建代理类

        try {
            writer.write("file1.txt", "text"); //调用代理对象的write方法
        } catch (Exception e) {
            e.printStackTrace();
        }
        writer.write("file2.txt", new byte[]{}); //调用代理对象的write方法
    }
}复制代码

最关的一步是 Proxy.newProxyInstance ,该调用会创建代理对象,该代理对象会将我们需要代理的接口(Writer)和 InvocationHandler 实现类关联起来。这样代理对象就会有 Writer 接口的 2 个方法,针对我们的业务逻辑调用过程为:调用代理对象 writer 的 write 方法写数据 -> 转到 FileWriterInvocationHandler 对象的 invoke 方法,判断磁盘空间是否够用 -> 抛出磁盘空间不足异常或调用 FileWriter 对象的 write 方法写数据。在这里动态代理涉及到了 Writer 接口及其实现类、InvocationHandler 接口及其实现类、代理类。动态代理 UML 类图如下:

可以看到代理类 Proxy 实现了 Writer 接口,因此可以调用 write 方法,同时代理类关联 FileWriterInvocationHandler ,因此对 write 方法的调用会变成对 invoke 方法的调用。

至此,新的需求就完成了,我们结合代理模式谈谈此次需求变更我们用到了哪些好的设计原则。

1. 我们没有在原有 FileWriter 实现类中修改代码, 而是新增了 FileInvocationHandler 实现新需求,这符合设计原则中的开闭原则,即:对扩展开发对修改封闭。改动现有代码容易影响已有的正常代码

2. 我们增加代理之后只是把 Writer writer = new FileWriter() 改为 Writer writer = Proxy.newProxyInstance(...),由于都继承了 Writer 接口,因此不需要修改 writer 的类型, 这符合面向接口的设计原则,让我们尽量少的改动现有代码

动态代理还有一个重要的应用场景,我们可以在 invoke 方法中把待调用的方法名(method)和参数(args)发送到远程服务器,在远程服务器中完成调用并返回一个结果,这其实就是 RPC (remote procedure call),即:远程过程调用。我在阅读 Hadoop 源码过程中发现 Hadoop RPC 将动态代理技术应用在上述场景中。

远程代理

个人觉得上述动态代理第二个应用场景算是远程代理的一个特例,因为远程代理不一定非要动态创建代理对象。接下来我们以 Java RMI 为例, 简单看下远程代理。RMI(remote method invocation)即:远程方法调用,与 RPC 类似,可以让我们像调用 Java 本地方法一样,调用远程的方法。这里就需要一个代理对象,它实现了本地的接口,其中序列化/反序列化以及网络传输都在代理对象中实现, 对我们透明,这也是控制了我们对远程对象的访问。代码如下:

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * 定义一个接口,接口中的方法要在远程调用
 */
public interface MyRemote extends Remote {
    public String sayHello() throws RemoteException;
}复制代码
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

/**
 * 定义一个接口的远程实现类
 * 为了让远程对象拥有 “远程的” 功能,需要继承 UnicastRemoteObject 类
 */
public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote {

    protected MyRemoteImpl() throws RemoteException {
    }

    /**
     * 客户端通过 rmi 代理对象调用 sayHello 方法,将会进入到此方法
     * @return
     * @throws RemoteException
     */
    @Override
    public String sayHello() throws RemoteException {
        System.out.println("req from client.");
        return "Server says, 'Hey'";
    }

    /**
     * 启动远程进程的 main 方法
     * @param args
     */
    public static void main(String[] args) {
        try {
            MyRemote service = new MyRemoteImpl();
            Naming.rebind("RemoteHello", service); //将服务名和对应的服务进行绑定,客户端会根据 RemoteHello 找到远程服务
        } catch (RemoteException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}复制代码

这样我们的远程服务已经写好了,还需要做以下 3 个工作来启动远程服务

1. 生成客户端代理类,需要在 MyRemoteImpl.class 所在的目录中执行 rmic MyRemoteImpl 命令,将会生成 MyRemoteImpl_Stub.class 类。首先,rmic 命令是 jdk 自带命令,所在的目录与 java 和 javac 所在的目录一样;其次,我用的 Idea 创建的普通 Java 工程,我的 MyRemoteImpl.class 文件在“E:\backends\java-backends\java-ex\out\production\java-ex”目录中,以我的工程为例,路径以及命令执行如下:

E:\backends\java-backends\java-ex\out\production\java-ex>rmic MyRemoteImpl复制代码

2. 启动 rmiregistry,为了远程服务可以注册服务名,在我们的 class 所在的目录(“项目目录\out\production\java-ex”)中执行 rmiregistry 命令

E:\backends\java-backends\java-ex\out\production\java-ex>rmiregistry复制代码

3. 运行 MyRemoteImpl 类,启动远程服务进程

继续编写客户端访问代码,客户端代码主要是找到刚刚注册的 RemoteHello 远程服务,并获得代理对象,调用代理对象上的方法。我们可以在同一个工程下,创建 MyRemoteClient 类

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;

public class MyRemoteClient {
    public static void main(String[] args) {
        try {
            /**
             * 找到远程服务,并返回代理对象
             * 该代理对象就是 MyRemoteImpl_Stub 且实现了 MyRemote 接口
             */
            MyRemote service = (MyRemote) Naming.lookup("rmi://127.0.0.1/RemoteHello");
            /**
             * 调用代理对象的 sayHello 方法,便会通过代理将调用发送到远程服务进程并返回结果
             */
            String ret = service.sayHello();
            System.out.println(ret); 
        } catch (RemoteException e) {
            e.printStackTrace();
        } catch (NotBoundException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}复制代码

我们可以直接运行 MyRemoteClient 类,可以看到在刚启动的 MyRemoteImpl 进程中,控制台打印了

req from client.复制代码

在 MyRemoteClient 进程的控制台中打印了

Server says, 'Hey'复制代码

至此我们的远程代理已经介绍完毕。

虚拟代理

虚拟代理是作为创建开销大的对象的替身。举一个我们常见的例子,在 Web 开发或者移动端开发的时候经常会用到 Image 组件,Image 组件一般要传入一个 URL 参数,从网络上下载图片到本地展示。假设这个组件要等到图片下载完成才有显示,那如果图片较大或者网络较慢,给用户造成不好的体验。解决方法是我们可以先显示一个 loading 状态的默认的本地图片,当远程图片下载完成后重新渲染,替换掉当前的 laoding 状态的图片。用虚拟代理来实现这个技术就可以定义一个 ImageProxy 类型,在该类中初始时候先展示一个默认图片,启动线程创建 Image 对象,Image 对象创建完毕,再重新渲染,替换默认图片。虚拟代理也是控制了对 Image 对象的访问。

总结

本章主要介绍了代理模式,并且我们看到了代理模式常用的几种变形,同时也接触了面向对象的基本的设计原则

动态代理 - 程序运行时动态地创建代理对象,所有的对代理对象方法的调用都会变成对 InvocationHandler 的 invoke 方法的调用

远程代理 - 本地调用代理对象访问远程的方法,无需关心网络通信细节,跟调用本地方法一样

虚拟代理 - 为了创建开销大的对象而存在

可以看到代理模式最核心就是控制,代理对象的目的就是控制对真实对象的访问。

本章主要参考《Head First 设计模式》

公众号「渡码」