探索 JDK RMI

RMI(Remote Method Invoke)是 JDK 自带的一个远程调用框架,可以基于 RMI 构建自己的分布式应用。现在很多分布式服务框架都会选择支持 RMI 协议,比如 dubbo,spring rmi,Hessian 等 RPC 框架。为了对 RMI 有更多的了解,下面我们一起来读代码。

一、代码示例

为了更直观的了解 RMI 的使用,先来看一段代码。
新建三个 maven 工程,分别是 rmiclient,rmidependency,rmiserver,其中 rmiclient 是客服端,rmiserver 是服务端,rmidependency 是一个只包含接口的服务工程。rmiclient 和 rmiserver 引入 rmidependency 依赖。rmidependency 中 HelloWorldService 接口如下:

public interface HelloWorldService extends Remote {
    public String sayHello(String from, String to) throws RemoteException;
}

rmiserver 中 HelloWordServiceImpl 实现了 HelloWorldService 接口的类:

public class HelloWorldServiceImpl extends UnicastRemoteObject implements HelloWorldService {
    public HelloWorldServiceImpl() throws RemoteException {
        super();
    }
    @Override
    public String sayHello(String from, String to) throws RemoteException {
        return from + " say hello to " + to;
    }
}

在 rmiServer 中发布服务

public class RMIServer
{
    public static void main( String[] args )
    {
        try {
    //1.服务创建及发布:HelloWorldService 需要继承自 UnicastRemoteObject,当初始化时会自动将 HelloWorldServiceImpl任务一个服务发布。
            HelloWorldService helloWorldService = new HelloWorldServiceImpl();
    // 2. 创建注册中心:创建本机 1099 端口上的 RMI 注册表
            Registry registry = LocateRegistry.createRegistry(1099);
    // 3. 服务注册:将服务绑定到注册表中
            registry.bind("rmi://localhost:1099/helloWorldService", helloWorldService);
        } catch (RemoteException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (AlreadyBoundException e) {
            e.printStackTrace();
        }
    }

在 rmiclent 中调用远程服务

public class RMIClient
{
    public static void main( String[] args )
    {
        try {
            HelloWorldService helloWorldService = (HelloWorldService)   Naming.lookup("rmi://localhost:1099/helloWorldService");
            if(helloWorldService != null) {
                String result = helloWorldService.sayHello("java", "菜鸟");
                System.out.println(result);
            } else  {
                System.out.println("rmi 查找服务错误");
            }
            //Naming.list("rmi://localhost:1099");
        } catch (NotBoundException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

以上,可以看出 RMI 开发中有三个重要角色,分别是客户端,服务端,注册中心,其中
(1)注册中心:负责服务注册
(2)服务端:是提供服务的地方,是真正实现约定接口的地方
(3)客户端:是服务的调用方,是需要使用服务的一方。

通过上面的代码发现,无论是 HelloWorldServiceImpl 还是 Registry 都是 RemoteObjet 的子类。具体类图如下

RemoteObject 最重要的属性是 RemoteRef ref, RemoteRef 的实现类 UnicastRef,UnicastRef 包含属性 LiveRef ref。LiveRef 类中的 Endpoint、Channel 封装了与网络通信相关的方法。

二、启动服务端

服务端通过 LocateRegistry.createRegistry(1099) 来创建注册中心,如下,在创建注册中心的时候,会初始化一个 HashTable 的 bindings 属性,在使用 bind() 方法注册服务的时候,会保存到 bindings 结构中。之后如果注册中心的端口是 1099 并且系统开启了安全管理器,那么可以在限定的权限集内(listen 和 accept)绕过系统的安全校验,反之需要进行安全校验。之后通过 setup() 中的 exportObject 方法来暴露服务。Ps:继承 UnicastRemoteObject 的类,最终也会调用调用 exportObject 方法。

public RegistryImpl(final int var1) throws RemoteException {
    this.bindings = new Hashtable(101);
    if (var1 == 1099 && System.getSecurityManager() != null) {
        try {
            AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
                public Void run() throws RemoteException {
                    LiveRef var1x = new LiveRef(RegistryImpl.id, var1);
                    RegistryImpl.this.setup(new UnicastServerRef(var1x, (var0) -> {
                        return RegistryImpl.registryFilter(var0);
                    }));
                    return null;
                }
            }, (AccessControlContext)null, new SocketPermission("localhost:" + var1, "listen,accept"));
        } catch (PrivilegedActionException var3) {
            throw (RemoteException)var3.getException();
        }
    } else {
        LiveRef var2 = new LiveRef(id, var1);
        this.setup(new UnicastServerRef(var2, RegistryImpl::registryFilter));
    }

}
private void setup(UnicastServerRef var1) throws RemoteException {
    this.ref = var1;
    var1.exportObject(this, (Object)null, true);
}

setup() 里面调用的是 UnicastServerRef 的 exportObject() 方法,进入该方法,这里面为 RestryImpl 创建了一个代理,代理的作用是创建了服务于客户端的 RegistryImpl 的 Stub 对象,最后用 skeleton、stub、UnicastServerRef 对象、id 和一个 boolean 值构造了一个 Target 对象,也就是这个 Target 对象基本上包含了全部的信息。

public Remote exportObject(Remote var1, Object var2, boolean var3) throws RemoteException {
    Class var4 = var1.getClass();
    Remote var5;
    try {
        var5 = Util.createProxy(var4, this.getClientRef(), this.forceStubUse);
    } catch (IllegalArgumentException var7) {
        throw new ExportException("remote object implements illegal remote interface", var7);
    }
    if (var5 instanceof RemoteStub) {
        this.setSkeleton(var1);
    }
    Target var6 = new Target(var1, this, var5, this.ref.getObjID(), var3);
    this.ref.exportObject(var6);
    this.hashToMethod_Map = (Map)hashToMethod_Maps.get(var4);
    return var5;
}

上面提到了 Stub(存根)和 Skeleton(骨架)对象,分别是客户端的代理和服务端的代理,Stub 和 Skeleton 通过 socket 进行通信。上面的代码封装了 Target 方法之后,调用了 LiveRef 的 exportObject() 方法,追到了 TCPTransport 的 exportObject() 方法,如下,这个方法里面做了两件事。一是 listen() 方法创建一个 ServerSocket。并启动一条线程等待客户端的请求,接着调用父类 Transport 的 exportObject() 将 Target 对象存放进 ObjectTable 中。

public void exportObject(Target var1) throws RemoteException {
    synchronized(this) {
        this.listen();
        ++this.exportCount;
    }
    boolean var2 = false;
    boolean var12 = false;
    try {
        var12 = true;
        super.exportObject(var1);
        var2 = true;
        var12 = false;
    } finally {
        if (var12) {
            if (!var2) {
                synchronized(this) {
                    this.decrementExportCount();
                }
            }
        }
    }
    if (!var2) {
        synchronized(this) {
            this.decrementExportCount();
        }
    }
}

三、客户端获取获取服务

通过客户端调用远程服务分为两个步骤:一是获取注册中心 registry;二是根据注册中心获取服务的代理类 service。通过示例代码,可以追溯到 LocateRegistry 的 getRegistry() 方法。

public void exportObject(Target var1) throws RemoteException {
    synchronized(this) {
        this.listen();
        ++this.exportCount;
    }
    boolean var2 = false;
    boolean var12 = false;
    try {
        var12 = true;
        super.exportObject(var1);
        var2 = true;
        var12 = false;
    } finally {
        if (var12) {
            if (!var2) {
                synchronized(this) {
                    this.decrementExportCount();
                }
            }
        }
    }
    if (!var2) {
        synchronized(this) {
            this.decrementExportCount();
        }
    }
}

这个方法做的是通过传入的 host 和 port 构造 RemoteRef 对象,并创建了一个本地代理。代理对象其实是 RegistryImpl_Stub 对象。但注意此时这个代理其实还没有和服务端的 RegistryImpl 对象关联,毕竟是两个 JVM 上面的对象,这里我们也可以猜测,代理和远程的 Registry 对象之间是通过 socket 消息来完成的。

public Remote lookup(String var1) throws AccessException, NotBoundException, RemoteException {
    try {
        RemoteCall var2 = this.ref.newCall(this, operations, 2, 4905912898345647071L);

        try {
            ObjectOutput var3 = var2.getOutputStream();
            var3.writeObject(var1);
        } catch (IOException var17) {
            throw new MarshalException("error marshalling arguments", var17);
        }

        this.ref.invoke(var2);

        Remote var22;
        try {
            ObjectInput var4 = var2.getInputStream();
            var22 = (Remote)var4.readObject();
        } catch (IOException var14) {
            throw new UnmarshalException("error unmarshalling return", var14);
        } catch (ClassNotFoundException var15) {
            throw new UnmarshalException("error unmarshalling return", var15);
        } finally {
            this.ref.done(var2);
        }

        return var22;
    } catch (RuntimeException var18) {
        throw var18;
    } catch (RemoteException var19) {
        throw var19;
    } catch (NotBoundException var20) {
        throw var20;
    } catch (Exception var21) {
        throw new UnexpectedException("undeclared checked exception", var21);
    }
}

获取注册中心后,在客户端直接生成代理对象 RegistryImpl_Stub,RegistryImpl_Stub 通过 newCall() 方法和服务端建立连接,并向服务端传输远程接口名称,使用的注册中心方法集合以及集合的索引,来调用远程方法。实际调用 RemoteRef 的 invoke 方法进行网络通信,来获得远程对象实例。

四、总结

通过上面的分析,RMI 的调用流程可以简化成下面的结构。

但是里面还有很多细节值得仔细研究,例如 rmi 在调用的方法中存在引用型数据,是如何进行序列化和反序列化?bindings 数据结构在整个调用过程中到底处于什么样的角色?骨干和存根是如何封装通信?后续笔者也会持续分享。
另外 RMI 优点是避免重复造轮子,降低开发工作量,优化部署结构等,缺点是调用过程是两个 jvm 通信,增加了调用时间,而且如果网络不稳定会影响方法调用,降低了可用性,所以技术选型的时候需要按照业务需要平衡一下,或者可以选择 dubbo 这种支持 rmi 协议的 RPC 框架来进行管理。


↙↙↙阅读原文可查看相关链接,并与作者交流