Senden einer Nachricht von einem Port zu einem anderen

Question

Ich habe einen Server und 2 Clients, die jeweils ihren eigenen Port verwenden. Wenn ein Client eine Nachricht an den Server sendet, gibt der Server diese an den Absender zurück. Dann soll der Server die Nachricht auch an den anderen Client senden. Hier habe ich Probleme.

Ich glaube, ich kann die Verbindung in writeMessage() falsch einrichten, aber ich bin mir nicht ganz sicher. Im Moment habe ich die Funktion nur versucht, zu Debugging-Zwecken auf Client 80 auf Port 8080 zu schreiben.

Server:

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)) 
} 

Client 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) 
     } 
    } 
} 

(Mein zweiter Client ist die gleiche wie meine erste außer Port 3000 ist mit 8080 ersetzt) ​​

Um zu replizieren Das Problem, der Benutzer muss den Servercode und dann beide Clients ausführen. Die Clients können dann Nachrichten an den Server senden.

Jede Hilfe mit diesem würde sehr geschätzt werden. Ich kann das überhaupt nicht herausfinden. Hoffentlich können einige erfahrene Go-Benutzer helfen!

Answer 1

Ihre Logik scheint Fehler zu haben, wo acceptloop Aufrufe für listenconnection, es erstellt eine Endlosschleife innerhalb einer Endlosschleife. Ich denke, Sie müssen das System mit Anwendungsfällen und Szenarien zu rekonstruieren.

Wenn mein Verständnis stimmt, möchten Sie einen Server haben, der darauf wartet, dass Clients eine Verbindung herstellen. Zuerst kommt client1 herein und sendet einige Daten. Der Server akzeptiert diese Verbindung und muss sie nur einmal für jeden Client akzeptieren. Wenn der Client2 online ist, senden Sie an diesem Punkt Daten an Client2. All dies geschieht in einer Endlosschleife.

Kasse dieses Code https://play.golang.org/p/_5AREG3jnG