通信开发进阶

    使用示例

    我们通过一个完成的示例来说明一下如何在程序中实现异步全双工通信，完成示例代码位于：https://github.com/gogf/gf/tree/master/geg/net/gtcp/pkg_operations/common

    1. types/types.go

      考虑到简化测试代码复杂度，因此这里使用JSON数据格式来传递数据。在一些对于消息包大小比较严格的场景中，数据字段可以自行按照二进制进行封装解析设计。此外，需要注意的是，即使使用JSON数据格式，其中的Act字段往往定义常量来实现，大部分场景中使用uint8类型即可，以减小消息包大小，这里偷一下懒，直接使用字符串，以便演示。

    2. funcs/funcs.go

      自定义数据格式的发送/获取定义，便于数据结构编码/解析。

      1.  package funcs
      3.  import (
      4.      "encoding/json"
      5.      "fmt"
      6.      "github.com/gogf/gf/g/net/gtcp"
      7.      "github.com/gogf/gf/geg/net/gtcp/pkg_operations/common/types"
      8.  )
      10.  // 自定义格式发送消息包
      11.  func SendPkg(conn *gtcp.Conn, act string, data...string) error {
      12.      s := ""
      13.      if len(data) > 0 {
      14.          s = data[0]
      15.      }
      16.      msg, err := json.Marshal(types.Msg{
      17.          Act  : act,
      18.          Data : s,
      19.      })
      20.      if err != nil {
      21.          panic(err)
      22.      }
      23.      return conn.SendPkg(msg)
      24.  }
      27.  func RecvPkg(conn *gtcp.Conn) (msg *types.Msg, err error) {
      28.      if data, err := conn.RecvPkg(); err != nil {
      29.          return nil, err
      30.      } else {
      31.          msg = &types.Msg{}
      32.          err = json.Unmarshal(data, msg)
      33.              return nil, fmt.Errorf("invalid package structure: %s", err.Error())
      34.          }
      35.          return msg, err
      36.      }
      37.  }

    3. 通信服务端。在该示例中，服务端并不主动断开连接，而是在10秒后向客户端发送doexit消息，通知客户端主动断开连接，以结束示例。

    4. gtcp_common_client.go

      通信客户端，可以看到代码结构和服务端差不多，数据获取独立处于for循环中，每个业务逻辑发送消息包时直接使用SendPkg方法进行发送。

      客户端连接10秒后，服务端会给客户端发送doexit消息，客户端收到该消息后便主动断开连接，长连接结束。

      1.  package main
      3.  import (
      4.      "github.com/gogf/gf/g/net/gtcp"
      5.      "github.com/gogf/gf/g/os/glog"
      6.      "github.com/gogf/gf/g/os/gtimer"
      7.      "github.com/gogf/gf/geg/net/gtcp/pkg_operations/common/funcs"
      8.      "github.com/gogf/gf/geg/net/gtcp/pkg_operations/common/types"
      9.      "time"
      10.  )
      12.  func main() {
      13.      conn, err := gtcp.NewConn("127.0.0.1:8999")
      14.      if err != nil {
      15.          panic(err)
      16.      }
      17.      defer conn.Close()
      19.      gtimer.SetInterval(time.Second, func() {
      20.          if err := funcs.SendPkg(conn, "heartbeat"); err != nil {
      21.              panic(err)
      22.          }
      23.      })
      24.      // 测试消息, 3秒后向服务端发送hello消息
      25.      gtimer.SetTimeout(3*time.Second, func() {
      26.          if err := funcs.SendPkg(conn, "hello", "My name's John!"); err != nil {
      27.              panic(err)
      28.          }
      29.      for {
      30.          msg, err := funcs.RecvPkg(conn)
      31.          if err != nil {
      32.              if err.Error() == "EOF" {
      33.                  glog.Println("server closed")
      34.              }
      35.              break
      36.          }
      37.          switch msg.Act {
      38.              case "hello":     onServerHello(conn, msg)
      39.              case "doexit":    onServerDoExit(conn, msg)
      40.              case "heartbeat": onServerHeartBeat(conn, msg)
      41.              default:
      42.                  glog.Errorfln("invalid message: %v", msg)
      43.                  break
      44.          }
      45.      }
      46.  }
      48.  func onServerHello(conn *gtcp.Conn, msg *types.Msg) {
      49.      glog.Printfln("hello response message from [%s]: %s", conn.RemoteAddr().String(), msg.Data)
      50.  }
      52.  func onServerHeartBeat(conn *gtcp.Conn, msg *types.Msg) {
      53.      glog.Printfln("heartbeat from [%s]", conn.RemoteAddr().String())
      54.  }
      56.  func onServerDoExit(conn *gtcp.Conn, msg *types.Msg) {
      57.      glog.Printfln("exit command from [%s]", conn.RemoteAddr().String())
      58.      conn.Close()
      59.  }
    5. 执行后
      • 服务端输出结果
      • 客户端输出结果