Networking 从一个端口向另一个端口发送消息

我有一个服务器和两个客户端，每个客户端使用自己的端口。当客户端向服务器发送消息时，服务器会将其回显给发送者。然后，服务器也应该将消息发送到另一个客户端。这就是我遇到问题的地方

我相信我可能在writeMessage（）中设置了错误的连接，但我不能完全确定。目前，我有一个函数，它只是试图在端口8080上写入客户机2以进行调试

服务器：

package main

import (
    "fmt"
    "log"
    "net"
)

var message string = ""

func main() {
    fmt.Println("The server is listening on Port 3000 and 8080")
    listener, err := net.Listen("tcp", "localhost:3000")
    if err != nil {
        log.Fatal(err) 
    }

    listener2, err := net.Listen("tcp", "localhost:8080")
    if err != nil {
        log.Fatal(err)
    }

    go acceptLoop(listener)
    acceptLoop(listener2)


}

func acceptLoop(l net.Listener) {
    defer l.Close()
    for {
            c, err := l.Accept()
            if err != nil {
                log.Fatal(err)
            }
            fmt.Println("New connection found!")
            listenConnection(c)
    }
}

func listenConnection(conn net.Conn) {
        for {
                buffer := make([]byte, 1400)
                dataSize, err := conn.Read(buffer)
                if err != nil {
                    fmt.Println("Connection has closed")
                    return
                }

                //This is the message you received
                data := buffer[:dataSize]
                fmt.Print(string(data))
                conn.Write(data)
                message = string(data)
                writeMessage()
        }
}

func writeMessage(){
    conn2, e := net.Dial("tcp", "localhost:8080")
    if e != nil {
        log.Fatalln(e)
    }
    defer conn2.Close()
    conn2.Write([]byte(message))
}

客户1：

package main

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

func main() {
        conn, err := net.Dial("tcp", "localhost:3000")
        if err != nil {
                log.Fatalln(err)
        }

        go listenConnection(conn, err)
        writeMessage(conn, err)

}

func listenConnection(conn net.Conn, err error){
    for {
                buffer := make([]byte, 1400)
                dataSize, err := conn.Read(buffer)
                if err != nil {
                        fmt.Println("connection closed")
                        return
                }

                data := buffer[:dataSize]
                fmt.Print("Server: ", string(data))
        }
}

func writeMessage(conn net.Conn, err error){
    for {
        reader := bufio.NewReader(os.Stdin)
        //fmt.Print("Enter message: ")
        text, _ := reader.ReadString('\n')
        text = "3000: " + text

        _, err = conn.Write([]byte(text))
        if err != nil {
                log.Fatalln(err)
        }
    }
}

（我的第二个客户端与第一个客户端相同，只是端口3000被替换为8080。）

为了复制问题，用户必须运行服务器代码，然后运行两个客户端。然后，客户端可以向服务器发送消息

---

在此方面的任何帮助都将不胜感激。我完全搞不懂。希望一些更有经验的围棋用户能够提供帮助

您的逻辑似乎有缺陷，在acceptloop调用listenconnection时，它会在无限循环中创建无限循环。我认为您需要使用用例和场景重构系统

如果我的理解是正确的，您希望有一个服务器等待客户端连接。首先，client1进来，发送一些数据。服务器接受此连接，并且只需要为每个客户端接受一次。此时，如果client2处于联机状态，则向client2发送数据。所有这些都是在一个无限循环中发生的

签出此代码

---

您的逻辑似乎有缺陷，在acceptloop调用listenconnection时，它会在无限循环中创建无限循环。我认为您需要使用用例和场景重构系统

如果我的理解是正确的，您希望有一个服务器等待客户端连接。首先，client1进来，发送一些数据。服务器接受此连接，并且只需要为每个客户端接受一次。此时，如果client2处于联机状态，则向client2发送数据。所有这些都是在一个无限循环中发生的

签出此代码

---

这正是我需要的！看来我把这条路弄得比需要的更复杂了。非常感谢。这正是我需要的！看来我把这条路弄得比需要的更复杂了。非常感谢。