[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种

负载命令

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

管制命令

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

命令的协定

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

通信模式

oneway — 不关怀响应，申请线程不会被阻塞
sync — 调用会被阻塞，晓得返回后果为止
future — 调用时不会阻塞县线程，获取后果的时候会阻塞线程
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 {}
}

后果：

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

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

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

关于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：

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于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：

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复