[TOC]

golang 如何应用原生 RPC 及微服务简述

微服务

1. 微服务是什么

• 应用一套小服务来开发单个利用的形式，每个服务运行在独立的过程里，个别采纳轻量级的通信机制互联，并且它们能够通过自动化的形式部署

微服务是设计思维，不是量的体现

• 专一的性能
• 代码量并不少
• 架构变简单

2. 特点是啥

• 专一的职责，例如专一于权限治理
• 轻量级的通信，通信与平台和语言无关，例如 http 是轻量的
• 隔离性，数据隔离
• 有本人的数据
• 技术多样

3. 微服务架构的劣势

• 独立性
• 使用者容易了解
• 技术栈灵便
• 高效团队

4. 微服务架构的有余

• 额定的工作，服务的拆分
• 保证数据一致性
• 减少了沟通老本

微服务生态

1. 硬件层

• 用 docker+k8s 去解决

2. 通信层

• 网络传输，用 RPC（近程过程调用）

  • HTTP 传输，GET POST PUT DELETE
  • 基于 TCP，更靠底层，RPC 基于 TCP，Dubbo（18 年底改成反对各种语言），Grpc，Thrift

• 须要晓得调用谁，用服务注册和发现

  • 须要分布式数据同步：etcd，consul，zk
• 数据传递这外面可能是各种语言，各种技术，各种传递

数据传输协定选型倡议

1、对于公司间的零碎调用，如果性能要求在 100ms 以上的服务，基于 XML 的 SOAP 协定 是一个值得思考的计划。

2、对于调试 环境比拟顽劣的场景，采纳 JSON 或 XML 可能极大的进步调试效率，升高零碎开发成本。

3、当对性能和简洁性有极高要求的场景，Protobuf，Thrift，Avro 之间具备肯定的竞争关系。

4、对于 T 级别的数据的长久化利用场景，Protobuf 和 Avro 是首要抉择。如果长久化后的数据存储在 Hadoop 子项目里，Avro 会是更好的抉择。

5、如果须要提供 一个残缺的 RPC 解决方案，Thrift 是一个好的抉择。

6、如果序列化之后须要反对不同的传输层协定，或者须要跨防火墙拜访的高性能场景，Protobuf能够优先思考。

RPC 机制和实现过程

1. RPC 机制

服务间通过轻量级的近程过程调用，个别应用HTTP，RPC

• HTTP 调用应用层协定，构造绝对固定
• RPC 的网络协议就绝对灵便，并且能够定制

RPC 近程过程调用，个别采纳C/S 模式，客户端服务器模式，客户端过程，调用服务端过程的程序，服务端过程执行后果返回给客户端，客户端从阻塞状态被唤醒，接收数据，提取数据。

上述过程中，客户端调用服务器的函数，来执行工作，它不晓得操作是在本地操作系统进行，还是通过近程过程调用进行的，全程无感。

RPC 的根本通信如下：

RPC 近程过程调用，须要思考的问题有如下 四点：

• 参数传递
• 通信协议机制
• 出错解决
• 超时解决

2. 参数传递

• 值传递

个别默认是值传递，只须要将参数中的值复制到网络音讯中的数据中即可

• 援用传递

比拟艰难，单纯传递参数的援用是齐全没有用意义的，因为援用的地址给到远端的服务器，服务器上的该内存地址齐全不是客户端想要的数据，若非要这样解决，客户端还必须把数据的正本传递给到远端服务器，并将它们放到远端服务器内存中，服务器复制援用的地址后，即可进行数据的读取。

可是上述做法很麻烦，且很容易出错，个别 RPC 不反对间接传递援用

• 数据格式对立问题

须要有一个规范来对所有数据类型进行编解码，数据格式能够有 隐式类型 和显式类型

• 隐式类型

只传递值，不传递变量的名称或 类型

• 显式类型

传递字段的类型和值

常见的传输数据格式有：

• ISO 规范的 ASN.1
• JSON
• PROTOBUF
• XML

3. 通信协议机制

狭义上的协定栈分为 共有协定 和公有协定

• 共有协定

例如HTTP，SMPP，WEBSERVICE 都是共有协定，领有通用型上，公网传输的能力上 有劣势

• 公有协定

外部约定而成的协定，弊病多，然而 能够高度的定制化，晋升性能，降低成本，进步灵活性和效率。企业外部往往采纳公有协定开发

对于协定的制订须要思考如下 5 个方面：

• 协定设计

须要思考哪些问题

• 公有协定的编解码

须要有业务针对性的编解码形式办法，如下有案例

• 命令的定义和命令处理器的抉择

协定的过程个别会有 2 种

1. 负载命令

传输业务具体的数据，如申请参数，响应后果的命令

1. 管制命令

个别为性能治理命令，如心跳命令等

• 命令的协定

个别是应用序列化协定，不同的协定在编码效率和传输效率上都不雷同，如

• 通信模式

1. oneway — 不关怀响应，申请线程不会被阻塞
2. sync — 调用会被阻塞，晓得返回后果为止
3. future — 调用时不会阻塞县线程，获取后果的时候会阻塞线程
4. callback — 异步调用，不会阻塞线程

出错解决和超时解决

近程过程调用绝对本地过程调用出错的概率更大，因而须要思考到调用失败的各种场景：

• 服务端出错，须要如何解决
• 客户端申请服务时候呈现谬误或者超时，须要设置适合的重试机制

4. 繁难 GO 语言原生 RPC

大略分为如下 4 个步骤：

• 设计数据结构和办法
• 实现办法
• 注册服务

• 客户端连贯服务端，调用服务端的办法

  往下看有 golang 如何应用原生 rpc 的案例

rpc 调用和服务监控

• RPC 相干内容

  • 数据传输：JSON Protobuf thrift
  • 负载：随机算法 轮询 一致性 hash 加权
  • 异样容错：衰弱检测 熔断 限流

• 服务监控

  • 日志收集
  • 打点采样

1. RPC 简介

• 近程过程调用（Remote Procedure Call，RPC）是一个计算机通信协议
• 该协定容许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额定地为这个交互作用编程
• 如果波及的软件采纳面向对象编程，那么近程过程调用亦可称作近程调用或近程办法调用

2. RPC 调用流程

个别状况下，咱们会将性能代码在本地间接调用，微服务架构下，咱们须要将这个函数作为独自的服务运行，客户端通过网络调用

• 微服务架构下数据交互个别是 对内 RPC，对外 REST

• 将业务按功能模块拆分到各个微服务，具备如下长处

  • 进步我的项目合作效率
  • 升高模块耦合度
  • 进步零碎可用性

• 有如下毛病：

  • 开发门槛比拟高，比方 RPC 框架的应用、前期的服务监控等工作

3.rpc golang 原生解决形式

最简略的 golang 原生 rpc 的应用

golang 官网的 net/rpc 库应用 encoding/gob 进行编解码，反对 tcp 和 http 数据传输方式

server1.go

package main

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

type Happy struct{}

// 计算 happy
func (r *Happy) CalHappy(num int, ret *int) error {
   *ret = num * 10
   return nil
}

// 主函数
func main() {
   // new 一个服务
   ha := new(Happy)
   // 注册一个 Happy 的服务
   rpc.Register(ha)
   // 服务解决绑定到 http 协定上
   rpc.HandleHTTP()
   // 监听服务
   err := http.ListenAndServe(":9999", nil)
   if err != nil {log.Panicln(err)
   }
}

client1.go

package main

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

// 主函数
func main() {
   // 连贯近程 rpc 服务
   conn, err := rpc.DialHTTP("tcp", ":9999")
   if err != nil {log.Fatal(err)
   }
   // 调用服务器办法
   ret := 0
   err2 := conn.Call("Happy.CalHappy", 10, &ret)
   if err2 != nil {log.Fatal(err2)
   }
   fmt.Println("开心指数：", ret)
}

后果

golang 应用 jsonrpc

jsonrpc 采纳 JSON 进行数据编解码，反对跨语言调用，jsonrpc 库是基于 tcp 协定实现的，暂不反对 http 传输方式

server2.go

package main

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

type Happy struct{}

// 计算 happy
func (r *Happy) CalHappy(num int, ret *int) error {
   *ret = num * 10
   return nil
}

// 主函数
func main() {
   // new 一个服务
   ha := new(Happy)
   // 注册一个 Happy 的服务
   rpc.Register(ha)
   // 监听服务
   listen, err := net.Listen("tcp", ":9999")
   if err != nil {log.Panicln(err)
   }
   // 解决申请
   for {con, err := listen.Accept()
      if err != nil {continue}

      // 专门开一个协程解决相应申请
      go func(con net.Conn) {fmt.Println("process new client")
         jsonrpc.ServeConn(con)
      }(con)
   }
}

client2.go

package main

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

// 主函数
func main() {
   // 连贯近程 rpc 服务
   conn, err := jsonrpc.Dial("tcp", ":9999")
   if err != nil {log.Fatal(err)
   }
   // 调用服务器办法
   ret := 0
   err2 := conn.Call("Happy.CalHappy", 10, &ret)
   if err2 != nil {log.Fatal(err2)
   }
   fmt.Println("开心指数：", ret)
}

golang 原生 rpc 自定义协定

例如咱们自定义协定，一段数据，前 2 个字节是数据头，前面的得为实在的数据，如：

• 既然自定义了协定，那么咱们 发送数据和读取数据的时候就须要恪守咱们的协定规定，否则会出问题
• 那么咱们做数据传输的时候就会波及到 编码和解码，咱们也须要本人封装好编码和解码的函数

写入数据和读取数据的函数封装

// 写入数据
func MyWriteData(con net.Conn, data []byte) (int, error) {
    if con == nil {log.Fatal("con is nil")
    }

    buf := make([]byte, 2+len(data))
    // 先写入头部, 把实在数据的长度写到头外面
    binary.BigEndian.PutUint16(buf[:2], uint16(len(data)))
    // 再写入数据
    copy(buf[2:], data)
    n, err := con.Write(buf)
    if err != nil {log.Fatal("Write error", err)
    }
    return n, nil
}

// 读取数据
func MyReadData(con net.Conn) ([]byte, error) {
    if con == nil {log.Fatal("con is nil")
    }
    // 协定头 2 个字节
    myheader := make([]byte, 2)
    // 读取 2 个字节的协定头
    _, err := io.ReadFull(con, myheader)
    if err != nil {log.Fatal("ReadFull error", err)
    }
    // 读取实在数据
    // 从头外面读取实在数据的长度
    len := binary.BigEndian.Uint16(myheader)
    data := make([]byte, len)
    _, err = io.ReadFull(con, data)
    if err != nil {log.Fatal("ReadFull error", err)
    }
    return data, nil
}

编写编码和解码的函数封装

咱们设计成 字符串命令 与 具体调用的函数做绑定的形式，这样为接下来的server3.go rpc 的实现，打好根底

// 具体的数据结构体
type MyData struct {
    Name   string
    MyArgs []interface{} // 参数列表
}

// 加密
func MyEncode(data *MyData) ([]byte, error) {
    if data == nil {log.Fatal("con is nil")
    }
    var bb bytes.Buffer
    buf := gob.NewEncoder(&bb)
    if err := buf.Encode(data); err != nil {log.Fatal("Encode error", err)
    }
    return bb.Bytes(), nil}

// 解密
func MyDecode(data []byte) (MyData, error) {
    if data == nil {log.Fatal("con is nil")
    }
    buf := bytes.NewBuffer(data)
    myDe := gob.NewDecoder(buf)
    var res MyData
    if err := myDe.Decode(&res); err != nil {log.Fatal("Decode error", err)
    }
    return res, nil
}

综合上述性能 server 端的实现 my_server.go：

package main

import (
    "bytes"
    "encoding/binary"
    "encoding/gob"
    "fmt"
    "io"
    "log"
    "net"
    "reflect"
)

// 写入数据
func MyWriteData(con net.Conn, data []byte) (int, error) {
    if con == nil {log.Fatal("con is nil")
    }

    buf := make([]byte, 2+len(data))
    // 先写入头部, 把实在数据的长度写到头外面
    binary.BigEndian.PutUint16(buf[:2], uint16(len(data)))
    // 再写入数据
    copy(buf[2:], data)
    n, err := con.Write(buf)
    if err != nil {log.Fatal("Write error", err)
    }
    return n, nil
}

// 读取数据
func MyReadData(con net.Conn) ([]byte, error) {
    if con == nil {log.Fatal("con is nil")
    }
    // 协定头 2 个字节
    myheader := make([]byte, 2)
    // 读取 2 个字节的协定头
    _, err := io.ReadFull(con, myheader)
    if err != nil {log.Fatal("ReadFull error", err)
    }
    // 读取实在数据
    // 从头外面读取实在数据的长度
    len := binary.BigEndian.Uint16(myheader)
    data := make([]byte, len)
    _, err = io.ReadFull(con, data)
    if err != nil {log.Fatal("ReadFull error", err)
    }
    return data, nil
}

// 具体的数据结构体
type MyData struct {
    Name   string
    MyArgs []interface{} // 参数列表
}

// 加密
func MyEncode(data *MyData) ([]byte, error) {
    if data == nil {log.Fatal("con is nil")
    }
    var bb bytes.Buffer
    buf := gob.NewEncoder(&bb)
    if err := buf.Encode(data); err != nil {log.Fatal("Encode error", err)
    }
    return bb.Bytes(), nil}

// 解密
func MyDecode(data []byte) (MyData, error) {
    if data == nil {log.Fatal("con is nil")
    }
    buf := bytes.NewBuffer(data)
    myDe := gob.NewDecoder(buf)
    var res MyData
    if err := myDe.Decode(&res); err != nil {log.Fatal("Decode error", err)
    }
    return res, nil
}

// 全局的一个 map，命令与函数做对应关系
var myFun = make(map[string]reflect.Value)

// 注册命令绑定函数
func MyRegister(name string, fn interface{}) {if _, ok := myFun[name]; ok { // 阐明该命令曾经绑定过函数
        return
    }
    myFun[name] = reflect.ValueOf(fn)
    log.Println("reflect.ValueOf(fn) ==", myFun[name])
}

// 服务端执行的办法
func MyRun(addr string) {listen, err := net.Listen("tcp", addr)
    if err != nil {log.Fatal("Listen is nil")
    }
    log.Println("启动服务端....")
    // 开始阻塞期待客户端的连贯
    for {con, err := listen.Accept()
        if err != nil {log.Println("Accept is nil")
            return
        }
        // 读取数据
        b, err := MyReadData(con)
        if err != nil {log.Println("MyReadData error", err)
            return
        }
        log.Println("MyReadData ===============")
        // 解析数据
        my, err := MyDecode(b)
        if err != nil {log.Println("MyDecode ===============")
            log.Println("MyDecode error", err)
            return
        }
        f, ok := myFun[my.Name]
        if !ok {fmt.Printf("命令 %s 没有绑定函数 \n", my.Name)
            return
        }
        // 获取参数
        args := make([]reflect.Value, 0, len(my.MyArgs))
        for _, arg := range my.MyArgs {args = append(args, reflect.ValueOf(arg))
            log.Println("reflect.ValueOf(arg) -", reflect.ValueOf(arg))
        }

        // 反射
        res := f.Call(args)
        log.Println("f.Call(args) ==", res)
        // 包装后果数据给到客户端
        out := make([]interface{}, 0, len(res))
        for _, arg := range res {log.Println("arg  ==", arg)
            out = append(out, arg.Interface())
        }
        log.Println("out  ==", out)
        // 编码数据
        bb, err := MyEncode(&MyData{Name: my.Name, MyArgs: out})
        if err != nil {log.Println("MyEncode error", err)
            return
        }
        // 将数据写给客户端
        _, err = MyWriteData(con, bb)
        if err != nil {log.Println("MyWriteData ========")
            log.Println("MyWriteData error", err)
            return
        }
    }
}
// 客户端通过命令调用函数
func CallRPCFun(con net.Conn, rpcName string, args interface{}) {
    // 通过反射，获取 args 未初始化的函数原型
    fn := reflect.ValueOf(args).Elem()
    log.Println("fn ==", fn)
    // 须要另一个函数，作用是对第一个函数参数操作
    f := func(args []reflect.Value) []reflect.Value {
        // 解决参数
        inArgs := make([]interface{}, 0, len(args))
        for _, arg := range args {inArgs = append(inArgs, arg.Interface())
        }
        // 连贯
        // 编码数据
        reqRPC := &MyData{Name: rpcName, MyArgs: inArgs}
        b, err := MyEncode(reqRPC)
        if err != nil {log.Println("MyEncode ===============")
            log.Println("MyEncode error", err)
        }
        // 写数据
        _, err = MyWriteData(con, b)
        if err != nil {log.Println("MyWriteData ===============")
            log.Fatal("MyWriteData error", err)
        }
        // 服务端发过来返回值，此时应该读取和解析
        respBytes, err := MyReadData(con)
        if err != nil {log.Fatal("MyReadData error", err)
        }
        // 解码
        res, err := MyDecode(respBytes)
        if err != nil {log.Println("MyDecode ===============")
            log.Fatal("MyDecode error", err)
        }
        // 解决服务端返回的数据
        outArgs := make([]reflect.Value, 0, len(res.MyArgs))
        for i, arg := range res.MyArgs {
            // 必须进行 nil 转换
            if arg == nil {// reflect.Zero()会返回类型的零值的 value
                // .out()会返回函数输入的参数类型
                outArgs = append(outArgs, reflect.Zero(fn.Type().Out(i)))
                continue
            }
            outArgs = append(outArgs, reflect.ValueOf(arg))
        }
        return outArgs
    }

    v := reflect.MakeFunc(fn.Type(), f)

    // 为函数 f 赋值
    fn.Set(v)
}

// 定义用户对象
type Data struct {
    CmdName string
    Param   string
}

// 用于测试用户查问的办法
func GetData(id int) (Data, error) {data := make(map[int]Data)
    // 假数据
    data[0] = Data{"PullInfo", "xiaoxiong"}
    data[1] = Data{"PutInfo", "daxiong"}

    // 查问
    if u, ok := data[id]; ok {return u, nil}
    return Data{}, fmt.Errorf("%d err", id)
}

// 主函数
func main() {
    // 简略设置 log 参数
    log.SetFlags(log.Lshortfile | log.LstdFlags)
    
    // rpc 服务端
    // 编码中有一个字段是 interface{}时，进行注册
    gob.Register(Data{})
    addr := "127.0.0.1:9999"
    // 创立服务端
    // 将服务端办法，注册一下
    MyRegister("GetData", GetData)

    // 服务端期待调用
    go MyRun(addr)
    
    //------------- 我是分割线 -----------
    
    // rpc 客户端获取连贯
    conn, err := net.Dial("tcp", addr)
    if err != nil {fmt.Println("Dial err")
        return
    }
    log.Println("客户端拨号胜利了，开始调用函数了...")
    // 创立客户端对象
    // 须要申明函数原型
    var getdata func(int) (Data, error)

    CallRPCFun(conn, "GetData", &getdata)
    // 失去查问后果
    u, err := getdata(1)
    if err != nil {fmt.Println("getdata err")
        return
    }
    log.Println(u)
    select {}}

后果：

以上均为学习所得，若有偏误还请斧正

技术是凋谢的，咱们的心态也应如此。将来的路线上拥抱变动，怯懦前行。大家一起加油！

我是小魔童哪吒，欢送吐槽，欢送沟通