Go实战--go中使用rpc(Thewaytogo)

生命不止，继续 go go go !!!

今天聊聊golang中如何使用rpc，各位先稍安勿躁，我们先介绍一些基本的知识。

TCP和Http
这个stackoverlow上的回答，觉得很好，搬过来：

HTTP is a layer built ontop of the TCP layer to some what standardize data transmission. So naturally using TCP sockets will be less heavy than using HTTP. If performance is the only thing you care about then plain TCP is the best solution for you.

You may want to consider HTTP because of its ease of use and simplicity which ultimately reduces development time. If you are doing something that might be directly consumed by a browser (through an AJAX call) then you should use HTTP. For a non-modern browser to directly consume TCP connections without HTTP you would have to use Flash or Silverlight and this normally happens for rich content such as video and/or audio. However, many modern browsers now (as of 2013) support API’s to access network, audio, and video resources directly via Javascript. The only thing to consider is the usage rate of modern web browsers among your users; see caniuse.com for the latest info regarding browser compatibility.

As for benchmarks, this is the only thing I found. See page 5, it has the performance graph. Note that it doesn’t really compare apples to apples since it compares the TCP/Binary data option with the HTTP/XML data option. Which begs the question: what kind of data are your services outputting? binary (video, audio, files) or text (JSON, XML, HTML)?

In general performance oriented system like those in the military or financial sectors will probably use plain TCP connections. Where as general web focused companies will opt to use HTTP and use IIS or Apache to host their services.

什么是rpc
RPC是Remote Procedure CallProtocol的缩写，即—远程过程调用协议。

RPC是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。如果涉及的软件采用面向对象编程，那么远程过程调用亦可称作远程调用或远程方法调用，信息数据。通过它可以使函数调用模式网络化。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

net/rpc

Go语言标准库能够自带一个rpc框架还是非常给力的，这可以很大程度的降低写后端网络通信服务的门槛，特别是在大规模的分布式系统中，rpc基本是跨机器通信的标配。rpc能够最大程度屏蔽网络细节，让开发者专注在服务功能的开发上面。

Package rpc provides access to the exported methods of an object across a network or other I/O connection. A server registers an object, making it visible as a service with the name of the type of the object. After registration, exported methods of the object will be accessible remotely. A server may register multiple objects (services) of different types but it is an error to register multiple objects of the same type.

Go RPC的函数只有符合下面的条件才能被远程访问，不然会被忽略，详细的要求如下：
1. 函数必须是导出的(首字母大写)
2. 必须有两个导出类型的参数，
3. 第一个参数是接收的参数，第二个参数是返回给客户端的参数，第二个参数必须是指针类型的
4. 函数还要有一个返回值error

下面介绍几个方法：
Register–注册

func Register(rcvr interface{}) error

Register publishes the receiver’s methods in the DefaultServer.

NewServer

func NewServer() *Server

NewServer returns a new Server.

func (*Server) HandleHTTP

func (server *Server) HandleHTTP(rpcPath, debugPath string)

HandleHTTP registers an HTTP handler for RPC messages on rpcPath, and a debugging handler on debugPath. It is still necessary to invoke http.Serve(), typically in a go statement.

func Accept

func Accept(lis net.Listener)

Accept accepts connections on the listener and serves requests to DefaultServer for each incoming connection. Accept blocks; the caller typically invokes it in a go statement.

func Dial

func Dial(network, address string) (*Client, error)

Dial connects to an RPC server at the specified network address.

RPC可以利用TCP和HTTP进行传递数据，所以这也是为什么最开始介绍了一下tcp vs http.

下面的实现出自于：
https://astaxie.gitbooks.io/build-web-application-with-golang/zh/08.4.html

基于HTTP的RPC
服务端：

package main

    import (
        "errors"
        "fmt"
        "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()

        err := http.ListenAndServe(":1234", nil)
        if err != nil {
            fmt.Println(err.Error())
        }
    }

客户端：

package main

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

    type Args struct {
        A, B int
    }

    type Quotient struct {
        Quo, Rem int
    }

    func main() {
        if len(os.Args) != 2 {
            fmt.Println("Usage: ", os.Args[0], "server")
            os.Exit(1)
        }
        serverAddress := os.Args[1]

        client, err := rpc.DialHTTP("tcp", serverAddress+":1234")
        if err != nil {
            log.Fatal("dialing:", err)
        }
        // Synchronous call
        args := Args{17, 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\n", args.A, args.B, reply)

        var quot Quotient
        err = client.Call("Arith.Divide", args, ")
        if err != nil {
            log.Fatal("arith error:", err)
        }
        fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

    }

我们已经看到了，上面的两段代码很多的冗余，我们把公共数据部分要提出来。
rpc_objects.go

package rpc_objects
import "net"

type Args struct {
    N, M int
}

func (t *Args) Multiply(args *Args, replu *int) net.error {
    *reply = args.N * args.M
    return nil
}

服务端：

package mian
import (
    "net/http"
    "log"
    "net"
    "net/rpc"
    "time"
    "./rpc_objects"
)

func main() {
    calc := new(rpc_objects.Args)
    rpc.Register(calc)
    rpc.HandleHTTP()
    listener, e := net.Listen("tcp", "localhost:1234")
    if e != nil {
        log.Fatal("Starting RPC-SERVER -listen error:", e)
    }
    go http.Serve(listener, nil)
    time.Sleep(1000e9)
}

客户端：

package mian
import (
    "fmt"
    "log"
    "net/rpc"
    "./rpc_objects"
)

const serverAddress = "localhost"

func main() {
    client, err := rpc.DialHTTP("tcp", serverAddress + ":1234")
    if err != nil {
        log.Fatal("Error dialing:", e)
    }
    args := &rpc_objects.Args{7, 8}
    var reply int
    err = client.Call("Args.Multiply", args, &reply)
    if err != nil {
        log.Fatal("Args error", err)
    }
    fmt.Printf("Args: %d * %d", args.N, args.M, reply)
}

基于TCP的RPC
服务端：

package main

    import (
        "errors"
        "fmt"
        "net"
        "net/rpc"
        "os"
    )

    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)

        tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
        checkError(err)

        listener, err := net.ListenTCP("tcp", tcpAddr)
        checkError(err)

        for {
            conn, err := listener.Accept()
            if err != nil {
                continue
            }
            rpc.ServeConn(conn)
        }

    }

    func checkError(err error) {
        if err != nil {
            fmt.Println("Fatal error ", err.Error())
            os.Exit(1)
        }
    }

客户端：

package main

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

    type Args struct {
        A, B int
    }

    type Quotient struct {
        Quo, Rem int
    }

    func main() {
        if len(os.Args) != 2 {
            fmt.Println("Usage: ", os.Args[0], "server:port")
            os.Exit(1)
        }
        service := os.Args[1]

        client, err := rpc.Dial("tcp", service)
        if err != nil {
            log.Fatal("dialing:", err)
        }
        // Synchronous call
        args := Args{17, 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\n", args.A, args.B, reply)

        var quot Quotient
        err = client.Call("Arith.Divide", args, ")
        if err != nil {
            log.Fatal("arith error:", err)
        }
        fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

    }