2.微服务--RPC

1.RPC简介

1.远程过程调用（Remote Procedure Call,RPC）是一个计算机通信协议。
2.该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。
3.如果涉及的软件采用面向对象编程，那么远程过程调用也可称为远程调用或远程方法调用。

2.流行的RPC框架的对比

3.golang中如何实现RPC

Golang中实现RPC比较简单，官方提供了封装好的库，还有第三方库。

官方库：net/rpc
1.net/rpc库使用encoding/gob进行编码
2.支持tcp和http数据传输方式
3.由于其他语言不支持gob编解码方式，所以golang的RPC只支持golang开发的服务端与客户端的交互

官方库：net/jsonrpc
1.jsonrpc采用JSON进行数据编解码，因而支持跨语言调用。
2.jsonrpc库是基于tcp协议实现的，暂不支持http传输方式。

golang的RPC必须符合四个条件才可以：
1.结构体字段首字母要大写，要跨域访问，所以大写。
2.函数名必须首字母大写。
3.函数第一个参数是接收参数，第二个参数是返回给客户端参数，必须是指针类型。
4.函数必须有一个返回值err。

3.1示例1

golang实现RPC程序，实现求矩形面积和周长

//rpcClient/server.go

package main

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

//服务端，求举行面积和周长

//声明矩形对象
type Rect struct {

}

//声明参数结构体，字段首字母大写
type Param struct {
    Width,Height int
}
//golang的RPC必须符合4个条件才可以
//◼ 结构体字段首字母要大写，要跨域访问，所以大写
//◼ 函数名必须首字母大写(可以序列号导出的)
//◼ 函数第一个参数是接收参数，第二个参数是返回给客户端参数，必须是指针类型
//◼ 函数必须有一个返回值error

//定义求矩形面积的方法
func (r Rect) Area(p Param,ret *int)  error{
    *ret = p.Width * p.Height
    return nil
}
//定义求矩形周长的方法
func (r Rect) Perimeter(p Param,ret *int)  error{
    *ret = (p.Width + p.Height)*2
    return nil
}

func main()  {
    //1.注册服务
    rect := new(Rect)
    rpc.Register(rect)
    //2.把服务处理绑定到http协议上
    rpc.HandleHTTP()
    //3.监听服务，等待客户端调用请求面积和周长的方法
    err := http.ListenAndServe(":8080",nil)
    if err != nil{
        log.Fatal(err)
    }
}

//rpcServer/client.go
package main

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

//声明参数结构体，字段首字母大写
type Params struct {
    Width,Height int
}
//调用服务
func main()  {
    //1.链接远程RPC服务
    rp,err := rpc.DialHTTP("tcp","127.0.0.1:8080")
    if err != nil{
        log.Fatal(err)
    }
    //2.调用远程方法
    //定义接收服务端传回来的计算结果的变量
    ret := 0
    //求矩形面积
    err2 := rp.Call("Rect.Area",Params{50,10},&ret)
    if err2 != nil{
        log.Fatal(err2)
    }
    fmt.Println("面积：",ret)

    //求矩形周长
    err3 := rp.Call("Rect.Perimeter",Params{50,10},&ret)
    if err3 != nil{
        log.Fatal(err3)
    }
    fmt.Println("周长：",ret)
}

3.2示例2

模仿前面例题，自己实现 RPC 程序，服务端接收 2 个参数，可以做乘法运算，也可以做商和余数的运算，客户端进行传参和访问，得到结果如下:
 9*2 = 18
 9/2,商=4，余数=1

 下面使用net/rpc/jsonrpc库通过json格式编码解码，支持跨语言调用

rpcServer/server.go

package main

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

//结构体，用于注册的
type Arith struct {

}

//声明参数结构体
type ArithRequest struct {
    A,B int
}

//返回给客户端的结果
type ArithResponse struct {
    //乘积
    Pro int
    //商
    Quo int
    //余数
    Rem int
}

//乘法
func (a *Arith) Multiply(req ArithRequest,res *ArithResponse) error  {
    res.Pro = req.A * req.B
    return nil
}
//商和余数
func (a *Arith) Divide(req ArithRequest,res *ArithResponse) error  {
    if req.B == 0{
        return errors.New("除数不能为0")

    }
    //商
    res.Quo = req.A/req.B
    //余数
    res.Rem = req.A%req.B
    return nil

}
func main()  {
    rpc.Register(new(Arith))
    lis,err := net.Listen("tcp",":8080")
    if err != nil{
        log.Fatal(err)
    }
    //循环监听服务
    for{
        conn,err := lis.Accept()
        if err != nil{
            continue
        }
        go func(conn net.Conn) {
            fmt.Println("new client")
            jsonrpc.ServeConn(conn)
        }(conn)
    }
}

rpcClient/client.go

package main

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

//声明参数结构体
type ArithRequest struct {
    A,B int
}

//返回给客户端的结果
type ArithResponse struct {
    //乘积
    Pro int
    //商
    Quo int
    //余数
    Rem int
}
//调用服务
func main()  {
    conn,err := jsonrpc.Dial("tcp",":8080")
    if err != nil{
        log.Fatal(err)
    }
    req := ArithRequest{9,2}
    var res ArithResponse
    err2 := conn.Call("Arith.Multiply", req, &res)
    if err2 != nil {
        log.Fatal(err2)
    }
    fmt.Printf("%d * %d = %d\n", req.A, req.B, res.Pro)
    err3 := conn.Call("Arith.Divide", req, &res)
    if err3 != nil {
        log.Fatal(err3)
    }
    fmt.Printf("%d / %d 商 %d，余数 = %d\n", req.A, req.B, res.Quo, res.Rem)
}

3.3RPC调用流程

1.微服务架构下数据交互一般是对内RPC，对外REST。
2.将业务按功能模块拆分到各个微服务，具有提高项目协作效率、降低模块耦合度、提高系统可用性等优点，但是开发门槛比较高，比如RPC框架的时候，后期的服务监控等工作。
3.一般情况下，我们会将功能代码在本地直接调用，微服务架构下，我们需要将这个函数作为单独的服务运行，客户端通过网络调用。

3.5自己实现RPC调用库（类似于net/rpc、net/rpc/jsonrpc）

3.5.1网络传输数据格式

成熟的RPC框架会有自定义传输协议，这里网络传输格式定义如下：
前面是固定长度消息头，后面是变长消息体。

//会话中读写数据测试

//rpc/session.go
package rpc

import (
    "encoding/binary"
    "io"
    "net"
)

//测试网络中读写数据的情况

//会话连接的结构体
type Session struct {
    conn net.Conn
}

//构造方法
func NewSession(conn net.Conn) *Session {
    return &Session{conn:conn}
}

//向连接中写数据
func (s *Session) Write(data []byte) error {
    //定义写数据的格式

    //4字节头部+可变体的长度
    buf := make([]byte,4+len(data))
    //写入头部，记录数据长度
    binary.BigEndian.PutUint32(buf[:4],uint32(len(data)))
    //将整个数据，放在索引4的后面
    copy(buf[4:],data)
    _,err := s.conn.Write(buf)
    if err != nil{
        return err
    }
    return nil
}

//从连接中读数据
func (s *Session) Read() ([]byte,error)  {
    //读取头部记录的长度
    header := make([]byte, 4)
    //按长度读取头部消息
    _,err := io.ReadFull(s.conn, header)
    if err != nil{
        return nil,err
    }

    //根据头部信息，读取数据长度
    dataLen := binary.BigEndian.Uint32(header)
    data := make([]byte,dataLen)
    //读取到的数据存到data中
    _,err = io.ReadFull(s.conn, data)
    if err != nil{
        return nil,err
    }
    return data,nil
}

//rpc/session_test.go

package rpc

import (
    "fmt"
    "net"
    "sync"
    "testing"
)

func TestSession_ReadWriter(t *testing.T)  {
    //定义地址
    addr := "127.0.0.1:8000"
    my_data := "hello lili"
    wg := sync.WaitGroup{}
    wg.Add(2)

    //写数据的协成
    go func() {
        defer wg.Done()
        lis,err := net.Listen("tcp", addr)
        if err != nil{
            t.Fatal(err)
        }
        conn,_ := lis.Accept()
        s:= NewSession(conn)
        err = s.Write([]byte(my_data))
        if err != nil{
            t.Fatal(err)
        }
    }()
    //读数据的协成
    go func() {
        defer wg.Done()
        conn,err := net.Dial("tcp", addr)
        if err != nil{
            t.Fatal(err)
        }
        s:= NewSession(conn)
        data,err := s.Read()
        if err!= nil{}
        t.Fatal(err)

        //最后一层校验
        if string(data) != my_data{
            t.Fatal(err)
        }

        fmt.Println("读取到的数据为：",string(data))
    }()
}

测试结果：
 rpc go test -v            
=== RUN   TestSession_ReadWriter
--- PASS: TestSession_ReadWriter (0.00s)
PASS
ok      _/Users/tongchao/Desktop/gopath/src/test/rpc    0.008s
➜  rpc 

3.5.2gob编码/解码

//codec.go
package rpc

import (
    "bytes"
    "encoding/gob"
)

//定义RPC交互的数据结构

type RPCData struct {
    //访问的函数
    Name string
    //访问时的参数
    Args []interface{}
}

//编码
func encode(data RPCData) ([]byte, error)  {
    //得到字节数组的编码器
    var buf bytes.Buffer
    bufEnc := gob.NewEncoder(&buf)
    //编码器对数据编码
    if err := bufEnc.Encode(data); err != nil{
        return nil,err
    }
    return buf.Bytes(),nil
}

//解码
func decode(b []byte) (RPCData,error)  {
    buf := bytes.NewBuffer(b)
    //得到字节数组的解码器
    bufDec := gob.NewDecoder(buf)
    //解码器对数据解码
    var data RPCData
    if err:= bufDec.Decode(&data);err != nil{
        return data,err
    }
    return data,nil
}

//codec_test.go
package rpc
import (
    "fmt"
    "testing"
)
func TestCode(t *testing.T)  {
    args := make([]interface{},0)
    data := RPCData{
        Name: "lili",
        Args: args,
    }
    encodeData,err := encode(data)
    if err != nil{
        fmt.Println(err)
    }
    fmt.Printf("encodeData:%v\n",encodeData)

    decodeData,err := decode(encodeData)
    if err != nil{
        fmt.Println(err)
    }
    fmt.Printf("decodeData:%v\n",decodeData)
}

结果：
=== RUN   TestCode
encodeData:[40 255 129 3 1 1 7 82 80 67 68 97 116 97 1 255 130 0 1 2 1 4 78 97 109 101 1 12 0 1 4 65 114 103 115 1 255 132 0 0 0 28 255 131 2 1 1 14 91 93 105 110 116 101 114 102 97 99 101 32 123 125 1 255 132 0 1 16 0 0 9 255 130 1 4 108 105 108 105 0]
decodeData:{lili []}
--- PASS: TestCode (0.00s)
PASS

Process finished with exit code 0