随笔- 254 文章- 0 评论- 35 阅读- 57万

RPC简介与实践

　　本文是RPC的简介与实践，首先介绍一下RPC的概念与原理，接着介绍一下Go语言对RPC的支持，最后提供一个Go语言原生RPC的简单demo。

一、RPC是什么

　　RPC，全称：Remote Procedure Call，中文翻译：远程过程调用。

　　RPC是一种技术思想，而非规范或协议，它指的是，本地计算机程序通过网络向远程计算机程序请求服务，隐藏底层网络技术，使其看起来就像调用本地函数一样简便，服务提供方与调用方都无需了解底层网络的传输细节。

二、RPC是怎么工作的

1. RPC框架的组成

（1）客户端(Client)：服务调用者。

（2）服务端(Server)：服务提供者。

（3）客户端存根(Client Stub)：存放服务端的地址信息，负责将客户端的请求参数打包成网络消息，通过网络远程发送给服务方。

（4）服务端存根(Server Stub)：接收调用方发送过来的消息，将消息解包，并调用本地的方法。

（5）底层网络传输：可以是TCP或HTTP。

2. 一次完整的RPC调用流程

简单图示：

详细介绍：

（1）客户端通过本地调用的方式调用服务。

（2）客户端存根接收到调用请求后负责将调用的方法、参数等信息序列化成网络消息体，找到远程服务的地址，将消息通过网络发送给服务方。

（3）服务端存根接收到消息后进行解码(反序列化)，根据解码结果调用本地服务。

（4）服务端调用本地方法进行业务逻辑处理，然后将处理结果返回给服务端存根。

（5）服务端存根将调用结果序列化，然后通过网络发送给调用方。

（6）客户端存根收到消息，将消息进行解码(方序列化)，得到调用结果，将结果发送给客户端。

（7）客户端最终得到服务调用结果。

三、Go语言对RPC的支持

1. Go内置RPC

　　Go标准包“net/rpc”中已经提供了对RPC的支持，而且支持三个级别的RPC：TCP、HTTP、JSONRPC。但Go的RPC只支持Go开发的服务器与客户端之间的交互，无法跨语言调用，因为在内部，它们采用了Gob编码。

2. 什么是Gob编码

　　Gob是Go语言内置的编解码方式，可以支持变长类型的编解码(意味着通用)而且它的效率比json，xml更高。

3. Go的RPC函数怎么写

　　Go RPC函数只有符合下面的条件才能被远程访问，否则会被忽略：

（1）函数必须是导出的(函数名称首字母大写)。

（2）必须有两个导出类型的参数，第一个是接收的参数，第二个是返回给客户端的参数，第二个参数必须是指针类型的。

（3）必须有一个error类型的返回值。

4. 一个简单的demo

　　这里提供一个基于TCP的RPC简单demo，逻辑很简单，就是求两个整型数值的乘机与商余，代码如下。

（1）服务端：

/**
* rpc demo tcp server - 求两数的乘积与商余
* author: JetWu
* date: 2020.04.21
 */
package main
 
import (
    "errors"
    "fmt"
    "log"
    "net"
    "net/rpc"
    "time"
)
 
//接收参数
type Args struct {
    A, B int
}
 
//返回参数
type Quotient struct {
    Quo, Rem int
}
 
//RPC服务函数
 
type Arith int
 
func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    return nil
}
 
func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B
    return nil
}
 
func main() {
    //RPC服务注册
    arith := new(Arith)
    rpc.Register(arith)
 
    tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
    if err != nil {
        log.Fatal("net.ResolveTCPAddr err: ", err)
    }
    //监听网络
    listener, err := net.ListenTCP("tcp", tcpAddr)
    if err != nil {
        log.Fatal("net.ListenTCP err: ", err)
    }
    defer listener.Close()
    log.Println("rpc demo tcp server started ...")
 
    for {
        fmt.Printf("accepted at %v\n", time.Now())
        //等待客户端连接
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("listener.Accept err: ", err)
            continue
        }
        fmt.Printf("getted at %v\n", time.Now())
        //为客户端提供服务
        go rpc.ServeConn(conn)
    }
}

（2）客户端：

/**
* rpc demo tcp client - 求两数的乘积与商余
* author: JetWu
* date: 2020.04.21
 */
package main
 
import (
    "fmt"
    "log"
    "net/rpc"
)
 
//接收参数
type Args struct {
    A, B int
}
 
//返回参数
type Quotient struct {
    Quo, Rem int
}
 
func main() {
    //连接服务端
    client, err := rpc.Dial("tcp", ":1234")
    if err != nil {
        log.Fatal("rpc.Dial error: ", err)
    }
    log.Println("successfully connected to the rpc demo tcp server ...")
 
    //RPC服务调用
 
    args := Args{17, 8}
    var reply int
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatal("Arith.Multiply error: ", err)
    }
    fmt.Printf("Arith.Multiply: %d * %d = %d\n", args.A, args.B, reply)
 
    var quo Quotient
    err = client.Call("Arith.Divide", args, &quo)
    if err != nil {
        log.Fatal("Arith.Divide error: ", err)
    }
    fmt.Printf("Arith.Divide: %d / %d = %d remainder %d\n", args.A, args.B, quo.Quo, quo.Rem)
}