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 框架来进行管理。
