RPC和RMI

- 日理万妓 2022-02-16 10:38 338阅读 0赞

## **1、RPC（远程过程调用）简介** ##

RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。那么问题来了——RPC到底是什么？

在校期间，大家多多少少也都写过一些程序，比如写个hello world服务类，然后本地调用下，如下所示。这些程序的特点是服务消费方和服务提供方是本地调用关系。

而在大型互联网公司，公司的系统都由成千上万大大小小的服务组成，各个服务部署在不同的机器上，由不同的团队负责。

这时就会遇到两个问题：

1.  要搭建一个新服务，免不了需要依赖他人的服务，而现在他人的服务都在远端（而不是在本地），怎么调用？
2.  其它团队要使用我们的服务，我们的服务该怎么发布以便他人调用？

RPC可以解决上面两个问题。简单来说，RPC就是说，假设有两台服务器A和B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。

### **如何调用他人的远程服务？** ###

由于各服务部署在不同机器，服务间的调用免不了网络通信过程，服务消费方每调用一个服务都要写一大堆网络通信相关的代码，不仅复杂而且极易出错。

如果有一种方式能让我们像调用本地服务一样调用远程服务，而让调用者对网络通信这些细节透明，那么将大大提高生产力，比如服务消费方在执行helloWorldService.sayHello(“test”)时，实质上调用的是远端的服务

RPC的例子有：阿里巴巴的hsf、dubbo（开源）、Facebook的thrift（开源）、Google grpc（开源）、Twitter的finagle等。

首先我们先看下一个RPC调用的流程：

*  1）服务消费方（client）调用以本地调用方式调用服务；
 *  2）client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体（编码）；
 *  3）client stub找到服务地址，并将消息发送到服务端；
 *  4）server stub收到消息后进行解码；
 *  5）server stub根据解码结果调用本地的服务；
 *  6）本地服务执行并将结果返回给server stub；
 *  7）server stub将返回结果打包成消息（编码）并发送至消费方；
 *  8）client stub接收到消息，并进行解码；
 *  9）服务消费方得到最终结果。

RPC的目标就是要2~8这些步骤都封装起来，让用户对这些细节透明。

**Q：怎么做到透明化远程服务调用？**

答：使用代理！

**Q：为什么使用代理呢？**

举个例子：假设你有一套房子要卖，一种方法是你直接去网上发布出售信息，然后直接带要买房子的人来看房子等等，另一种方法是去找中介，中介实际上就是你的代理——本来是你要做的事情，现在中介帮助你一一处理。对于买方来说跟你直接交易跟同中介直接交易没有任何差异，买方甚至可能觉察不到你的存在，这就是代理最大的好处。（当然，还有另外一个好处就是：在你很忙的时候，你可以把事情交给代理去做！）

下面简单介绍下动态代理怎么实现我们的需求。我们需要实现RPCProxyClient代理类，代理类的invoke方法中封装了与远端服务通信的细节，消费方首先从RPCProxyClient获得服务提供方的接口，当执行helloWorldService.sayHello(“test”)方法时就会调用invoke方法。

**Q：怎么对消息进行编码和解码？**

首先，要确定消息数据结构。

通信的第一步就是要确定客户端和服务端相互通信的消息结构。

第二步，就是序列化与反序列化。

序列化：将数据结构或对象转换成二进制串的过程，也就是编码的过程。

反序列化：将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。

为什么需要序列化：转换为二进制串后便于网络传输。

序列化方案在选择的时候，主要看三点：  
1）通用性，比如是否能支持Map等复杂的数据结构；  
2）性能，包括时间复杂度和空间复杂度，由于RPC框架将会被公司几乎所有服务使用，如果序列化上能节约一点时间，对整个公司的收益都将非常可观，同理如果序列化上能节约一点内存，网络带宽也能省下不少；  
3）可扩展性，对互联网公司而言，业务变化快，如果序列化协议具有良好的可扩展性，支持自动增加新的业务字段，删除老的字段，而不影响老的服务，这将大大提供系统的健壮性。

目前国内各大互联网公司广泛使用hessian、protobuf、thrift、avro等成熟的序列化解决方案来搭建RPC框架。

## **2、Java RMI** ##

Java RMI，远程方法调用（Remote Method Invocation）用于不同虚拟机之间的通信，这些虚拟机可以在不同的主机上、也可以在同一个主机上；一个虚拟机中的对象调用另一个虚拟上中的对象的方法，只不过是允许被远程调用的对象要通过一些标志加以标识。这样做的特点如下：

*      优点：避免重复造轮子；
 *      缺点：调用过程很慢，而且该过程是不可靠的，容易发生不可预料的错误，比如网络错误等；

在RMI中的核心是远程对象（remote object），除了对象本身所在的虚拟机，其他虚拟机也可以调用此对象的方法，而且这些虚拟机可以不在同一个主机上。每个远程对象都要实现一个或者多个远程接口来标识自己，声明了可以被外部系统或者应用调用的方法（当然也有一些方法是不想让人访问的）。

RMI能让一个Java程序去调用网络中另一台计算机的Java对象的方法，那么调用的效果就像是在本机上调用一样。通俗的讲：A机器上面有一个class，通过远程调用，B机器调用这个class 中的方法。

### `RMI`的通信模型 ###

从方法调用角度来看，RMI要解决的问题，是让客户端对远程方法的调用可以相当于对本地方法的调用而屏蔽其中关于远程通信的内容，即使在远程上，也和在本地上是一样的。

从客户端-服务器模型来看，客户端程序直接调用服务端，两者之间是通过JRMP（ Java Remote Method Protocol）协议通信，这个协议类似于HTTP协议，规定了客户端和服务端通信要满足的规范。

但是实际上，客户端只与代表远程主机中对象的Stub对象进行通信，丝毫不知道Server的存在。客户端只是调用Stub对象中的本地方法，Stub对象是一个本地对象，它实现了远程对象向外暴露的接口，也就是说它的方法和远程对象暴露的方法的签名是相同的。客户端认为它是调用远程对象的方法，实际上是调用Stub对象中的方法。可以理解为Stub对象是远程对象在本地的一个代理，当客户端调用方法的时候，Stub对象会将调用通过网络传递给远程对象。  
所以从逻辑上来看，数据是在`Client`和`Server`之间横向流动的，但是实际上是从`Client`到`Stub`，然后从`Skeleton`到`Server`这样纵向流动的。**RMI是基于socket通信的，是纯java语言的，不可跨平台。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppblhZYW4_size_16_color_FFFFFF_t_70][]

## **Demo** ##

**1. 远程服务的接口定义**

第一步就是建立和编译服务接口的Java代码。这个接口定义了所有的提供远程服务的功能，下面是源程序：

UserManagerInterface.java

package cn.com.tt.rmiserver.stub;
    
    import java.rmi.Remote;
    import java.rmi.RemoteException;
    
    import cn.com.tt.rmiserver.bean.Account;
    
    public interface UserManagerInterface extends Remote{
        public String getUserName() throws RemoteException;
        public Account getAdminAccount() throws RemoteException;
    }

接口必须继承Remote类，每一个定义地方法都要抛出RemoteException异常对象。

**  2. 接口的具体实现**

第二步就是对于上面的接口进行实现:

UserManagerImp.java

package cn.com.tt.rmiserver;
    import java.rmi.RemoteException;
    import cn.com.tt.rmiserver.stub.UserManagerInterface;
    import cn.com.tt.rmiserver.bean.Account;
    
    public class UserManagerImp implements UserManagerInterface {
        public UserManagerImp() throws RemoteException {
        }
        private static final long serialVersionUID = -3111492742628447261L;
        public String getUserName() throws RemoteException{
            return "TT";
        }
        public Account getAdminAccount() throws RemoteException{
            Account account=new Account();
            account.setUsername("TT");
            account.setPassword("123456");
            return account;
        }
    }

**3. 定义一个bean，实现implements Serializable序列化接口。也就是可以在client和server端进行传输的可序列化对象。**

Account.java

package cn.com.tt.rmiserver.bean;
    
    import java.io.Serializable;
    
    public class Account implements Serializable,Cloneable{
        private static final long serialVersionUID = -1858518369668584532L;
        private String username;
        private String password;
        
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        public String getPassword() {
            return password;
        }
        public void setPassword(String password) {
            this.password = password;
        }
    }

**  4. 定义server端的主程序入口。**

Entry.java

package cn.com.tt.rmiserver.entry;
    
    import java.rmi.AlreadyBoundException;
    import java.rmi.RemoteException;
    import java.rmi.registry.LocateRegistry;
    import java.rmi.registry.Registry;
    import java.rmi.server.UnicastRemoteObject;
    import cn.com.tt.rmiserver.UserManagerImp;
    import cn.com.tt.rmiserver.stub.UserManagerInterface;
    
    public class Entry {
        public static void main(String []args) throws AlreadyBoundException, RemoteException{
            UserManagerImp userManager=new UserManagerImp();
            UserManagerInterface userManagerI=(UserManagerInterface)UnicastRemoteObject.exportObject(userManager,0);
            // Bind the remote object's stub in the registry
            Registry registry = LocateRegistry.createRegistry(2002);
           
            registry.rebind("userManager", userManagerI);
            System.out.println("server is ready");
            }
    }

**5 client端代码**

ClientEntry.java

package weiblog.rmi;
    
    import java.rmi.NotBoundException;
    import java.rmi.RemoteException;
    import java.rmi.registry.LocateRegistry;
    import java.rmi.registry.Registry;
    import cn.com.tt.rmiserver.stub.UserManagerInterface;
    
    public class ClientEntry {
        
        public static void main(String []args){
            
            try {
                Registry registry = LocateRegistry.getRegistry("localhost",2002);
                UserManagerInterface userManager = (UserManagerInterface)registry.lookup("userManager");
                System.out.println("用户名是"+userManager.getAdminAccount().getUsername()
                        +"密码"+userManager.getAdminAccount().getPassword());
            } catch (RemoteException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (NotBoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }        
        }
    }

6 先运行服务器端代码， 然后运行客户端代码，就会显示运行结果，客户端可以运行多次，每次都可以取得服务器端的对象。如果要再次运行客户端代码就需要更改端口号，如果不更改就会显示端口号被占用。

参考：

[https://www.cnblogs.com/xt0810/p/3640167.html][https_www.cnblogs.com_xt0810_p_3640167.html]

[https://blog.csdn.net/lmy86263/article/details/72594760][https_blog.csdn.net_lmy86263_article_details_72594760]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ppblhZYW4_size_16_color_FFFFFF_t_70]: /images/20220216/0a888f0b3afa4cea8415461c5d7d2f80.png
[https_www.cnblogs.com_xt0810_p_3640167.html]: https://www.cnblogs.com/xt0810/p/3640167.html
[https_blog.csdn.net_lmy86263_article_details_72594760]: https://blog.csdn.net/lmy86263/article/details/72594760