[golang note] 网络编程 - RPC编程

net包

---

• 官方文档

http://godoc.golangtc.com/pkg/net/

Package net provides a portable interface for network I/O, including TCP/IP, UDP, domain name resolution, and Unix domain sockets.

net包中提供了一系列可移植的网络I/O接口，其中包含了TCP/IP、UDP、域名解析和Unix域套接字。

RPC

---

• RPC定义

RPC，Remote Procedure Call Protocol，远程过程调用协议。RPC是一种通过网络从远程计算机程序上请求服务，但不需要了解底层网络技术的一种协议。RPC协议基于某些传输协议（如TCP和UDP协议等）而存在，为通信程序之间携带信息数据。

在传统计算机编程语言中，譬如C和C++，实现RPC是一件不容易的事情。为了实现RPC，首先得基于不同的操作系统提供的网络模型实现网络通信，然后需要自己封装协议来实现RPC，通常为了方便使用还结合使用Lua进行脚本调用。而golang语言原生支持RPC，极大地提高了开发效率。

• net/rpc包

在golang中，标准库提供的net/rpc包实现了RPC协议的相关细节，开发者可以方便地使用该包编写出RPC服务端和客户端程序，这使得用golang开发多个进程之间通信变得非常简单。

官网介绍：rpc包提供了基于网络或其他I/O连接来访问某个对象的导出函数的方法。服务端需要注册提供RPC服务的对象，并以该对象类型的名称作为可见的服务名。对象注册完成之后，该对象的导出函数将可以被远程访问。服务端可以注册多个不同类型的对象作为服务，但是需要注意的是，注册同一类型的多个对象将引发错误。

▶ 导出函数需满足的条件

• 函数的类型需要导出。

• 函数需要导出。

• 函数必须拥有两个参数，参数必须是导出类型或内建类型。

• 函数的第二个参数必须是一个指针。

• 函数必须返回一个error类型的值。

满足上述条件的函数可以简单表示成：

• 类型T、T1和T2默认使用golang内置的encoding/gob包进行编码解码。

• 第一个参数argType表示由RPC客户端传入的参数。

• 第二个参数replyType表示要返回给RPC客户端的结果。

• 函数最后返回一个error类型的值。如果一个error值返回，replyType参数将不会发送给RPC客户端，而error值将会作为一个字符串发送给RPC客户端。

▶ RPC服务端

• RPC服务端可以通过调用ServeConn处理单个连接上的请求。

• 多数情况下，RPC服务端将创建一个TCP网络监听器并调用Accept，或创建一个HTTP监听器并调用HandleHTTP和http.Serve。

• 如果没有明确指定RPC传输过程中使用何种编码解码器，默认将使用标准库提供的encoding/gob包进行数据传输的编解码器。

▶ RPC客户端

• 将要使用RPC服务的客户端需要建立连接，然后在连接上调用NewClient函数。

• net/rpc包提供了便利的rpc.Dial()和rpc.DialHTTP()方法来与指定的RPC服务端建立连接。

• net/rpc包允许客户端使用同步或异步的方式接收RPC服务端的处理结果：调用RPC客户端的Call()方法将进行同步处理，客户端程序顺序执行，只有接收完RPC服务端的处理结果之后才可继续执行后面的程序；调用RPC客户端的Go()方法时将进行异步处理，RPC客户端程序无需等待服务端的结果即可执行后面的程序，而当接收到RPC服务端的处理结果时，再对其进行相应的处理。

• 如果没有明确指定RPC传输过程中使用何种编码解码器，默认将使用标准库提供的encoding/gob包进行数据传输的编解码器。

HTTP RPC使用

---

• HTTP RPC服务端

▶ 目录结构

▶ 源码如下

package main

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

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 ==  {
        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", ":1234")
    defer l.Close()
    if e != nil {
        log.Fatal("listen error:", e)
        return
    }

    go http.Serve(l, nil)
    log.Println("rpc server started!")

    for {
        time.Sleep( * time.Second)
    }
}

• HTTP RPC客户端

▶ 目录结构

▶ 源码如下

package main

import (
    "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"+":1234")
    defer client.Close()
    if err != nil {
        log.Fatal("dialing error:", err)
        return
    }

    args1 := &Args{, }
    args2 := &Args{, }
    args3 := &Args{, }

    reply1 :=
    reply2 := Quotient{}
    reply3 := Quotient{}

    err = client.Call("Arith.Multiply", args1, &reply1)
    if err != nil {
        log.Fatal("Arith error:", err)
        return
    }
    log.Println(reply1) //

    err = client.Call("Arith.Divide", args2, &reply2)
    if err != nil {
        log.Fatal("Arith error:", err)
        return
    }
    log.Println(reply2) // {3 1}

    err = client.Call("Arith.Divide", args3, &reply3)
    if err != nil {
        log.Fatal("Arith error:", err) // arith error:divide by zero
        return
    }
    log.Println(reply3)
}

TCP RPC使用

---

• TCP RPC服务端

▶ 目录结构

▶ 源码如下

package main

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

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 ==  {
        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)
    server := rpc.NewServer()
    server.Register(arith)

    l, e := net.Listen("tcp", ":1234")
    defer l.Close()

    if e != nil {
        log.Fatal("listen error:", e)
        return
    }

    go server.Accept(l)
    log.Println("rpc server started!")

    for {
        time.Sleep( * time.Second)
    }
}

• TCP RPC客户端

▶ 目录结构

▶ 源码如下

package main

import (
    "log"
    "net/rpc"
)

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

func main() {
    client, err := rpc.Dial("tcp", "127.0.0.1:1234")
    defer client.Close()

    if err != nil {
        log.Fatal("dialing error:", err)
        return
    }

    args1 := &Args{, }
    args2 := &Args{, }
    args3 := &Args{, }

    reply1 :=
    reply2 := Quotient{}
    reply3 := Quotient{}

    // 同步方式RPC
    err = client.Call("Arith.Multiply", args1, &reply1)
    if err != nil {
        log.Fatal("Arith error:", err)
        return
    }
    log.Println(reply1) // 6

    // 异步方式RPC
    call2 := client.Go("Arith.Divide", args2, &reply2, nil)
    if call2 != nil {
        if replyCall, ok := <-call2.Done; ok {
            if replyCall.Error != nil {
                log.Fatal("Arith error:", replyCall.Error)
                return
            }
            log.Println(reply2) // {3 1}
        }
    }

    // 异步方式RPC
    call3 := client.Go("Arith.Divide", args3, &reply3, nil)
    if call3 != nil {
        if replyCall, ok := <-call3.Done; ok {
            if replyCall.Error != nil {
                log.Fatal("Arith error:", replyCall.Error) // Arith error:divide by zero
                return
            }
            log.Println(reply3) // {3 1}
        }
    }
}

Protobuf RPC使用

---

• 环境准备

官网（https://github.com/golang/protobuf）介绍的安装步骤如下：

▶ 安装protobuf

下载地址：https://developers.google.com/protocol-buffers/

▪ windows下安装

下载地址：https://developers.google.com/protocol-buffers/docs/downloads

▪ 下载protoc-2.6.1-win32.zip并解压；

▪ 将protoc.exe路径加入系统路径；

▪ linux下安装

▶ 安装goprotobuf插件

Tips:
    需要注意的是，使用go get命令之前需要安装git for windows，否则命令将不起作用。

▪ 在命令行下运行如下命令：

go get -u github.com/golang/protobuf/proto
go get -u github.com/golang/protobuf/protoc-gen-go
go install github.com/golang/protobuf/proto
go install github.com/golang/protobuf/protoc-gen-go

▪ 工程bin目录下会生成protoc-gen-go.exe文件，将工程bin目录加入系统路径（windows下path路径），以便该工具文件使用。

• 编写proto文件

在src目录下新建pbprotocol目录，并在该目录下新建一个arith.proto的文本文件，编辑该文件内容如下：

package arith;

option cc_generic_services   = true;
option java_generic_services = true;
option py_generic_services   = true;

message ArithRequest {
    optional int32 a = ;
    optional int32 b = ;
}

message ArithResponse {
    optional int32 c = ;
}

service ArithService {
    rpc Multiply (ArithRequest) returns (ArithResponse);
    rpc Divide   (ArithRequest) returns (ArithResponse);
}

在命令行进入pbprotocol目录，运行下面命令，生成目标文件arith.pb.go。

protoc --go_out=. arith.proto

对应的目录结构：       
      

• Protobuf RPC服务端

▶ 目录结构

▶ 源码如下

package main

import (
    "errors"
    "log"
    "net"
    "net/http"
    "net/rpc"
    "pbprotocol"
    "time"

    "github.com/golang/protobuf/proto"
)

type Arith int

func (t *Arith) Multiply(args *arith.ArithRequest, reply *arith.ArithResponse) error {
    reply.C = proto.Int32(args.GetA() * args.GetB())
    return nil
}

func (t *Arith) Divide(args *arith.ArithRequest, reply *arith.ArithResponse) error {
    if args.GetB() ==  {
        return errors.New("divide by zero")
    }

    reply.C = proto.Int32(args.GetA() / args.GetB())
    return nil
}

func main() {
    arith := new(Arith)
    rpc.Register(arith)
    rpc.HandleHTTP()

    l, e := net.Listen("tcp", ":1234")
    defer l.Close()

    if e != nil {
        log.Fatal("listen error:", e)
        return
    }

    go http.Serve(l, nil)
    log.Println("rpc server started!")

    for {
        time.Sleep( * time.Second)
    }
}

• Protobuf RPC客户端

▶ 目录结构

▶ 源码如下

package main

import (
    "log"
    "net/rpc"
    "pbprotocol"

    "github.com/golang/protobuf/proto"
)

func main() {
    client, err := rpc.DialHTTP("tcp", "127.0.0.1"+":1234")
    defer client.Close()

    if err != nil {
        log.Fatal("dialing error:", err)
        return
    }

    var args arith.ArithRequest
    var reply arith.ArithResponse

    // Multiply
    args.A = proto.Int32()
    args.B = proto.Int32()

    err = client.Call("Arith.Multiply", &args, &reply)
    if err != nil {
        log.Fatal("Arith error:", err)
        return
    }
    log.Println(reply.GetC()) // 2

    // Divide
    args.A = proto.Int32()
    args.B = proto.Int32()

    err = client.Call("Arith.Divide", &args, &reply)
    if err != nil {
        log.Fatal("Arith error:", err)
        return
    }
    log.Println(reply.GetC()) // 2

    // Divide zero
    args.A = proto.Int32()
    args.B = proto.Int32()

    err = client.Call("Arith.Divide", &args, &reply)
    if err != nil {
        log.Fatal("Arith error:", err) // arith error:divide by zero
        return
    }
    log.Println(reply.GetC())
}