gtcp 提供了许多方便的原生操作连接数据的方法，但是在绝大多数的应用场景中，开发者需要自己设计数据结构，并进行封包/解包处理，由于 TCP 消息协议是没有消息边界保护的，因此复杂的网络通信环境中很容易出现 粘包 的情况。因此 gtcp 也提供了简单的数据协议，方便开发者进行消息包交互，开发者不再需要担心消息包的处理细节，包括封包/解包处理，这一切复杂的逻辑 gtcp 已经帮你处理好了。

简单协议

gtcp 模块提供了简单轻量级数据交互协议，效率非常高，协议格式如下：

  1. 数据长度(16bit)|数据字段(变长)
  1. 数据长度：默认为 16位( 2字节)，用于标识该消息体的数据长度，单位为字节，不包含自身的2字节；
  2. 数据字段：变长，根据数据长度可以知道，数据最大长度不能超过 0xFFFF = 65535 bytes = 64 KB；

简单协议由 gtcp 封装实现，如果开发者客户端和服务端如果都使用 gtcp 模块来通信则无需关心协议实现，专注 数据 字段封装/解析实现即可。如果涉及和其他开发语言对接，则需要按照该协议实现对接即可，由于简单协议非常简单轻量级，因此对接成本很低。

连接对象-消息包处理 - 图1提示

数据字段也可以为空，即没有任何长度。

操作方法

https://pkg.go.dev/github.com/gogf/gf/v2/net/gtcp

  1. type Conn
  2.     func (c *Conn) SendPkg(data []byte, option ...PkgOption) error
  3.     func (c *Conn) SendPkgWithTimeout(data []byte, timeout time.Duration, option ...PkgOption) error
  4.     func (c *Conn) SendRecvPkg(data []byte, option ...PkgOption) ([]byte, error)
  5.     func (c *Conn) SendRecvPkgWithTimeout(data []byte, timeout time.Duration, option ...PkgOption) ([]byte, error)
  6.     func (c *Conn) RecvPkg(option ...PkgOption) (result []byte, err error)
  7.     func (c *Conn) RecvPkgWithTimeout(timeout time.Duration, option ...PkgOption) ([]byte, error)

可以看到，消息包方法命名是在原有的基本连接操作方法中加上了 Pkg 关键词便于区分。

其中，请求参数中的 PkgOption 数据结构如下，用于定义消息包接收策略：

  1. // 数据读取选项
  2. type PkgOption struct {
  3.     HeaderSize  int   // 自定义头大小(默认为2字节，最大不能超过4字节)
  4.     MaxDataSize int   // (byte)数据读取的最大包大小，默认最大不能超过2字节(65535 byte)
  5.     Retry       Retry // 失败重试策略
  6. }

使用示例

示例1，基本使用

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/v2/net/gtcp"
  6.     "github.com/gogf/gf/v2/os/glog"
  7.     "github.com/gogf/gf/v2/util/gconv"
  8.     "time"
  9. )
  11. func main() {
  12.     // Server
  13.     go gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
  14.         defer conn.Close()
  15.         for {
  16.             data, err := conn.RecvPkg()
  17.             if err != nil {
  18.                 fmt.Println(err)
  19.                 break
  20.             }
  21.             fmt.Println("receive:", data)
  22.         }
  23.     }).Run()
  25.     time.Sleep(time.Second)
  27.     // Client
  28.     conn, err := gtcp.NewConn("127.0.0.1:8999")
  29.     if err != nil {
  30.         panic(err)
  31.     }
  32.     defer conn.Close()
  33.     for i := 0; i < 10000; i++ {
  34.         if err := conn.SendPkg([]byte(gconv.String(i))); err != nil {
  35.             glog.Error(err)
  36.         }
  37.         time.Sleep(1*time.Second)
  38.     }
  39. }

这个示例比较简单，执行后，输出结果为：

  1. receive: [48]
  2. receive: [49]
  3. receive: [50]
  4. receive: [51]
  5. ...

示例2，自定义数据结构

大多数场景下，我们需要对发送的消息能自定义数据结构，开发者可以利用 数据 字段传递任意的消息内容实现。

以下是一个简单的自定义数据结构的示例，用于客户端上报当前主机节点的内存及CPU使用情况。在该示例中， 数据 字段使用了 JSON 数据格式进行自定义，便于数据的编码/解码。

连接对象-消息包处理 - 图2提示

实际场景中，开发者往往需要自定义包解析协议，或者采用较通用的 protobuf 二进制包封装/解析协议。

  1. types/types.go

数据结构定义。

  1. package types
  4. import "github.com/gogf/gf/v2/frame/g"
  7. type NodeInfo struct {
  8.        Cpu       float32 // CPU百分比(%)
  9.        Host      string  // 主机名称
  10.        Ip        g.Map   // IP地址信息(可能多个)
  11.        MemUsed   int     // 内存使用(byte)
  12.        MemTotal  int     // 内存总量(byte)
  13.        Time      int     // 上报时间(时间戳)
  14. }
  1. gtcp_monitor_server.go

服务端。

  1. package main
  4. import (
  5.        "encoding/json"
  6.        "github.com/gogf/gf/v2/net/gtcp"
  7.        "github.com/gogf/gf/v2/os/glog"
  8.        "github.com/gogf/gf/.example/net/gtcp/pkg_operations/monitor/types"
  9. )
  12. func main() {
  13.        // 服务端，接收客户端数据并格式化为指定数据结构，打印
  14.        gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
  15.            defer conn.Close()
  16.            for {
  17.                data, err := conn.RecvPkg()
  18.                if err != nil {
  19.                    if err.Error() == "EOF" {
  20.                        glog.Println("client closed")
  21.                    }
  22.                    break
  23.                }
  24.                info := &types.NodeInfo{}
  25.                if err := json.Unmarshal(data, info); err != nil {
  26.                    glog.Errorf("invalid package structure: %s", err.Error())
  27.                } else {
  28.                    glog.Println(info)
  29.                    conn.SendPkg([]byte("ok"))
  30.                }
  31.            }
  32.        }).Run()
  33. }
  1. gtcp_monitor_client.go

客户端。

  1. package main
  4. import (
  5.        "encoding/json"
  6.        "github.com/gogf/gf/v2/frame/g"
  7.        "github.com/gogf/gf/v2/net/gtcp"
  8.        "github.com/gogf/gf/v2/os/glog"
  9.        "github.com/gogf/gf/v2/os/gtime"
  10.        "github.com/gogf/gf/.example/net/gtcp/pkg_operations/monitor/types"
  11. )
  14. func main() {
  15.        // 数据上报客户端
  16.        conn, err := gtcp.NewConn("127.0.0.1:8999")
  17.        if err != nil {
  18.            panic(err)
  19.        }
  20.        defer conn.Close()
  21.        // 使用JSON格式化数据字段
  22.        info, err := json.Marshal(types.NodeInfo{
  23.            Cpu       : float32(66.66),
  24.            Host      : "localhost",
  25.            Ip        : g.Map {
  26.                "etho" : "192.168.1.100",
  27.                "eth1" : "114.114.10.11",
  28.            },
  29.            MemUsed   : 15560320,
  30.            MemTotal  : 16333788,
  31.            Time      : int(gtime.Timestamp()),
  32.        })
  33.        if err != nil {
  34.            panic(err)
  35.        }
  36.        // 使用 SendRecvPkg 发送消息包并接受返回
  37.        if result, err := conn.SendRecvPkg(info); err != nil {
  38.            if err.Error() == "EOF" {
  39.                glog.Println("server closed")
  40.            }
  41.        } else {
  42.            glog.Println(string(result))
  43.        }
  44. }

  1. 执行后

    • 客户端输出结果为：

      1.   2019-05-03 13:33:25.710 ok

    • 服务端输出结果为：

      1.   2019-05-03 13:33:25.710 &{66.66 localhost map[eth1:114.114.10.11 etho:192.168.1.100] 15560320 16333788 1556861605}
      2.   2019-05-03 13:33:25.710 client closed