Golang实现TCP客户端/服务器的常见问题

为什么不尝试使用UDP？它似乎更适合您的使用场景（如果我的理解正确的话）。

通常客户端会主动向服务器发起连接。服务端持续监听连接请求并作出响应。当连接建立后，双方都可以决定保持连接并使用它，或者关闭连接。但一旦连接关闭，客户端必须重新发起新的连接。

在Golang中实现TCP客户端/服务器通信时，你的思路基本正确，但需要一些调整。通常，服务器在客户端连接时保存连接对象（如net.Conn），然后通过该连接直接向客户端发送数据。客户端不需要额外监听端口来接收消息，因为连接是双向的：客户端可以在连接上读取服务器发送的数据，而无需作为服务器运行。下面是一个示例代码，展示如何实现这一点。

服务器端代码示例

服务器保存每个客户端的连接，并允许向特定客户端发送消息。这里使用一个映射来存储连接标识符（如客户端ID）和对应的连接对象。

package main

import (
    "fmt"
    "net"
    "sync"
)

type Server struct {
    connections map[string]net.Conn
    mutex       sync.RWMutex
}

func NewServer() *Server {
    return &Server{
        connections: make(map[string]net.Conn),
    }
}

func (s *Server) handleConnection(conn net.Conn, clientID string) {
    defer conn.Close()
    s.mutex.Lock()
    s.connections[clientID] = conn
    s.mutex.Unlock()

    fmt.Printf("客户端 %s 已连接\n", clientID)
    buffer := make([]byte, 1024)
    for {
        n, err := conn.Read(buffer)
        if err != nil {
            fmt.Printf("客户端 %s 断开连接: %v\n", clientID, err)
            s.mutex.Lock()
            delete(s.connections, clientID)
            s.mutex.Unlock()
            return
        }
        fmt.Printf("从客户端 %s 收到消息: %s", clientID, string(buffer[:n]))
    }
}

func (s *Server) sendToClient(clientID string, message string) error {
    s.mutex.RLock()
    conn, exists := s.connections[clientID]
    s.mutex.RUnlock()
    if !exists {
        return fmt.Errorf("客户端 %s 未连接", clientID)
    }
    _, err := conn.Write([]byte(message))
    return err
}

func main() {
    server := NewServer()
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println("监听失败:", err)
        return
    }
    defer listener.Close()
    fmt.Println("服务器启动在 :8080")

    go func() {
        // 示例：向特定客户端发送消息（例如，在另一个goroutine中）
        // 假设客户端ID为 "client1"
        // server.sendToClient("client1", "Hello from server!\n")
    }()

    clientCounter := 0
    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("接受连接失败:", err)
            continue
        }
        clientCounter++
        clientID := fmt.Sprintf("client%d", clientCounter)
        go server.handleConnection(conn, clientID)
    }
}

客户端代码示例

客户端连接到服务器，并在同一个连接上读取服务器发送的消息，无需额外监听端口。

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
)

func main() {
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        fmt.Println("连接服务器失败:", err)
        return
    }
    defer conn.Close()
    fmt.Println("已连接到服务器")

    // 启动一个goroutine来读取服务器消息
    go func() {
        reader := bufio.NewReader(conn)
        for {
            message, err := reader.ReadString('\n')
            if err != nil {
                fmt.Println("从服务器读取失败:", err)
                return
            }
            fmt.Print("收到服务器消息: " + message)
        }
    }()

    // 从标准输入读取用户输入并发送到服务器
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        text := scanner.Text()
        _, err := conn.Write([]byte(text + "\n"))
        if err != nil {
            fmt.Println("发送消息失败:", err)
            return
        }
    }
}

说明

• 服务器端：使用一个映射来存储客户端ID和net.Conn对象，通过sendToClient方法向特定客户端发送消息。使用互斥锁（sync.RWMutex）来安全地处理并发访问。
• 客户端：在连接建立后，启动一个goroutine持续读取服务器发送的数据。客户端通过标准输入发送消息到服务器，但服务器也可以主动发送消息。
• 关键点：TCP连接是全双工的，因此客户端不需要作为服务器监听端口；它可以直接在现有连接上读取数据。

这种方法避免了额外的端口监听，简化了架构。如果客户端需要处理来自多个服务器的通信，可以考虑使用多个连接或更高级的协议（如WebSocket），但对于基本TCP通信，上述代码是标准做法。