Wie kann ich serverseitige Fehler für den Jsonrpc-Server abfangen?

Der PHP-Editor Zimo stellt Ihnen vor, wie Sie serverseitige Fehler des JSONRPC-Servers erfassen. Während des Entwicklungsprozesses treten häufig serverseitige Fehler auf, und es ist sehr wichtig, diese Fehler genau zu erfassen. Um dieses Problem zu lösen, können wir Try-Catch-Anweisungen verwenden, um serverseitige Fehler zu erfassen und Fehlerinformationen an den Client zurückzugeben. Auf diese Weise können wir serverseitige Fehler besser lokalisieren und behandeln sowie die Programmstabilität und -zuverlässigkeit verbessern. Im Folgenden erklären wir im Detail, wie dieser Prozess gelingt.

Frageninhalt

Angenommen, ich habe einen einfachen Golang-JrPC-Server, der auf TCP basiert:

package main

import (
    "fmt"
    "net"
    "net/rpc"
    "net/rpc/jsonrpc"
)

type Arith int

type Args struct {
    A, B int
}

func (t *Arith) Add(args *Args, result *int) error {
    *result = args.A + args.B
    return nil
}

func RunServer() {
    arith := new(Arith)
    rpc.Register(arith)

    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println("Error starting server:", err)
        return
    }
    defer listener.Close()

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting connection:", err)
            continue
        }

        go jsonrpc.ServeConn(conn)
    }
}

Gibt es eine Möglichkeit, „Client getrennt!“ auszudrucken, wenn der Client die Verbindung zum Server trennt? Gibt es einen Rückruf oder ähnliches auf net.Conn?

func main() {
    go RunServer()
    client, err := jsonrpc.Dial("tcp", "localhost:8080")
    if err != nil {
        fmt.Println("Error connecting to server:", err)
        return
    }
    

    args := &Args{A: 3, B: 5}
    var result int
    
    // run a method
    err = client.Call("Arith.Add", args, &result)
    if err != nil {
        fmt.Println("Error calling Add method:", err)
        return
    }
    fmt.Printf("Result of %d + %d = %d\n", args.A, args.B, result)
    
    // suppose the client closes the client
    client.Close()
    // how does the server detect that the client is closed?
    // would be nice if I could print "client disconnected!"
    // without having to send jsonrpc heartbeats

}

Es wäre schön, wenn ich keine Jsonrpc-Heartbeat-Nachrichten senden müsste.

Ich habe in regelmäßigen Abständen versucht, Dummy-Lesungen von der Verbindung in der Goroutine durchzuführen, aber dies beeinträchtigt die JSONRPC-Verbindung.

Workaround

jsonrpc.ServeConn-Methode kehrt zurück, wenn der Client auflegt. Gibt die Meldung „Client getrennt“ aus, nachdem ServeConn zurückgekehrt ist.

func RunServer() {
    arith := new(Arith)
    rpc.Register(arith)

    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println("Error starting server:", err)
        return
    }
    defer listener.Close()

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting connection:", err)
            continue
        }

        go func() {
           jsonrpc.ServeConn(conn)
           fmt.Println("client disconnected") // <--- new code here
        }()
    }
}

Das obige ist der detaillierte Inhalt vonWie kann ich serverseitige Fehler für den Jsonrpc-Server abfangen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!