RPC远程调用机制

RPC技术内部原理是通过两种技术的组合来实现的：本地方法调用 和 网络通信技术。

RPC简介

　　RPC是Remote Procedure Call Protocol单词首字母的缩写，简称为：RPC，翻译成中文叫远程过程调用协议。所谓远程过程调用，通俗的理解就是可以在本地程序中调用运行在另外一台服务器上的程序的功能方法。这种调用的过程跨越了物理服务器的限制，是在网络中完成的，在调用远端服务器上程序的过程中，本地程序等待返回调用结果，直到远端程序执行完毕，将结果进行返回到本地，最终完成一次完整的调用。

　　需要强调的是：远程过程调用指的是调用远端服务器上的程序的方法整个过程。

RPC设计组成

　　RPC技术在架构设计上有四部分组成，分别是：客户端、客户端存根、服务端、服务端存根。

　　　　客户端（client）：服务调用发起方，也称为服务消费者。

　　　　客户端存根(Client Stub)：该程序运行在客户端所在的计算机机器上，主要用来存储要调用的服务器的地址，另外，该程序还负责将客户端请求远端服务器程序的数据信息打包成数据包，通过网络发送给服务端Stub程序；其次，还要接收服务端Stub程序发送的调用结果数据包，并解析返回给客户端。

　　　　服务端(Server)：远端的计算机机器上运行的程序，其中有客户端要调用的方法。

　　　　服务端存根(Server Stub)：接收客户Stub程序通过网络发送的请求消息数据包，并调用服务端中真正的程序功能方法，完成功能调用；其次，将服务端执行调用的结果进行数据处理打包发送给客户端Stub程序。

RPC原理及调用步骤

　　

 

　　在上述图中，通过1-10的步骤图解的形式，说明了RPC每一步的调用过程。具体描述为：

　　　　1、客户端想要发起一个远程过程调用，首先通过调用本地客户端Stub程序的方式调用想要使用的功能方法名；

　　　　2、客户端Stub程序接收到了客户端的功能调用请求，将客户端请求调用的方法名，携带的参数等信息做序列化操作，并打包成数据包。

　　　　3、客户端Stub查找到远程服务器程序的IP地址，调用Socket通信协议，通过网络发送给服务端。

　　　　4、服务端Stub程序接收到客户端发送的数据包信息，并通过约定好的协议将数据进行反序列化，得到请求的方法名和请求参数等信息。

　　　　5、服务端Stub程序准备相关数据，调用本地Server对应的功能方法进行，并传入相应的参数，进行业务处理。

 

 　　　  6、服务端程序根据已有业务逻辑执行调用过程，待业务执行结束，将执行结果返回给服务端Stub程序。

　　　　7、服务端Stub程序将程序调用结果按照约定的协议进行序列化，并通过网络发送回客户端Stub程序。

　　　　8、客户端Stub程序接收到服务端Stub发送的返回数据，对数据进行反序列化操作，并将调用返回的数据传递给客户端请求发起者。

　　　　9、客户端请求发起者得到调用结果，整个RPC调用过程结束。

RPC涉及到的相关技术

　　1、动态代理技术： 上文中我们提到的Client Stub和Sever Stub程序，在具体的编码和开发实践过程中，都是使用动态代理技术自动生成的一段程序。

　　2、序列化和反序列化： 在RPC调用的过程中，我们可以看到数据需要在一台机器上传输到另外一台机器上。在互联网上，所有的数据都是以字节的形式进行传输的。而我们在编程的过程中，往往都是使用数据对象，因此想要在网络上将数据对象和相关变量进行传输，就需要对数据对象做序列化和反序列化的操作。

　　　　序列化：把对象转换为字节序列的过程称为对象的序列化，也就是编码的过程。

　　　　反序列化：把字节序列恢复为对象的过程称为对象的反序列化，也就是解码的过程。

RPC官方库

　　在Go语言官方网站的pkg说明中，提供了官方支持的rpc包，具体链接如下：https://golang.org/pkg/net/rpc/。官方提供的rpc包完整的包名是：net/rpc。根据官方的解释，rpc包主要是提供通过网络访问一个对象方法的功能。

net/rpc库实现RPC调用编程

一、服务定义及暴露

　　在编程实现过程中，服务器端需要注册结构体对象，然后通过对象所属的方法暴露给调用者，从而提供服务，该方法称之为输出方法，此输出方法可以被远程调用。当然，在定义输出方法时，能够被远程调用的方法需要遵循一定的规则。我们通过代码进行讲解：

func (t *T) MethodName(request T1,response *T2) error

　　上述代码是go语言官方给出的对外暴露的服务方法的定义标准，其中包含了主要的几条规则，分别是：

　　　　1、对外暴露的方法有且只能有两个参数，这个两个参数只能是输出类型或内建类型，两种类型中的一种。

　　　　2、方法的第二个参数必须是指针类型。

　　　　3、方法的返回类型为error。

　　　　4、方法的类型是可输出的。

　　　　5、方法本身也是可输出的。

　　

type MathUtil struct {
}

func (this *MathUtil) CalculateCircleArea(req float32, resp *float32) error {
    *resp = math.Pi * req * req
    return nil
}

 

二、注册服务及监听请求

//1、初始化指针数据类型
mathUtil := new(MathUtil)

//2、调用net/rpc包的功能将服务对象进行注册
err := rpc.Register(mathUtil)
if err != nil {
   panic(err.Error())
}

//3、通过该函数把mathUtil中提供的服务注册到HTTP协议上，方便调用者可以利用http的方式进行数据传递
rpc.HandleHTTP()

//4、在特定的端口进行监听
listen, err := net.Listen("tcp", ":8081")
if err != nil {
   panic(err.Error())
}
go http.Serve(listen, nil)

三、客户端调用

　　在服务端是通过Http的端口监听方式等待连接的，因此在客户端就需要通过http连接，首先与服务端实现连接。

　　

client, err := rpc.DialHTTP("tcp", "localhost:8081")
    if err != nil {
        panic(err.Error())
    }

    var req float32
    req = 3

    var resp *float32
    err = client.Call("MathUtil.CalculateCircleArea", req, *resp)
    if err != nil {
        panic(err.Error())
    }
    fmt.Println(*resp)

　　上述的调用方法核心在于client.Call方法的调用，该方法有三个参数，第一个参数表示要调用的远端服务的方法名，第二个参数是调用时要传入的参数，第三个参数是调用要接收的返回值。
　　上述的Call方法调用实现的方式是同步的调用，除此之外，还有一种异步的方式可以实现调用。异步调用代码

    var respSync *float32
    //异步的调用方式
    syncCall := client.Go("MathUtil.CalculateCircleArea", req, &respSync, nil)
    replayDone := <-syncCall.Done
    fmt.Println(replayDone)
    fmt.Println(*respSync)    

多参数的请求调用参数传递

　　将参数定义在一个新的结构体中，存放在param包中：

type AddParma struct {
    Args1 float32 //第一个参数
    Args2 float32 //第二个参数
}

　　在server.go文件中，实现两数相加的功能，并实现服务注册的逻辑：

func (mu *MathUtil) Add(param param.AddParma, resp *float32) error {
    *resp = param.Args1 + param.Args2 //实现两数相加的功能
    return nil
}
mathUtil := new(MathUtil)

    err := rpc.RegisterName("MathUtil", mathUtil)
    if err != nil {
        panic(err.Error())
    }

    rpc.HandleHTTP()

    listen, err := net.Listen("tcp", ":8082")
    http.Serve(listen, nil)

 

RPC与Protobuf结合使用

　　需求：假设在一个系统中，有订单模块（Order），其他模块想要实现RPC的远程工程调用，根据订单ID和时间戳可以获取订单信息。如果获取成功就返回相应的订单信息；如果查询不到返回失败信息。现在，我们来进行需求的编程实现。

传输数据格式定义

　　数据定义

　　根据需求，定义message.proto文件，详细定义如下：

syntax = "proto3";
package message;

// 订单请求参数
message OrderRequest {
    string orderId = 1;
    int64 timeStamp = 2;
}

// 订单信息
message OrderInfo {
    string OrderId = 1;
    string OrderName = 2;
    string OrderStatus = 3;
}

　　编译proto文件

　　通过proto编译命令对.proto文件进行编译，自动生成对应结构体的Go语言文件。编译命令如下：

protoc ./message.proto --go_out=./

Protobufg格式数据与RPC结合

　　服务的定义:

　　进行RPC远程过程调用，实现调用远程服务器的方法，首先要有服务。在本案例中，定义提供订单查询功能的服务，取名为OrderService，同时提供订单信息查询方法供远程调用。详细的服务和方法定义如下：

type OrderService struct {
}

func (this *OrderService) GetOrderInfo(request message.OrderRequest, response *message.OrderInfo) error {
    orderMap := map[string]message.OrderInfo{
        "201907300001": message.OrderInfo{OrderId: "201907300001", OrderName: "衣服", OrderStatus: "已付款"},
        "201907310001": message.OrderInfo{OrderId: "201907310001", OrderName: "零食", OrderStatus: "已付款"},
        "201907310002": message.OrderInfo{OrderId: "201907310002", OrderName: "食品", OrderStatus: "未付款"},
    }
    current := time.Now().Unix()
    if (request.TimeStamp > current) {
        *response = message.OrderInfo{OrderId: "0", OrderName: "", OrderStatus: "订单信息异常"}
    } else {
        result := orderMap[request.OrderId]
        if result.OrderId != "" {
            *response = orderMap[request.OrderId]
        } else {
            return errors.New("server error")
        }
    }
    return nil
}

　　在服务的方法定义中，使用orderMap模拟初始订单数据库，方便案例查询展示。GetOrderInfo方法有两个参数，第一个是message.OrderRequest，作为调用者传递的参数，第二个是message.OrderInfo，作为调用返回的参数，通过此处的两个参数，将上文通过.proto定义并自动生成的Go语言结构体数据结合起来。

　　服务的注册和处理

　　服务定义好以后，需要将服务注册到RPC框架，并开启http请求监听处理。这部分代码与之前的RPC服务端实现逻辑一致，具体实现如下：

func main() {

    orderService := new(OrderService)

    rpc.Register(orderService)

    rpc.HandleHTTP()

    listen, err := net.Listen("tcp", ":8081")
    if err != nil {
        panic(err.Error())
    }
    http.Serve(listen, nil)
}

　　RPC客户端调用实现

　　在客户端，除了客户端正常访问远程服务器的逻辑外，还需要准备客户端需要传递的请求数据message.OrderInfo。具体实现如下：

func main() {
    client, err := rpc.DialHTTP("tcp", "localhost:8081")
    if err != nil {
        panic(err.Error())
    }
    timeStamp := time.Now().Unix()
    request := message.OrderRequest{OrderId: "201907300001", TimeStamp: timeStamp}
    var response *message.OrderInfo
    err = client.Call("OrderService.GetOrderInfo", request, &response)
    if err != nil {
        panic(err.Error())
    }
    fmt.Println(*response)
}

运行结果