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：**
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 {}
}
结果：
以上均为学习所得，若有偏误还请指正
技术是开放的，我们的心态也应如此。未来的道路上拥抱变化，勇敢前行。大家一起加油！
我是小魔童哪吒，欢迎吐槽，欢迎沟通