Wie erreicht man eine bidirektionale Kommunikation mithilfe von Unix-Sockets in Go?

Unix-Sockets in Go: Bidirektionale Kommunikation einrichten

Sie versuchen, eine einfache Client-Server-Architektur mithilfe von Unix-Sockets zu implementieren, sind aber auf ein Problem gestoßen Problem mit dem unidirektionalen Datenfluss. Lassen Sie uns in den Code eintauchen und das Problem angehen.

In Ihrem Clientcode senden Sie erfolgreich Nachrichten an den Server, aber der Server antwortet nicht. Dies deutet darauf hin, dass Sie einen entscheidenden Schritt verpassen: das Lesen der Antwort des Servers. Im überarbeiteten Client-Code unten haben wir eine Reader-Goroutine hinzugefügt, die das Lesen von Daten vom Server übernimmt.

// Client code with a reader goroutine
package main

import (
    "io"
    "log"
    "net"
    "time"
)

func reader(r io.Reader) {
    buf := make([]byte, 1024)
    for {
        n, err := r.Read(buf[:])
        if err != nil {
            return
        }
        println("Client got:", string(buf[0:n]))
    }
}

func main() {
    c, err := net.Dial("unix", "/tmp/echo.sock")
    if err != nil {
        panic(err)
    }
    defer c.Close()

    go reader(c)
    for {
        _, err := c.Write([]byte("hi"))
        if err != nil {
            log.Fatal("write error:", err)
            break
        }
        time.Sleep(1e9)
    }
}

Auf der Serverseite sieht Ihr Code korrekt aus. Es ist jedoch unbedingt erforderlich, Fehler in Goroutinen zu behandeln und Verbindungen zu schließen, wenn dies erledigt ist, wie im geänderten Servercode unten gezeigt:

// Server code with error handling and connection closing
package main

import (
    "log"
    "net"
)

func echoServer(c net.Conn) {
    defer c.Close()  // Ensure connection is closed when the goroutine exits

    for {
        buf := make([]byte, 512)
        nr, err := c.Read(buf)
        if err != nil {
            log.Fatal("read error:", err)
        }

        data := buf[0:nr]
        _, err = c.Write(data)
        if err != nil {
            log.Fatal("write error:", err)
        }
    }
}

func main() {
    l, err := net.Listen("unix", "/tmp/echo.sock")
    if err != nil {
        log.Fatal("listen error:", err)
    }

    for {
        fd, err := l.Accept()
        if err != nil {
            log.Fatal("accept error:", err)
        }

        go echoServer(fd)
    }
}

Mit diesen Änderungen sollte Ihre Client-Server-Kommunikation jetzt vollständig bi- gerichtet, so dass Daten in beide Richtungen fließen können.

Das obige ist der detaillierte Inhalt vonWie erreicht man eine bidirektionale Kommunikation mithilfe von Unix-Sockets in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!