@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/275/221/347/273/234/347/273/204/344/273/266/TCP/347/273/204/344/273/266/TCP/347/273/204/344/273/266-TLS/345/212/240/345/257/206.md

@@ -0,0 +1,143 @@
+`gtcp` 模块支持 `TLS` 加密通信服务端及客户端，在对安全要求比较高的场景中非常必要。 `TLS` 服务端创建可以通过 `NewServerTLS` 或者 `NewServerKeyCrt` 方法实现。 `TLS` 客户端创建可以通过 `NewConnKeyCrt` 或者 `NewConnTLS` 方法实现。
+
+使用示例：
+
+[https://github.com/gogf/gf/tree/master/.example/net/gtcp/tls](https://github.com/gogf/gf/tree/master/.example/net/gtcp/tls)
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/gtcp"
+    "github.com/gogf/gf/v2/util/gconv"
+    "time"
+)
+
+func main() {
+    address := "127.0.0.1:8999"
+    crtFile := "server.crt"
+    keyFile := "server.key"
+    // TLS Server
+    go gtcp.NewServerKeyCrt(address, crtFile, keyFile, func(conn *gtcp.Conn) {
+        defer conn.Close()
+        for {
+            data, err := conn.Recv(-1)
+            if len(data) > 0 {
+                fmt.Println(string(data))
+            }
+            if err != nil {
+                // if client closes, err will be: EOF
+                g.Log().Error(err)
+                break
+            }
+        }
+    }).Run()
+
+    time.Sleep(time.Second)
+
+    // Client
+    conn, err := gtcp.NewConnKeyCrt(address, crtFile, keyFile)
+    if err != nil {
+        panic(err)
+    }
+    defer conn.Close()
+    for i := 0; i < 10; i++ {
+        if err := conn.Send([]byte(gconv.String(i))); err != nil {
+            g.Log().Error(err)
+        }
+        time.Sleep(time.Second)
+        if i == 5 {
+            conn.Close()
+            break
+        }
+    }
+
+    // exit after 5 seconds
+    time.Sleep(5 * time.Second)
+}
+```
+
+执行后，可以看到客户端执行时报错：
+
+```
+panic: x509: certificate has expired or is not yet valid
+```
+
+那是因为我们的证书是手动创建的，并且已经过期了，为了演示方便，我们在客户端代码中去掉客户端对证书的校验。
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/net/gtcp"
+    "github.com/gogf/gf/v2/util/gconv"
+    "time"
+)
+
+func main() {
+    address := "127.0.0.1:8999"
+    crtFile := "server.crt"
+    keyFile := "server.key"
+    // TLS Server
+    go gtcp.NewServerKeyCrt(address, crtFile, keyFile, func(conn *gtcp.Conn) {
+        defer conn.Close()
+        for {
+            data, err := conn.Recv(-1)
+            if len(data) > 0 {
+                fmt.Println(string(data))
+            }
+            if err != nil {
+                // if client closes, err will be: EOF
+                g.Log().Error(err)
+                break
+            }
+        }
+    }).Run()
+
+    time.Sleep(time.Second)
+
+    // Client
+    tlsConfig, err := gtcp.LoadKeyCrt(crtFile, keyFile)
+    if err != nil {
+        panic(err)
+    }
+    tlsConfig.InsecureSkipVerify = true
+
+    conn, err := gtcp.NewConnTLS(address, tlsConfig)
+    if err != nil {
+        panic(err)
+    }
+    defer conn.Close()
+    for i := 0; i < 10; i++ {
+        if err := conn.Send([]byte(gconv.String(i))); err != nil {
+            g.Log().Error(err)
+        }
+        time.Sleep(time.Second)
+        if i == 5 {
+            conn.Close()
+            break
+        }
+    }
+
+    // exit after 5 seconds
+    time.Sleep(5 * time.Second)
+}
+```
+
+执行后，终端输出结果为：
+
+```0
+1
+2
+3
+4
+5
+2019-06-05 00:13:12.488 [ERRO] EOF
+Stack:
+1. /Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/v2/geg/net/gtcp/tls/gtcp_server_client.go:25
+```
+
+其中客户端在 `5` 秒后关闭了连接，因此服务端在接收数据时获取到了一个 `EOF` 错误，这种错误在正式使用中我们直接忽略，报错时服务端直接关闭客户端连接即可。

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/275/221/347/273/234/347/273/204/344/273/266/TCP/347/273/204/344/273/266/TCP/347/273/204/344/273/266-/345/267/245/345/205/267/346/226/271/346/263/225.md

@@ -0,0 +1,61 @@
+`gtcp` 模块也提供了一些常用的工具方法。
+
+**使用方式**：
+
+```go
+import "github.com/gogf/gf/v2/net/gtcp"
+```
+
+**接口文档**：
+
+[https://pkg.go.dev/github.com/gogf/gf/v2/net/gtcp](https://pkg.go.dev/github.com/gogf/gf/v2/net/gtcp)
+
+```go
+func LoadKeyCrt(crtFile, keyFile string) (*tls.Config, error)
+func NewNetConn(addr string, timeout ...int) (net.Conn, error)
+func NewNetConnKeyCrt(addr, crtFile, keyFile string) (net.Conn, error)
+func NewNetConnTLS(addr string, tlsConfig *tls.Config) (net.Conn, error)
+func Send(addr string, data []byte, retry ...Retry) error
+func SendPkg(addr string, data []byte, option ...PkgOption) error
+func SendPkgWithTimeout(addr string, data []byte, timeout time.Duration, option ...PkgOption) error
+func SendRecv(addr string, data []byte, receive int, retry ...Retry) ([]byte, error)
+func SendRecvPkg(addr string, data []byte, option ...PkgOption) ([]byte, error)
+func SendRecvPkgWithTimeout(addr string, data []byte, timeout time.Duration, option ...PkgOption) ([]byte, error)
+func SendRecvWithTimeout(addr string, data []byte, receive int, timeout time.Duration, retry ...Retry) ([]byte, error)
+func SendWithTimeout(addr string, data []byte, timeout time.Duration, retry ...Retry) error
+```
+
+1. `NewNetConn` 用于简化标准库连接对象 `net.Conn` 的创建；
+2. `NewNetConnTLS` 和 `NewNetConnKeyCrt` 用于创建支持TLS安全加密通信的TCP客户端；
+3. `Send*` 系列方法直接通过给定地址进行数据发送，并获取该请求的返回结果，用于短链接请求的情况；
+
+以下为一个简单的示例，我们使用工具方法来访问指定的Web站点：
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/net/gtcp"
+)
+
+func main() {
+    data, err := gtcp.SendRecv("www.baidu.com:80", []byte("HEAD / HTTP/1.1\n\n"), -1)
+    if err != nil {
+        panic(err)
+    }
+    fmt.Println(string(data))
+}
+```
+
+在这个示例中，我们通过TCP访问百度首页，模拟HTTP请求头信息，并获得返回结果。 执行后，输出结果如下：
+
+```
+HTTP/1.1 302 Found
+Connection: Keep-Alive
+Content-Length: 17931
+Content-Type: text/html
+Date: Tue, 04 Jun 2019 15:53:09 GMT
+Etag: "54d9749e-460b"
+Server: bfe/1.0.8.18
+```

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/275/221/347/273/234/347/273/204/344/273/266/TCP/347/273/204/344/273/266/TCP/347/273/204/344/273/266-/350/277/236/346/216/245/345/257/271/350/261/241/TCP/347/273/204/344/273/266-/350/277/236/346/216/245/345/257/271/350/261/241.md

@@ -0,0 +1,259 @@
+`gtcp` 模块提供了简便易用的 `gtcp.Conn` 链接操作对象。
+
+**使用方式**：
+
+```go
+import "github.com/gogf/gf/v2/net/gtcp"
+```
+
+**接口文档**：
+
+[https://pkg.go.dev/github.com/gogf/gf/v2/net/gtcp](https://pkg.go.dev/github.com/gogf/gf/v2/net/gtcp)
+
+```go
+type Conn
+    func NewConn(addr string, timeout ...int) (*Conn, error)
+    func NewConnByNetConn(conn net.Conn) *Conn
+    func NewConnKeyCrt(addr, crtFile, keyFile string) (*Conn, error)
+    func NewConnTLS(addr string, tlsConfig *tls.Config) (*Conn, error)
+    func (c *Conn) Close() error
+    func (c *Conn) LocalAddr() net.Addr
+    func (c *Conn) Recv(length int, retry ...Retry) ([]byte, error)
+    func (c *Conn) RecvLine(retry ...Retry) ([]byte, error)
+    func (c *Conn) RecvWithTimeout(length int, timeout time.Duration, retry ...Retry) ([]byte, error)
+    func (c *Conn) RemoteAddr() net.Addr
+    func (c *Conn) Send(data []byte, retry ...Retry) error
+    func (c *Conn) SendRecv(data []byte, receive int, retry ...Retry) ([]byte, error)
+    func (c *Conn) SendRecvWithTimeout(data []byte, receive int, timeout time.Duration, retry ...Retry) ([]byte, error)
+    func (c *Conn) SendWithTimeout(data []byte, timeout time.Duration, retry ...Retry) error
+    func (c *Conn) SetDeadline(t time.Time) error
+    func (c *Conn) SetRecvBufferWait(bufferWaitDuration time.Duration)
+    func (c *Conn) SetRecvDeadline(t time.Time) error
+    func (c *Conn) SetSendDeadline(t time.Time) error
+```
+
+## 写入操作
+
+TCP通信写入操作由 `Send` 方法实现，并提供了错误重试的机制，由第二个非必需参数 `retry` 提供。需要注意的是 `Send` 方法不带任何的缓冲机制，也就是说每调用一次 `Send` 方法将会立即调用底层的TCP Write方法写入数据(缓冲机制依靠系统底层实现)。因此，如果想要进行输出缓冲控制，请在业务层进行处理。
+
+在进行TCP写入时，可靠的通信场景下往往是一写一读，即 `Send` 成功之后接着便开始 `Recv` 获取目标的反馈结果。因此 `gtcp.Conn` 也提供了方便的 `SendRecv` 方法。
+
+## 读取操作
+
+TCP通信读取操作由 `Recv` 方法实现，同时也提供了错误重试的机制，由第二个非必需参数 `retry` 提供。 `Recv` 方法提供了内置的读取缓冲控制，读取数据时可以指定读取的长度（由 `length` 参数指定），当读取到指定长度的数据后将会立即返回。如果 `length < 0` 那么将会读取所有可读取的缓冲区数据并返回。当 `length = 0` 时表示获取一次缓冲区的数据后立即返回。
+
+如果使用 `Recv(-1)` 可以读取所有缓冲区可读数据(长度不定，如果发送的数据包太长有可能会被截断)，但需要注意包的解析问题，容易产生非完整包的情况。这个时候，业务层需要根据既定的数据包结构自己负责包的完整性处理。推荐使用后续介绍的 `简单协议` 通过 `SendPkg`/ `RecvPkg` 来实现消息包的发送/接收，具体请查看后续章节。
+
+## 超时处理
+
+`gtcp.Conn` 对TCP通信时的数据写入和读取提供了超时处理，通过方法中的 `timeout` 参数指定，这块比较简单，不过多阐述。
+
+* * *
+
+我们接下来通过通过几个例子来看看如何使用 `gtcp.Conn` 对象。
+
+## 使用示例
+
+### 示例1，简单使用
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/gogf/gf/v2/net/gtcp"
+    "github.com/gogf/gf/v2/os/glog"
+    "github.com/gogf/gf/v2/util/gconv"
+)
+
+func main() {
+    // Server
+    go gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
+        defer conn.Close()
+        for {
+            data, err := conn.Recv(-1)
+            if len(data) > 0 {
+                  fmt.Println(string(data))
+            }
+            if err != nil {
+                break
+            }
+        }
+    }).Run()
+
+    time.Sleep(time.Second)
+
+    // Client
+    conn, err := gtcp.NewConn("127.0.0.1:8999")
+    if err != nil {
+        panic(err)
+    }
+    for i := 0; i < 10000; i++ {
+        if err := conn.Send([]byte(gconv.String(i))); err != nil {
+            glog.Error(err)
+        }
+        time.Sleep(time.Second)
+    }
+}
+```
+
+1. `Server` 端，接收到客户端的数据后立即打印到终端上。
+2. `Client` 端，使用同一个连接对象，在循环中每隔1秒向服务端发送当前递增的数字。同时，该功能也可以演示出底层 `Socket` 通信并没有使用缓冲实现，也就是说，执行一次 `Send` 即立刻向服务端发送数据。因此，客户端需要在本地自行管理好需要发送的缓冲数据。
+3. 执行结果 执行后，可以看到Server在终端上输出以下信息：
+
+```shell
+    2018-07-11 22:11:08.650 0
+    2018-07-11 22:11:09.651 1
+    2018-07-11 22:11:10.651 2
+    2018-07-11 22:11:11.651 3
+    2018-07-11 22:11:12.651 4
+    2018-07-11 22:11:13.651 5
+    2018-07-11 22:11:14.652 6
+    2018-07-11 22:11:15.652 7
+    2018-07-11 22:11:16.652 8
+    2018-07-11 22:11:17.652 9
+    2018-07-11 22:11:18.652 10
+    2018-07-11 22:11:19.653 11
+    ...
+```
+
+### 示例2，回显服务
+
+我们将之前的回显服务改进一下：
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "github.com/gogf/gf/v2/net/gtcp"
+    "github.com/gogf/gf/v2/os/glog"
+    "github.com/gogf/gf/v2/os/gtime"
+)
+
+func main() {
+    // Server
+    go gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
+        defer conn.Close()
+        for {
+            data, err := conn.Recv(-1)
+            if len(data) > 0 {
+                if err := conn.Send(append([]byte("> "), data...)); err != nil {
+                  fmt.Println(err)
+                }
+            }
+            if err != nil {
+                break
+            }
+        }
+    }).Run()
+
+    time.Sleep(time.Second)
+
+    // Client
+    for {
+       if conn, err := gtcp.NewConn("127.0.0.1:8999"); err == nil {
+           if b, err := conn.SendRecv([]byte(gtime.Datetime()), -1); err == nil {
+               fmt.Println(string(b), conn.LocalAddr(), conn.RemoteAddr())
+           } else {
+               fmt.Println(err)
+           }
+           conn.Close()
+       } else {
+           glog.Error(err)
+       }
+       time.Sleep(time.Second)
+    }
+}
+```
+
+该示例程序中， `Client` 每隔1秒钟向 `Server` 发送当前的时间信息， `Server` 接收到之后返回原数据信息， `Client` 接收到 `Server` 端返回信息后立即打印到终端。
+
+执行后，输出结果为：
+
+```
+> 2018-07-19 23:25:43 127.0.0.1:34306 127.0.0.1:8999
+> 2018-07-19 23:25:44 127.0.0.1:34308 127.0.0.1:8999
+> 2018-07-19 23:25:45 127.0.0.1:34312 127.0.0.1:8999
+> 2018-07-19 23:25:46 127.0.0.1:34314 127.0.0.1:8999
+```
+
+### 示例3，HTTP客户端
+
+我们在这个示例中使用gtcp包来实现一个简单的HTTP客户端，读取并打印出百度首页的 `header` 和 `content` 内容。
+
+```go
+package main
+
+import (
+    "fmt"
+    "bytes"
+    "github.com/gogf/gf/v2/net/gtcp"
+    "github.com/gogf/gf/v2/util/gconv"
+)
+
+func main() {
+    conn, err := gtcp.NewConn("www.baidu.com:80")
+    if err != nil {
+        panic(err)
+    }
+    defer conn.Close()
+
+    if err := conn.Send([]byte("GET / HTTP/1.1\r\n\r\n")); err != nil {
+        panic(err)
+    }
+
+    header        := make([]byte, 0)
+    content       := make([]byte, 0)
+    contentLength := 0
+    for {
+        data, err := conn.RecvLine()
+        // header读取，解析文本长度
+        if len(data) > 0 {
+            array := bytes.Split(data, []byte(": "))
+            // 获得页面内容长度
+            if contentLength == 0 && len(array) == 2 && bytes.EqualFold([]byte("Content-Length"), array[0]) {
+                contentLength = gconv.Int(string(array[1][:len(array[1])-1]))           }
+            header = append(header, data...)
+            header = append(header, '\n')
+        }
+        // header读取完毕，读取文本内容
+        if contentLength > 0 && len(data) == 1 {
+            content, _ = conn.Recv(contentLength)
+            break
+        }
+        if err != nil {
+            fmt.Errorf("ERROR: %s\n", err.Error())
+            break
+        }
+    }
+
+    if len(header) > 0 {
+        fmt.Println(string(header))
+    }
+    if len(content) > 0 {
+        fmt.Println(string(content))
+    }
+}
+```
+
+执行后，输出结果为：
+
+```
+HTTP/1.1 200 OK
+Accept-Ranges: bytes
+Cache-Control: no-cache
+Connection: Keep-Alive
+Content-Length: 14615
+Content-Type: text/html
+Date: Sat, 21 Jul 2018 04:21:03 GMT
+Etag: "5b3c3650-3917"
+Last-Modified: Wed, 04 Jul 2018 02:52:00 GMT
+P3p: CP=" OTI DSP COR IVA OUR IND COM "
+Pragma: no-cache
+Server: BWS/1.1
+...
+(略)
+```

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/275/221/347/273/234/347/273/204/344/273/266/TCP/347/273/204/344/273/266/TCP/347/273/204/344/273/266-/350/277/236/346/216/245/345/257/271/350/261/241//350/277/236/346/216/245/345/257/271/350/261/241-/346/266/210/346/201/257/345/214/205/345/244/204/347/220/206.md

@@ -0,0 +1,228 @@
+`gtcp` 提供了许多方便的原生操作连接数据的方法，但是在绝大多数的应用场景中，开发者需要自己设计数据结构，并进行封包/解包处理，由于 `TCP` 消息协议是没有消息边界保护的，因此复杂的网络通信环境中很容易出现 **粘包** 的情况。因此 `gtcp` 也提供了简单的数据协议，方便开发者进行消息包交互，开发者不再需要担心消息包的处理细节，包括封包/解包处理，这一切复杂的逻辑 `gtcp` 已经帮你处理好了。
+
+## 简单协议
+
+`gtcp` 模块提供了简单轻量级数据交互协议，效率非常高，协议格式如下：
+
+```
+数据长度(16bit)|数据字段(变长)
+```
+
+1. 数据长度：默认为 `16位`( `2字节`)，用于标识该消息体的数据长度，单位为字节，不包含自身的2字节；
+2. 数据字段：变长，根据数据长度可以知道，数据最大长度不能超过 `0xFFFF = 65535 bytes = 64 KB`；
+
+简单协议由 `gtcp` 封装实现，如果开发者客户端和服务端如果都使用 `gtcp` 模块来通信则无需关心协议实现，专注 `数据` 字段封装/解析实现即可。如果涉及和其他开发语言对接，则需要按照该协议实现对接即可，由于简单协议非常简单轻量级，因此对接成本很低。
+:::tip
+数据字段也可以为空，即没有任何长度。
+:::
+## 操作方法
+
+[https://pkg.go.dev/github.com/gogf/gf/v2/net/gtcp](https://pkg.go.dev/github.com/gogf/gf/v2/net/gtcp)
+
+```go
+type Conn
+    func (c *Conn) SendPkg(data []byte, option ...PkgOption) error
+    func (c *Conn) SendPkgWithTimeout(data []byte, timeout time.Duration, option ...PkgOption) error
+    func (c *Conn) SendRecvPkg(data []byte, option ...PkgOption) ([]byte, error)
+    func (c *Conn) SendRecvPkgWithTimeout(data []byte, timeout time.Duration, option ...PkgOption) ([]byte, error)
+    func (c *Conn) RecvPkg(option ...PkgOption) (result []byte, err error)
+    func (c *Conn) RecvPkgWithTimeout(timeout time.Duration, option ...PkgOption) ([]byte, error)
+```
+
+可以看到，消息包方法命名是在原有的基本连接操作方法中加上了 `Pkg` 关键词便于区分。
+
+其中，请求参数中的 `PkgOption` 数据结构如下，用于定义消息包接收策略：
+
+```go
+// 数据读取选项
+type PkgOption struct {
+    HeaderSize  int   // 自定义头大小(默认为2字节，最大不能超过4字节)
+    MaxDataSize int   // (byte)数据读取的最大包大小，默认最大不能超过2字节(65535 byte)
+    Retry       Retry // 失败重试策略
+}
+```
+
+## 使用示例
+
+### 示例1，基本使用
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/net/gtcp"
+    "github.com/gogf/gf/v2/os/glog"
+    "github.com/gogf/gf/v2/util/gconv"
+    "time"
+)
+
+func main() {
+    // Server
+    go gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
+        defer conn.Close()
+        for {
+            data, err := conn.RecvPkg()
+            if err != nil {
+                fmt.Println(err)
+                break
+            }
+            fmt.Println("receive:", data)
+        }
+    }).Run()
+
+    time.Sleep(time.Second)
+
+    // Client
+    conn, err := gtcp.NewConn("127.0.0.1:8999")
+    if err != nil {
+        panic(err)
+    }
+    defer conn.Close()
+    for i := 0; i < 10000; i++ {
+        if err := conn.SendPkg([]byte(gconv.String(i))); err != nil {
+            glog.Error(err)
+        }
+        time.Sleep(1*time.Second)
+    }
+}
+```
+
+这个示例比较简单，执行后，输出结果为：
+
+```
+receive: [48]
+receive: [49]
+receive: [50]
+receive: [51]
+...
+```
+
+### 示例2，自定义数据结构
+
+大多数场景下，我们需要对发送的消息能自定义数据结构，开发者可以利用 `数据` 字段传递任意的消息内容实现。
+
+以下是一个简单的自定义数据结构的示例，用于客户端上报当前主机节点的内存及CPU使用情况。在该示例中， `数据` 字段使用了 `JSON` 数据格式进行自定义，便于数据的编码/解码。
+:::tip
+实际场景中，开发者往往需要自定义包解析协议，或者采用较通用的 `protobuf` 二进制包封装/解析协议。
+:::
+1. `types/types.go`
+
+数据结构定义。
+
+```go
+package types
+
+import "github.com/gogf/gf/v2/frame/g"
+
+type NodeInfo struct {
+       Cpu       float32 // CPU百分比(%)
+       Host      string  // 主机名称
+       Ip        g.Map   // IP地址信息(可能多个)
+       MemUsed   int     // 内存使用(byte)
+       MemTotal  int     // 内存总量(byte)
+       Time      int     // 上报时间(时间戳)
+}
+```
+
+2. `gtcp_monitor_server.go`
+
+服务端。
+
+```go
+package main
+
+import (
+       "encoding/json"
+       "github.com/gogf/gf/v2/net/gtcp"
+       "github.com/gogf/gf/v2/os/glog"
+       "github.com/gogf/gf/.example/net/gtcp/pkg_operations/monitor/types"
+)
+
+func main() {
+       // 服务端，接收客户端数据并格式化为指定数据结构，打印
+       gtcp.NewServer("127.0.0.1:8999", func(conn *gtcp.Conn) {
+           defer conn.Close()
+           for {
+               data, err := conn.RecvPkg()
+               if err != nil {
+                   if err.Error() == "EOF" {
+                       glog.Println("client closed")
+                   }
+                   break
+               }
+               info := &types.NodeInfo{}
+               if err := json.Unmarshal(data, info); err != nil {
+                   glog.Errorf("invalid package structure: %s", err.Error())
+               } else {
+                   glog.Println(info)
+                   conn.SendPkg([]byte("ok"))
+               }
+           }
+       }).Run()
+}
+```
+
+3. `gtcp_monitor_client.go`
+
+客户端。
+
+```go
+package main
+
+import (
+       "encoding/json"
+       "github.com/gogf/gf/v2/frame/g"
+       "github.com/gogf/gf/v2/net/gtcp"
+       "github.com/gogf/gf/v2/os/glog"
+       "github.com/gogf/gf/v2/os/gtime"
+       "github.com/gogf/gf/.example/net/gtcp/pkg_operations/monitor/types"
+)
+
+func main() {
+       // 数据上报客户端
+       conn, err := gtcp.NewConn("127.0.0.1:8999")
+       if err != nil {
+           panic(err)
+       }
+       defer conn.Close()
+       // 使用JSON格式化数据字段
+       info, err := json.Marshal(types.NodeInfo{
+           Cpu       : float32(66.66),
+           Host      : "localhost",
+           Ip        : g.Map {
+               "etho" : "192.168.1.100",
+               "eth1" : "114.114.10.11",
+           },
+           MemUsed   : 15560320,
+           MemTotal  : 16333788,
+           Time      : int(gtime.Timestamp()),
+       })
+       if err != nil {
+           panic(err)
+       }
+       // 使用 SendRecvPkg 发送消息包并接受返回
+       if result, err := conn.SendRecvPkg(info); err != nil {
+           if err.Error() == "EOF" {
+               glog.Println("server closed")
+           }
+       } else {
+           glog.Println(string(result))
+       }
+}
+```
+
+4. 执行后
+
+   - 客户端输出结果为：
+
+     ```html
+       2019-05-03 13:33:25.710 ok
+     ```
+
+   - 服务端输出结果为：
+
+     ```html
+       2019-05-03 13:33:25.710 &{66.66 localhost map[eth1:114.114.10.11 etho:192.168.1.100] 15560320 16333788 1556861605}
+       2019-05-03 13:33:25.710 client closed
+     ```