在 Java 世界里,有一种技术可以实现“跨虚拟机”的调用,它就是 RMI(Remote Method Invocation,远程方法调用)
。例如,服务A 在 JVM1 中运行,服务B 在 JVM2 中运行,服务A 与 服务B 可相互进行远程调用,就像调用本地方法一样,这就是 RMI。在分布式系统中,我们使用 RMI 技术可轻松将 服务提供者(Service Provider)与 服务消费者(Service Consumer)进行分离,充分体现组件之间的弱耦合,系统架构更易于扩展。
本文先从通过一个最简单的 RMI 服务与调用示例,让读者快速掌握 RMI 的使用方法,然后指出 RMI 的局限性,最后笔者对此问题提供了一种简单的解决方案,即使用 ZooKeeper 轻松解决 RMI 调用过程中所涉及的问题。
1 发布 RMI 服务
发布一个 RMI 服务,我们只需做三件事情:
- 定义一个 RMI 接口
- 编写 RMI 接口的实现类
- 通过 JNDI 发布 RMI 服务
1.1 定义一个 RMI 接口
RMI 接口实际上还是一个普通的 Java 接口,只是 RMI 接口必须继承 java.rmi.Remote
,此外,每个 RMI 接口的方法必须声明抛出一个 java.rmi.RemoteException 异常
,就像下面这样:
package com.king.zkrmi; import java.rmi.Remote; import java.rmi.RemoteException; /** * RMI服务接口 */ public interface HelloService extends Remote { String sayHello(String name) throws RemoteException; }
继承了 Remote 接口,实际上是让 JVM 得知该接口是需要用于远程调用的
,抛出了 RemoteException 是为了让调用 RMI 服务的程序捕获这个异常
。毕竟远程调用过程中,什么奇怪的事情都会发生(比如:断网)。需要说明的是,RemoteException 是一个“受检异常”,在调用的时候必须使用 try...catch... 自行处理
。
1.2 编写 RMI 接口的实现类
实现以上的 HelloService 是一件非常简单的事情,但需要注意的是,我们必须让实现类继承 java.rmi.server.UnicastRemoteObject 类
,此外,必须提供一个构造器,并且构造器必须抛出 java.rmi.RemoteException 异常
。我们既然使用 JVM 提供的这套 RMI 框架,那么就必须按照这个要求来实现,否则是无法成功发布 RMI 服务的,一句话:我们得按规矩出牌!
1 package com.king.zkrmi; 2 3 import java.rmi.RemoteException; 4 import java.rmi.server.UnicastRemoteObject; 5 6 /** 7 * RMI服务实现 8 */ 9 public class HelloServiceImpl extends UnicastRemoteObject implements HelloService { 10 11 protected HelloServiceImpl() throws RemoteException { 12 } 13 14 @Override 15 public String sayHello(String name) throws RemoteException { 16 return String.format("Hello %s", name); 17 } 18 }
为了满足 RMI 框架的要求,我们确实做了很多额外的工作(继承了 UnicastRemoteObject 类,抛出了 RemoteException 异常
),但这些工作阻止不了我们发布 RMI 服务的决心!我们可以通过 JVM 提供的 JNDI(Java Naming and Directory Interface,Java 命名与目录接口)这个 API 轻松发布 RMI 服务
。
1.3 通过 JNDI 发布 RMI 服务
发布 RMI 服务,我们需要告诉 JNDI 三个基本信息:1. 域名或 IP 地址(host)、2. 端口号(port)、3. 服务名(service)
,它们构成了 RMI 协议的 URL(或称为“RMI 地址”):
rmi://<host>:<port>/<service>
如果我们是在本地发布 RMI 服务,那么 host 就是“localhost”。此外,RMI 默认的 port 是“1099”
,我们也可以自行设置 port 的值(只要不与其它端口冲突即可)。service 实际上是一个基于同一 host 与 port 下唯一的服务名,我们不妨使用 Java 完全类名来表示吧
,这样也比较容易保证 RMI 地址的唯一性。
对于我们的示例而言,RMI 地址为:
rmi://localhost:1099/demo.zookeeper.rmi.server.HelloServiceImpl
我们只需简单提供一个 main() 方法就能发布 RMI 服务,就像下面这样:
1 package demo.zookeeper.rmi.server; 2 3 import java.rmi.Naming; 4 import java.rmi.registry.LocateRegistry; 5 6 public class RmiServer { 7 8 public static void main(String[] args) throws Exception { 9 int port = 1099; 10 String url = "rmi://localhost:1099/demo.zookeeper.rmi.server.HelloServiceImpl"; 11 LocateRegistry.createRegistry(port); 12 Naming.rebind(url, new HelloServiceImpl()); 13 } 14 }
需要注意的是,我们通过 LocateRegistry.createRegistry() 方法在 JNDI 中创建一个注册表,只需提供一个 RMI 端口号即可
。此外,通过 Naming.rebind() 方法绑定 RMI 地址与 RMI 服务实现类
,这里使用了 rebind() 方法,它相当于先后调用 Naming 的 unbind() 与 bind() 方法,只是使用 rebind() 方法来得更加痛快而已,所以我们选择了它。
运行这个 main() 方法,RMI 服务就会自动发布,剩下要做的就是写一个 RMI 客户端来调用已发布的 RMI 服务。
2 调用 RMI 服务
同样我们也使用一个 main() 方法来调用 RMI 服务,相比发布而言,调用会更加简单,我们只需要知道两个东西:1. RMI 请求路径、2. RMI 接口(一定不需要 RMI 实现类,否则就是本地调用了)
。数行代码就能调用刚才发布的 RMI 服务,就像下面这样:
1 package demo.zookeeper.rmi.client; 2 3 import demo.zookeeper.rmi.common.HelloService; 4 import java.rmi.Naming; 5 6 public class RmiClient { 7 8 public static void main(String[] args) throws Exception { 9 String url = "rmi://localhost:1099/demo.zookeeper.rmi.server.HelloServiceImpl"; 10 HelloService helloService = (HelloService) Naming.lookup(url); 11 String result = helloService.sayHello("Jack"); 12 System.out.println(result); 13 } 14 }
当我们运行以上 main() 方法,在控制台中看到“Hello Jack”输出,就表明 RMI 调用成功。
3 RMI 服务的局限性
可见,借助 JNDI 这个所谓的命名与目录服务,我们成功地发布并调用了 RMI 服务。实际上,JNDI 就是一个注册表,服务端将服务对象放入到注册表中,客户端从注册表中获取服务对象。在服务端我们发布了 RMI 服务,并在 JNDI 中进行了注册,此时就在服务端创建了一个 Skeleton(骨架),当客户端第一次成功连接 JNDI 并获取远程服务对象后,立马就在本地创建了一个 Stub(存根),远程通信实际上是通过 Skeleton 与 Stub 来完成的,数据是基于 TCP/IP 协议,在“传输层”上发送的
。毋庸置疑,理论上 RMI 一定比 WebService 要快,毕竟 WebService 是基于 HTTP 的,而 HTTP 所携带的数据是通过“应用层”来传输的,传输层较应用层更为底层,越底层越快。
既然 RMI 比 WebService 快,使用起来也方便,那么为什么我们有时候还要用 WebService 呢?
其实原因很简单,WebService 可以实现跨语言系统之间的调用,而 RMI 只能实现 Java 系统之间的调用
。也就是说,RMI 的跨平台性不如 WebService 好,假如我们的系统都是用 Java 开发的,那么当然首选就是 RMI 服务了。
貌似 RMI 确实挺优秀的,除了不能跨平台以外,还有那些问题呢?
笔者认为有两点局限性:
- RMI 使用了 Java 默认的序列化方式,对于性能要求比较高的系统,可能需要使用其它序列化方案来解决(例如:Protobuf)。
- RMI 服务在运行时难免会存在出故障,例如,如果 RMI 服务无法连接了,就会导致客户端无法响应的现象。
在一般的情况下,Java 默认的序列化方式确实已经足以满足我们的要求了,如果性能方面如果不是问题的话,我们需要解决的实际上是第二点,也就是说,让使系统具备 HA(High Availability,高可用性)
。
4 使用 ZooKeeper 提供高可用的 RMI 服务
要想解决 RMI 服务的高可用性问题,我们需要利用 ZooKeeper 充当一个 服务注册表(Service Registry),让多个 服务提供者(Service Provider)形成一个集群,让 服务消费者(Service Consumer)通过服务注册表获取具体的服务访问地址(也就是 RMI 服务地址)去访问具体的服务提供者
。如下图所示:
需要注意的是,服务注册表并不是 Load Balancer(负载均衡器),提供的不是“反向代理”服务,而是“服务注册”与“心跳检测”功能
。
利用服务注册表来注册 RMI 地址,这个很好理解,那么“心跳检测”又如何理解呢?说白了就是通过服务中心定时向各个服务提供者发送一个请求(实际上建立的是一个 Socket 长连接),如果长期没有响应,服务中心就认为该服务提供者已经“挂了”,只会从还“活着”的服务提供者中选出一个做为当前的服务提供者。
也许读者会考虑到,服务中心可能会出现单点故障,如果服务注册表都坏掉了,整个系统也就瘫痪了。看来要想实现这个架构,必须保证服务中心也具备高可用性
。
ZooKeeper 正好能够满足我们上面提到的所有需求:
使用 ZooKeeper 的临时性 ZNode 来存放服务提供者的 RMI 地址,一旦与服务提供者的 Session 中断,会自动清除相应的 ZNode。
让服务消费者去监听这些 ZNode,一旦发现 ZNode 的数据(RMI 地址)有变化,就会重新获取一份有效数据的拷贝。
ZooKeeper 与生俱来的集群能力(例如:数据同步与领导选举特性),可以确保服务注册表的高可用性。
4.1 服务提供者
需要编写一个 ServiceProvider 类,来发布 RMI 服务,并将 RMI 地址注册到 ZooKeeper 中(实际存放在 ZNode 上):
1 package com.king.zkrmi; 2 3 import org.apache.zookeeper.*; 4 import org.slf4j.Logger; 5 import org.slf4j.LoggerFactory; 6 7 import java.io.IOException; 8 import java.net.MalformedURLException; 9 import java.rmi.Naming; 10 import java.rmi.Remote; 11 import java.rmi.RemoteException; 12 import java.rmi.registry.LocateRegistry; 13 import java.util.concurrent.CountDownLatch; 14 15 /** 16 * RMI服务提供者 17 */ 18 public class ServiceProvider { 19 20 private static final Logger LOGGER = LoggerFactory.getLogger(ServiceProvider.class); 21 22 // 用于等待 SyncConnected 事件触发后继续执行当前线程 23 private CountDownLatch latch = new CountDownLatch(1); 24 25 // 发布 RMI 服务并注册 RMI 地址到 ZooKeeper 中 26 public void publish(Remote remote, String host, int port) { 27 String url = publishService(remote, host, port); // 发布 RMI 服务并返回 RMI 地址 28 if (url != null) { 29 ZooKeeper zk = connectServer(); // 连接 ZooKeeper 服务器并获取 ZooKeeper 对象 30 if (zk != null) { 31 createNode(zk, url); // 创建 ZNode 并将 RMI 地址放入 ZNode 上 32 } 33 } 34 } 35 36 // 发布 RMI 服务 37 private String publishService(Remote remote, String host, int port) { 38 String url = null; 39 try { 40 url = String.format("rmi://%s:%d/%s", host, port, remote.getClass().getName()); 41 LocateRegistry.createRegistry(port); 42 Naming.rebind(url, remote); 43 LOGGER.debug("publish rmi service (url: {})", url); 44 } catch (RemoteException | MalformedURLException e) { 45 LOGGER.error("", e); 46 } 47 return url; 48 } 49 50 // 连接 ZooKeeper 服务器 51 private ZooKeeper connectServer() { 52 ZooKeeper zk = null; 53 try { 54 zk = new ZooKeeper(Constant.ZK_CONNECTION_STRING, Constant.ZK_SESSION_TIMEOUT, new Watcher() { 55 @Override 56 public void process(WatchedEvent event) { 57 if (event.getState() == Event.KeeperState.SyncConnected) { 58 latch.countDown(); // 唤醒当前正在执行的线程 59 } 60 } 61 }); 62 latch.await(); // 使当前线程处于等待状态 63 } catch (IOException | InterruptedException e) { 64 LOGGER.error("", e); 65 } 66 return zk; 67 } 68 69 // 创建 ZNode 70 private void createNode(ZooKeeper zk, String url) { 71 try { 72 byte[] data = url.getBytes(); 73 String path = zk.create(Constant.ZK_PROVIDER_PATH, data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); // 创建一个临时性且有序的 ZNode 74 LOGGER.debug("create zookeeper node ({} => {})", path, url); 75 } catch (KeeperException | InterruptedException e) { 76 LOGGER.error("", e); 77 } 78 } 79 }
涉及到的 Constant 常量,见如下代码:
package com.king.zkrmi; /** * ZK常量 */ public interface Constant { String ZK_CONNECTION_STRING = "localhost:2181"; int ZK_SESSION_TIMEOUT = 5000; String ZK_REGISTRY_PATH = "/registry"; String ZK_PROVIDER_PATH = ZK_REGISTRY_PATH + "/provider"; }
注意:我们首先需要使用 ZooKeeper 的客户端工具创建一个持久性 ZNode,名为“/registry”,该节点是不存放任何数据的,可使用如下命令:
create /registry null
4.2 服务消费者
服务消费者需要在创建的时候连接 ZooKeeper,同时监听 /registry 节点的 NodeChildrenChanged 事件
,也就是说,一旦该节点的子节点有变化,就需要重新获取最新的子节点。这里提到的子节点,就是存放服务提供者发布的 RMI 地址
。需要强调的是,这些子节点都是临时性的,当服务提供者与 ZooKeeper 服务注册表的 Session 中断后,该临时性节会被自动删除
。
1 package com.king.zkrmi; 2 3 import org.apache.zookeeper.KeeperException; 4 import org.apache.zookeeper.WatchedEvent; 5 import org.apache.zookeeper.Watcher; 6 import org.apache.zookeeper.ZooKeeper; 7 import org.slf4j.Logger; 8 import org.slf4j.LoggerFactory; 9 10 import java.io.IOException; 11 import java.net.ConnectException; 12 import java.net.MalformedURLException; 13 import java.rmi.Naming; 14 import java.rmi.NotBoundException; 15 import java.rmi.Remote; 16 import java.rmi.RemoteException; 17 import java.util.ArrayList; 18 import java.util.List; 19 import java.util.concurrent.CountDownLatch; 20 import java.util.concurrent.ThreadLocalRandom; 21 22 /** 23 * RMI服务消费者 24 */ 25 public class ServiceConsumer { 26 27 private static final Logger LOGGER = LoggerFactory.getLogger(ServiceConsumer.class); 28 29 // 用于等待 SyncConnected 事件触发后继续执行当前线程 30 private CountDownLatch latch = new CountDownLatch(1); 31 32 // 定义一个 volatile 成员变量,用于保存最新的 RMI 地址(考虑到该变量或许会被其它线程所修改,一旦修改后,该变量的值会影响到所有线程) 33 private volatile List<String> urlList = new ArrayList<>(); 34 35 // 构造器 36 public ServiceConsumer() { 37 ZooKeeper zk = connectServer(); // 连接 ZooKeeper 服务器并获取 ZooKeeper 对象 38 if (zk != null) { 39 watchNode(zk); // 观察 /registry 节点的所有子节点并更新 urlList 成员变量 40 } 41 } 42 43 // 查找 RMI 服务 44 public <T extends Remote> T lookup() { 45 T service = null; 46 int size = urlList.size(); 47 if (size > 0) { 48 String url; 49 if (size == 1) { 50 url = urlList.get(0); // 若 urlList 中只有一个元素,则直接获取该元素 51 LOGGER.debug("using only url: {}", url); 52 } else { 53 url = urlList.get(ThreadLocalRandom.current().nextInt(size)); // 若 urlList 中存在多个元素,则随机获取一个元素 54 LOGGER.debug("using random url: {}", url); 55 } 56 service = lookupService(url); // 从 JNDI 中查找 RMI 服务 57 } 58 return service; 59 } 60 61 // 连接 ZooKeeper 服务器 62 private ZooKeeper connectServer() { 63 ZooKeeper zk = null; 64 try { 65 zk = new ZooKeeper(Constant.ZK_CONNECTION_STRING, Constant.ZK_SESSION_TIMEOUT, new Watcher() { 66 @Override 67 public void process(WatchedEvent event) { 68 if (event.getState() == Event.KeeperState.SyncConnected) { 69 latch.countDown(); // 唤醒当前正在执行的线程 70 } 71 } 72 }); 73 latch.await(); // 使当前线程处于等待状态 74 } catch (IOException | InterruptedException e) { 75 LOGGER.error("", e); 76 } 77 return zk; 78 } 79 80 // 观察 /registry 节点下所有子节点是否有变化 81 private void watchNode(final ZooKeeper zk) { 82 try { 83 List<String> nodeList = zk.getChildren(Constant.ZK_REGISTRY_PATH, new Watcher() { 84 @Override 85 public void process(WatchedEvent event) { 86 if (event.getType() == Event.EventType.NodeChildrenChanged) { 87 watchNode(zk); // 若子节点有变化,则重新调用该方法(为了获取最新子节点中的数据) 88 } 89 } 90 }); 91 List<String> dataList = new ArrayList<>(); // 用于存放 /registry 所有子节点中的数据 92 for (String node : nodeList) { 93 byte[] data = zk.getData(Constant.ZK_REGISTRY_PATH + "/" + node, false, null); // 获取 /registry 的子节点中的数据 94 dataList.add(new String(data)); 95 } 96 LOGGER.debug("node data: {}", dataList); 97 urlList = dataList; // 更新最新的 RMI 地址 98 } catch (KeeperException | InterruptedException e) { 99 LOGGER.error("", e); 100 } 101 } 102 103 // 在 JNDI 中查找 RMI 远程服务对象 104 @SuppressWarnings("unchecked") 105 private <T> T lookupService(String url) { 106 T remote = null; 107 try { 108 remote = (T) Naming.lookup(url); 109 } catch (NotBoundException | MalformedURLException | RemoteException e) { 110 if (e instanceof ConnectException) { 111 // 若连接中断,则使用 urlList 中第一个 RMI 地址来查找(这是一种简单的重试方式,确保不会抛出异常) 112 LOGGER.error("ConnectException -> url: {}", url); 113 if (urlList.size() != 0) { 114 url = urlList.get(0); 115 return lookupService(url); 116 } 117 } 118 LOGGER.error("", e); 119 } 120 return remote; 121 } 122 }
4.3 发布服务
我们需要调用 ServiceProvider 的 publish() 方法来发布 RMI 服务,发布成功后也会自动在 ZooKeeper 中注册 RMI 地址:
1 package com.king.zkrmi; 2 3 /** 4 * 服务发布 5 */ 6 public class Server { 7 8 public static void main(String[] args) throws Exception { 9 if (args.length != 2) { 10 System.err.println("please using command: java Server <rmi_host> <rmi_port>"); 11 System.exit(-1); 12 } 13 14 String host = args[0]; 15 int port = Integer.parseInt(args[1]); 16 17 ServiceProvider provider = new ServiceProvider(); 18 19 HelloService helloService = new HelloServiceImpl(); 20 provider.publish(helloService, host, port); 21 22 Thread.sleep(Long.MAX_VALUE); 23 } 24 }
注意:在运行 Server 类的 main() 方法时,一定要使用命令行参数来指定 host 与 port,例如:
java Server localhost 1099 java Server localhost 2099
以上两条 Java 命令可在本地运行两个 Server 程序,当然也可以同时运行更多的 Server 程序,只要 port 不同就行。
4.4 调用服务
通过调用 ServiceConsumer 的 lookup() 方法来查找 RMI 远程服务对象。我们使用一个“死循环”来模拟每隔 3 秒钟调用一次远程方法。
1 package com.king.zkrmi; 2 3 /** 4 * RMI客户端 5 */ 6 public class Client { 7 8 public static void main(String[] args) throws Exception { 9 ServiceConsumer consumer = new ServiceConsumer(); 10 11 while (true) { 12 HelloService helloService = consumer.lookup(); 13 String result = helloService.sayHello("Jack"); 14 System.out.println(result); 15 Thread.sleep(3000); 16 } 17 } 18 }
4.5 使用方法
根据以下步骤验证 RMI 服务的高可用性:
- 运行两个 Server 程序,一定要确保 port 是不同的。
- 运行一个 Client 程序。
- 停止其中一个 Server 程序,并观察 Client 控制台的变化(停止一个 Server 不会导致 Client 端调用失败)。
- 重新启动刚才关闭的 Server 程序,继续观察 Client 控制台变化(新启动的 Server 会加入候选)。
- 先后停止所有的 Server 程序,还是观察 Client 控制台变化(Client 会重试连接,多次连接失败后,自动关闭)。
5 总结
通过本文,我们尝试使用 ZooKeeper 实现了一个简单的 RMI 服务高可用性解决方案,通过 ZooKeeper 注册所有服务提供者发布的 RMI 服务,让服务消费者监听 ZooKeeper 的 Znode,从而获取当前可用的 RMI 服务。此方案局限于 RMI 服务,对于任何形式的服务(比如:WebService),也提供了一定参考。
如果再配合 ZooKeeper 自身的集群,那才是一个相对完美的解决方案,对于 ZooKeeper 的集群,请读者自行实践。
由于笔者水平有限,对于描述有误之处,还请各位读者提出建议,并期待更加优秀的解决方案。