net/rpc

rpc包提供了通过网络或其他I/O连接对一个对象的导出方法的访问

应用

比如我们在服务器注册一个对象,这个对象可以作为一项服务被暴露,服务的名字就是该对象的类型名，注册之后,对象的导出方法就可以被远程访问。服务端可以注册多个不同类型的对象,即多个服务

只有满足下面条件的方法才能远程访问

方法是导出的

方法有两个参数，都是导出类型或内建类型
方法的第二个参数是指针
方法只有一个error接口类型的返回值

结构如下

func (t *T) MethodName(argType T1, replyType *T2) error

T、T1和T2都能被encoding/gob包序列化
方法的第一个参数代表调用者提供的参数
第二个参数代表返回给调用者的参数
返回值，如果非nil，将被作为字符串回传，在客户端看来就和errors.New创建的一样。如果返回了错误，回复的参数将不会被发送给客户端

下面我们看一下标准的定义如何实现

package server

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
}

Airth 即服务,这个服务有两项功能,执行两个数据的乘法和除法

下面我们看在服务端注册这个服务

// 创建服务对象
arith := new(Arith)
// 注册服务
rpc.Register(arith)
rpc.HandleHTTP()
// 监听端口
l, e := net.Listen("tcp", ":1234")
if e != nil {
    log.Fatal("listen error:", e)
}
// 启动服务
go http.Serve(l, nil)

我们看看完整的服务端代码

package main

import (

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


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

我们看客户端如何调用

package main

import (
  "net/rpc"
  "fmt"
    )

type Args struct {
  A, B int
}
type Quotient struct {
  Quo, Rem int
}
type Arith int


func main(){
  // 创建客户端
  client, err := rpc.DialHTTP("tcp",  ":1234")
// 客户端结束连接是必须调用
  defer client.Close()
  if err != nil {
   fmt.Println(err)
  }

  args := &Args{7,8}
  var reply int
  // 方式1 同步
  err = client.Call("Arith.Multiply", args, &reply)
  if err != nil {
    fmt.Println(err)
  }
  fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)
  var quotient = new(Quotient)

  // 方式2 异步 需要使用chan 等待
  call := client.Go("Arith.Divide", args, &quotient,nil)
  quotientCall := <- call.Done
  if err != nil {
  fmt.Println(err)
  }
  fmt.Println(quotientCall)
  fmt.Println(quotient)
}

image.png

最后编辑于：2018.12.26 11:02:05