Golang基础(7)：go的net/rpc用法

一：PRC是什么？

RPC(Remote Procedure Call) 远程过程调用，是一个计算通信协议。该协议允许一台计算机上的程序调用另外一台计算机上的程序。
远程过程调用就是2个不在同一台计算机上的程序方法，根据一定的规则可以彼此进行调用

二：为什么要用RPC

当一个公司跨部门合作，或者跨公司合作时，你不想暴露自己项目太多的数据，而只允许对方获取特定的数据时候，你就可以用RPC了。 还有就是方法参数确定了后，函数内部的实现不管你怎么变化，都不会影响彼此

那你要问： 我用RESTful 不是一样吗？
那就来说说这2者的区别：
1：RPC的客户端和服务端是紧耦合的，客户端要知道调用过程的名字，过程的参数以及类型，顺序
RESTful是基于HTTP的语义来操作资源，参数的顺序一般关系不大，也容易通过代理转换链接和资源的位置，从这一点说，RESTful更灵活

2：他们操作不一样。 RPC操作的是过程和方法。 RESTful操作的是资源，不是方法

3：RESTful执行的是对资源的操作，增加、查找、修改和删除等,主要是CURD，所以如果你要实现一个特定目的的操作，比如为名字姓张的学生的数学成绩都加上10这样的操作， RESTful的API设计起来就不是那么直观或者有意义。在这种情况下, RPC的实现更有意义，它可以实现一个 Student.Increment(Name, Score) 的方法供客户端调用

4：如果我们用socket实现RPC，那么就能获取性能上的优势。在大并发的情况下，RPC的性能优于RESTful

所以通常情况下，我们对内是用rpc提供服务，对外用RESTful提供服务

三：golang中的rpc

golang官方给我们提供了一个net/rpc的库使用，它支持tpc，http，JSONRPC数据传输。但是它只能用于go内部使用，为什么？因为它使用了一个go自带的库（encoding/gob）来编码和解码。如果需要跨平台那么需要其它的rpc框架了，比如thrift，gRPC等等

net/rpc的远程调用还有一些附加条件：

1. 函数必须是导出的(首字母大写)
2. 必须有两个导出类型的参数
3. 第一个参数是接收的参数，第二个参数是返回给客- 户端的参数，第二个参数必须是指针类型的
4. 函数还要有一个返回值error

举个例子，正确的RPC函数格式如下：
func (t *T) MethodName(argType T1, replyType *T2) error
T、T1和T2类型必须能被encoding/gob包编解码。

四：net/rpc 库

服务端代码：rpc_server.go

package main

import (
    "errors"
    "log"
    "net"
    "net/http"
    "net/rpc"
)

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

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() {
    arith := new(Arith)
    rpc.Register(arith)
    rpc.HandleHTTP()
    l, e := net.Listen("tcp", ":1212")
    if e != nil {
        log.Fatal("listen error: ", e)
    }
    http.Serve(l, nil)
}

简单分析一下上面的例子，先实例化了一个Arith对象arith，然后给arith注册了rpc服务，然后把rpc挂载到http服务上面，当http服务打开的时候我们就可以通过rpc客户端来调用arith中符合rpc标准的的方法了

客户端代码：rpc_client.go

package main

import (
    "fmt"
    "log"
    "net/rpc"
)

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

func main() {
    client, err := rpc.DialHTTP("tcp", "127.0.0.1:1212")
    if err != nil {
        log.Fatal("dialing: ", err)
    }

    args := &Args{7, 8}
    var reply int
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatal("arith error: ", err)
    }
    fmt.Printf("Arith: %d*%d=%d
", args.A, args.B, reply)

    quotient := new(Quotient)
    divCall := client.Go("Arith.Divide", args, quotient, nil)
    replyCall := <-divCall.Done
    if replyCall.Error != nil {
        log.Fatal("arith error: ", replyCall.Error)
    }
    fmt.Printf("Arith: %d/%d = %d...%d", args.A, args.B, quotient.Quo, quotient.Rem)
}

简单说明下，先用rpc的DialHTTP方法连接服务器端，调用服务器端的函数就要使用Call方法了，Call方法的参数和返回值已经很清晰的表述出rpc整体的调用逻辑了
运行服务器端跑起来，

$ go run rpc_server.go

再把客户端跑起来，这时候客户端会输出：
$ go run rpc_client.go
Arith: 7*8=56
Arith: 7/8 = 0...7

参考：
https://www.cnblogs.com/andyidea/p/6525714.html