Go语言网络编程：深入理解net.Conn.Read与缓冲区管理

func handleConnection(conn net.Conn) {
    defer conn.Close() // 确保连接关闭

    var buf []byte // 问题所在：声明了一个零长度的切片

    // 尝试向客户端发送欢迎信息
    _, err := conn.Write([]byte("Ready to receive\n"))
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error writing to socket: %s\n", err)
        return
    }

    for {
        readLen, err := conn.Read(buf) // 尝试从连接中读取数据
        if err != nil {
            if err == io.EOF {
                fmt.Printf("Connection closed by remote host: %s\n", conn.RemoteAddr())
            } else {
                fmt.Fprintf(os.Stderr, "Error reading from socket: %s\n", err)
            }
            return
        }
        if readLen == 0 {
            // 理论上，如果readLen为0且err为nil，可能表示没有数据可读，但对于TCP通常表示EOF
            fmt.Printf("Read 0 bytes, connection might be closing or no data: %s\n", conn.RemoteAddr())
            continue
        }

        // 尝试打印读取到的数据
        // 注意：由于buf是零长度，这里打印的将是空字符串或不确定内容
        fmt.Printf("Client at %s says '%s'\n", conn.RemoteAddr().String(), string(buf[:readLen]))
    }
}

var buf = make([]byte, 1024) // 分配一个1024字节的缓冲区

package main

import (
    "fmt"
    "io"
    "net"
    "os"
    "strconv"
)

// handleConnection 处理单个客户端连接
func handleConnection(conn net.Conn) {
    defer func() {
        fmt.Printf("Closing connection from %s\n", conn.RemoteAddr())
        conn.Close() // 确保连接最终被关闭
    }()

    fmt.Printf("Accepted connection from %s\n", conn.RemoteAddr())

    // 1. 正确初始化缓冲区：分配一个固定大小的字节切片
    buf := make([]byte, 1024) // 例如，1KB的缓冲区

    // 2. 向客户端发送欢迎信息
    _, err := conn.Write([]byte("Ready to receive (Type 'exit' to close)\n"))
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error writing welcome message to %s: %v\n", conn.RemoteAddr(), err)
        return
    }

    // 3. 循环读取客户端数据并回显
    for {
        readLen, err := conn.Read(buf) // 从连接中读取数据到缓冲区
        if err != nil {
            if err == io.EOF {
                // io.EOF表示连接已被远程端点关闭
                fmt.Printf("Connection from %s closed by remote host.\n", conn.RemoteAddr())
            } else {
                fmt.Fprintf(os.Stderr, "Error reading from %s: %v\n", conn.RemoteAddr(), err)
            }
            return // 发生错误或连接关闭时退出循环
        }

        if readLen == 0 {
            // 如果readLen为0且err为nil，通常不应该发生在一个活跃的TCP连接上
            // 但作为防御性编程，可以处理一下，或者直接认为这是EOF的另一种表现
            fmt.Printf("Read 0 bytes from %s, continuing...\n", conn.RemoteAddr())
            continue
        }

        // 将读取到的字节转换为字符串并打印
        receivedData := string(buf[:readLen])
        fmt.Printf("Received %d bytes from %s: '%s'\n", readLen, conn.RemoteAddr(), receivedData)

        // 检查是否是退出命令
        if len(receivedData) >= 4 && receivedData[:4] == "exit" {
            fmt.Printf("Client %s requested exit.\n", conn.RemoteAddr())
            return // 客户端请求退出，关闭连接
        }

        // 将读取到的数据回显给客户端
        _, err = conn.Write(buf[:readLen])
        if err != nil {
            fmt.Fprintf(os.Stderr, "Error writing echo data to %s: %v\n", conn.RemoteAddr(), err)
            return
        }
    }
}

// main函数启动TCP监听器
func main() {
    if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, "Usage: %s <port>\n", os.Args[0])
        os.Exit(1)
    }

    port := os.Args[1]
    listenAddr := "localhost:" + port // 监听本地所有接口的指定端口

    listener, err := net.Listen("tcp", listenAddr)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Could not listen on %s: %v\n", listenAddr, err)
        os.Exit(1)
    }
    defer listener.Close() // 确保监听器关闭

    fmt.Printf("Echo server listening on %s\n", listenAddr)

    for {
        // 接受新的客户端连接
        conn, err := listener.Accept()
        if err != nil {
            fmt.Fprintf(os.Stderr, "Error accepting connection: %v\n", err)
            continue // 继续尝试接受其他连接
        }
        // 为每个新连接启动一个goroutine来处理，实现并发
        go handleConnection(conn)
    }
}