Golang 的 TCP EOF 几乎同时处理接收的消息

从现在开始，我们要努力学习啦！今天我给大家带来《Golang 的 TCP EOF 几乎同时处理接收的消息》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

我有一个监听设备的 golang tcp 服务器。设备应发送一条 hello 消息，然后服务器以 hello 进行响应。之后，设备发送数据。发送数据后，设备会发送提交请求以检查是否收到数据。问题是，我没有收到提交请求。这几乎就像数据和提交请求是同时发送的，因为记录的时间戳相隔 0.1 秒。但是，我知道我收到了一些东西，因为发送数据后，我在日志中得到了以下内容：

device ip: 13.56.127.98:65145, timestamp: 2023-08-07t21:23:40.893412845z 
        error reading header: eof

这也是服务器代码：

package servers

import (
    "bufio"
    "bytes"
    "encoding/binary"
    "fmt"
    "math/rand"
    "net"
    "time"
)

func Server() {
    PORT := ":8081"
    l, err := net.Listen("tcp", PORT)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer l.Close()
    rand.Seed(time.Now().Unix())

    for {
        c, err := l.Accept()
        if err != nil {
            fmt.Println(err)
            return
        }

        // Set TCP keep-alive settings
        if tcpConn, ok := c.(*net.TCPConn); ok {
            // Enable TCP keep-alive
            tcpConn.SetKeepAlive(true)

            // Set the time period for sending TCP keep-alive probes
            keepAlivePeriod := 60 * time.Hour // Adjust this value as needed
            tcpConn.SetKeepAlivePeriod(keepAlivePeriod)
        }
        go func() {
            defer c.Close()
            handleConnection(c)
        }()
    }
}

func handleConnection(c net.Conn) {
    defer c.Close()

    data := make([]byte, 4096)

    for {
        //log device ip
        fmt.Printf("Device IP: %s, Timestamp: %s \n", c.RemoteAddr().String(), time.Now().Format(time.RFC3339Nano))
        // Read the communication header from the connection
        //_, err := c.Read(data)
        _, err := bufio.NewReader(c).Read(data)
        if err != nil {
            fmt.Println("   Error reading header:", err)
            return
        }

        // Check the sync bytes
        if data[0] != 0x02 || data[1] != 0x55 {
            fmt.Println("   Invalid sync bytes")
            //log actual bytes received
            fmt.Printf("    Received: %02X %02X %02X %02X %02X\n", data[0], data[1], data[2], data[3], data[4])
            return
        }

        // Get the message type from the header
        messageType := data[2]

        // get payload length
        payloadLengthBytes := data[3:5]
        payloadLength := binary.LittleEndian.Uint16(payloadLengthBytes)

        // Handle the different message types
        switch messageType {
        case 0:
            fmt.Println("   Received Hello message:")
            sendHelloResponse(c)
        case 4:
            // Send data records
            fmt.Println("   Received Send data records message:")
        case 5:
            // Commit request
            fmt.Println("   Received Commit request message:")
        // ... more cases follow
        }
    }
}

我假设 for 循环和读取数据存在一些问题。缓冲区大小也应该足够大，因为每条消息总共可能有 500 字节。

正确答案

在这个答案中，我应用了问题评论中的好的建议。设置描述更改的注释。

func Server() {
    PORT := ":8081"
    l, err := net.Listen("tcp", PORT)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer l.Close()
    // rand.Seed(time.Now().Unix()) NOTE: not needed in GO 1.20 or later.

    for {
        c, err := l.Accept()
        if err != nil {
            fmt.Println(err)
            return
        }

        // Set TCP keep-alive settings
        if tcpConn, ok := c.(*net.TCPConn); ok {
            // Enable TCP keep-alive
            tcpConn.SetKeepAlive(true)

            // Set the time period for sending TCP keep-alive probes
            keepAlivePeriod := 60 * time.Hour // Adjust this value as needed
            tcpConn.SetKeepAlivePeriod(keepAlivePeriod)
        }
        // NOTE: anonymous function eliminated here by
        // eliminating extra call to defer c.Close()
        go handleConnection(c)
    }
}

func handleConnection(c net.Conn) {
    defer c.Close()
    data := make([]byte, 4096)

    // NOTE: create buffer once and reuse.
    br := bufio.NewReader(c)

    for {
        // NOTE: use io.ReadFull to read complete header.
        _, err := io.ReadFull(br, data[:5])
        if err != nil {
            fmt.Println("   Error reading header:", err)
            return
        }

        // Check the sync bytes
        if data[0] != 0x02 || data[1] != 0x55 {
            fmt.Println("   Invalid sync bytes")
            //log actual bytes received
            fmt.Printf("    Received: %02X %02X %02X %02X %02X\n", data[0], data[1], data[2], data[3], data[4])
            return
        }

        // Get the message type from the header
        messageType := data[2]

        // Get payload
        // NOTE: Use io.ReadFUll again.
        payloadLength := binary.LittleEndian.Uint16(data[3:5])
        _, err = io.ReadFull(br, data[:payloadLength])
        if err != nil {
            fmt.Println("   Error reading payload:", err)
            return
        }

        // Handle the different message types
        switch messageType {
        case 0:
            fmt.Println("   Received Hello message:")
            //sendHelloResponse(c)
        case 4:
            // Send data records
            fmt.Println("   Received Send data records message:")
        case 5:
            // Commit request
            fmt.Println("   Received Commit request message:")
            // ... more cases follow
        }
    }
}

Run the code on the playground。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。