一、Java RMI的原理

Java RMI是The Java Remote Method Invocation的简写，其字面含义为：java远程方法调用；Java RMI允许一个JVM上的对象调用另一个JVM中的对象，其使得两个JVM之间可以相互通信，Dubbo则借鉴了这种理念；

RMI可用于构建分布式应用，其原理如下图：

Java RMI - 图1

图片来源：https://onclick786.blogspot.com/2016/08/java-remote-method-invocation-or-java.html

1、RMI的基本概念

  • Client Host，客户端
  • Server Host，服务端
  • Server Object，远程对象，存在于服务端，Server Skeleton依赖其做出业务响应；
  • Server Stub 对象，客户端本地存根，从远程获取，充当远程服务(主要为Server Object)的客户端代理；
  • Server Skeleton 对象，存在于服务端，负责将Server Stub传输过来的数据进行解包，以及调用Server Object的方法，然后封装返回值给stub对象；
  • Server Stub 和Server Skeleton 在各自的JVM中使用socket通信将远程调用伪装成本地调用，理解此至关重要，后面将有详解；
  • 通过 RMI 注册服务完成服务的注册和发现；

2、调用步骤：

  • (1). 服务端(Server Host)向注册服务注册(RMI Registry Host)自己的地址；
  • (2). 客户端(Client Host)通过 RMI 注册服务获取(Look for)目标地址；
  • (3). 注册中心返回一个本地存根(Server Stub)给客户端；
  • (4). 客户端调用本地的 Stub(即存根对象，Server Stub) 对象上的方法，将请求参数通过网络通信传输给服务端的Server Skeleton
  • (5). 服务端的 Skeleton(Server Skeleton) 对象收到网络请求之后，将调用信息解包，然后找到真正的服务对象(Server Object)发起调用，并将返回结果打包通过网络(Data Communication)发送回客户端。

二、Java RMI 使用案例

1. 创建远程对象Server Object

  1. package com.codestack.dubbo.learn.FirstRmi.service;
  3. import java.rmi.Remote;
  4. import java.rmi.RemoteException;
  5. /**
  6.  * @author Ling
  7.  * @create 2018-09-03-9:26
  8.  **/
  9. public interface Hello extends Remote{
  10.     String sayHello(String name) throws RemoteException;
  11. }

其中sayHello必须声明RemoteException异常；

Server Object的具体实现：

  1. package com.codestack.dubbo.learn.FirstRmi.service.impl;
  3. import com.codestack.dubbo.learn.FirstRmi.service.Hello;
  4. /**
  5.  * @author Ling
  6.  * @create 2018-09-03-9:26
  7.  **/
  8. public class HelloImpl implements Hello {
  9.     @Override
  10.     public String sayHello(String name) {
  11.         return "hello! " + name;
  12.     }
  14. }

2. 服务注册与绑定

  1. package com.codestack.dubbo.learn.FirstRmi;
  3. import com.codestack.dubbo.learn.FirstRmi.service.Hello;
  4. import com.codestack.dubbo.learn.FirstRmi.service.impl.HelloImpl;
  6. import java.rmi.RemoteException;
  7. import java.rmi.registry.LocateRegistry;
  8. import java.rmi.registry.Registry;
  9. import java.rmi.server.UnicastRemoteObject;
  12. /**
  13.  * @author Ling
  14.  * @create 2018-09-03-9:26
  15.  **/
  16. public class FirstRmiAppServer {
  17.     public static void main(String[] args) throws RemoteException {
  18.         //创建Skeleton
  19.         Hello obj = new HelloImpl(); // #1
  20.         Hello skeleton = (Hello) UnicastRemoteObject.exportObject(obj, 0); // #2
  21.         //创建本地注册中心
  22.         Registry registry = LocateRegistry.createRegistry(1099); // #3
  23.         //绑定skeleton
  24.         registry.rebind("Hello", skeleton); // #4
  25.     }
  26. }

3. 客户端注册

  1. package com.codestack.dubbo.learn.FirstRmi;
  3. import com.codestack.dubbo.learn.FirstRmi.service.Hello;
  5. import java.rmi.NotBoundException;
  6. import java.rmi.RemoteException;
  7. import java.rmi.registry.LocateRegistry;
  8. import java.rmi.registry.Registry;
  10. /**
  11.  * @author Ling
  12.  * @create 2018-09-03-9:26
  13.  **/
  14. public class FirstRmiAppClient {
  15.     public static void main(String[] args) throws RemoteException, NotBoundException {
  16.         Registry registry = LocateRegistry.getRegistry(); // #1 获取本地注册中心实例
  17.         Hello stub = (Hello) registry.lookup("Hello"); // #2 返回一个本地存根
  18.         String response = stub.sayHello("Chris"); // #3 调用远程方法
  19.         System.out.println(response);
  20.     }
  21. }

依次运行FirstRmiAppServer，FirstRmiAppClient，控制台将打印：hello! Chris

三、RMI的本质：Stub 和 Skeleton剖析

1. 定义服务端ServerObject

  1. package com.codestack.dubbo.learn.FirstRmi.RmiTheory;
  3. public interface Dog {
  4.     public int weight() throws Throwable;
  5.     public String watch() throws Throwable;
  6. }

实现Dog接口：

  1. package com.codestack.dubbo.learn.FirstRmi.RmiTheory;
  3. public class DogServer implements Dog{
  4.     private int weight;
  5.     @Override
  6.     public int weight() throws Throwable {
  7.         return 100;
  8.     }
  10.     @Override
  11.     public String watch() throws Throwable {
  12.         return "I'm watching!";
  13.     }
  14. }

2. 定义服务端Skeleton

  1. package com.codestack.dubbo.learn.FirstRmi.RmiTheory;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  9. public class DogSkeleton extends Thread{
  10.     private DogServer dogServer;
  11.     public DogSkeleton(DogServer server){
  12.         this.dogServer = server;
  13.     }
  15.     public void run() {
  16.         ServerSocket serverSocket = null;
  17.         try {
  18.             serverSocket = new ServerSocket(8000);
  19.             Socket socket = serverSocket.accept();
  21.             while (!socket.isClosed()) {
  22.                 ObjectInputStream inStream =
  23.                         new ObjectInputStream(socket.getInputStream());
  24.                 //获取客户端Stub的请求方法
  25.                 String method = (String) inStream.readObject();
  26.                 if  (method.equals( "weight" )) {
  27.                     //调用ServerObject的真实方法
  28.                     int  age = dogServer.weight();
  29.                     ObjectOutputStream outStream =
  30.                             new  ObjectOutputStream(socket.getOutputStream());
  31.                     //返回结果给客户端Stub
  32.                     outStream.writeInt(age);
  33.                     outStream.flush();
  34.                 }
  35.                 if (method.equals( "watch" )) {
  36.                     //调用ServerObject的真实方法
  37.                     String name = dogServer.watch();
  38.                     ObjectOutputStream outStream =
  39.                             new  ObjectOutputStream(socket.getOutputStream());
  40.                     // return result to stub
  41.                     outStream.writeObject(name);
  42.                     outStream.flush();
  43.                     socket.close();
  44.                 }
  45.             }
  47.         } catch (Exception e) {
  48.             e.printStackTrace();
  49.         } catch (Throwable throwable) {
  50.             throwable.printStackTrace();
  51.         }
  53.     }
  55.     public static void main(String[] args){
  56.         DogServer dogServer = new DogServer();
  57.         DogSkeleton dogSkeleton = new DogSkeleton(dogServer);
  58.         dogSkeleton.start();
  59.     }
  60. }

将DogSkeleton作为外部代理，创建一个socket，等待客户端的连接，根据客户端传入的不通参数，实际调用DogServer来做相应的处理；

3. 定义客户端Stub

  1. package com.codestack.dubbo.learn.FirstRmi.RmiTheory;
  3. import java.io.ObjectInputStream;
  4. import java.io.ObjectOutputStream;
  5. import java.net.Socket;
  7. public class DogStub implements Dog{
  9.     private Socket socket;
  11.     public DogStub() throws Throwable {
  12.         socket =  new  Socket( "localhost" ,  8000 );
  13.     }
  15.     @Override
  16.     public int weight() throws Throwable {
  17.         ObjectOutputStream outStream =
  18.                 new  ObjectOutputStream(socket.getOutputStream());
  19.         outStream.writeObject( "weight" );
  20.         outStream.flush();
  21.         ObjectInputStream inStream =
  22.                 new  ObjectInputStream(socket.getInputStream());
  23.         return  inStream.readInt();
  24.     }
  26.     @Override
  27.     public String watch() throws Throwable {
  28.         ObjectOutputStream outStream =
  29.                 new  ObjectOutputStream(socket.getOutputStream());
  30.         outStream.writeObject( "watch" );
  31.         outStream.flush();
  32.         ObjectInputStream inStream =
  33.                 new  ObjectInputStream(socket.getInputStream());
  34.         return  (String)inStream.readObject();
  35.     }
  36. }

构造DogStub的时候创建一个socket，然后将请求参数写入到ObjectInputStream中，传递给服务端。

4. 测试Demo

  1. package com.codestack.dubbo.learn.FirstRmi.RmiTheory;
  3. public class DogClient {
  5.     public static void main(String[] args) throws Throwable {
  6.         Dog dogStub = new DogStub();
  7.         System.out.println("dog's weight is: "+dogStub.weight());
  8.         System.out.println(dogStub.watch());
  10.     }
  11. }

依次运行：DogSkeleton、DogClient，控制台打印：

  1. dog's weight is: 100
  2. I'm watching!

RMI依靠Socket，然后使用Stub和Skeleton对象做通信代理，完成远程调用；