关于golang:golang如何使用原生RPC及微服务简述

[TOC]

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

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

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

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

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

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

用 docker+k8s 去解决

网络传输，用 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能够优先思考。

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

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

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

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

RPC 的根本通信如下：

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

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

值传递

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

援用传递

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

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

数据格式对立问题

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

隐式类型

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

显式类型

传递字段的类型和值

常见的传输数据格式有：

ISO 规范的 ASN.1
JSON
PROTOBUF
XML

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

共有协定

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

公有协定

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

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

协定设计

须要思考哪些问题

公有协定的编解码

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

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

协定的过程个别会有 2 种

负载命令

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

管制命令

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

命令的协定

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

通信模式

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

出错解决和超时解决

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

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

大略分为如下 4 个步骤：

设计数据结构和办法
实现办法
注册服务
客户端连贯服务端，调用服务端的办法

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

RPC 相干内容
- 数据传输：JSON Protobuf thrift
- 负载：随机算法 轮询一致性 hash 加权
- 异样容错：衰弱检测熔断限流
服务监控
- 日志收集
- 打点采样

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

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

微服务架构下数据交互个别是 对内 RPC，对外 REST
将业务按功能模块拆分到各个微服务，具备如下长处
- 进步我的项目合作效率
- 升高模块耦合度
- 进步零碎可用性
有如下毛病：
- 开发门槛比拟高，比方 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)
}

后果

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)
}

例如咱们自定义协定，一段数据，前 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 {}}

后果：

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

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

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

关于golang:golang如何使用原生RPC及微服务简述

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

微服务

1. 微服务是什么

2. 特点是啥

3. 微服务架构的劣势

4. 微服务架构的有余

微服务生态

1. 硬件层

2. 通信层

数据传输协定选型倡议

RPC 机制和实现过程

1. RPC 机制

2. 参数传递

3. 通信协议机制

4. 繁难 GO 语言原生 RPC

rpc 调用和服务监控

1. RPC 简介

2. RPC 调用流程

3.rpc golang 原生解决形式

最简略的 golang 原生 rpc 的应用

golang 应用 jsonrpc

golang 原生 rpc 自定义协定

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

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

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