Wie funktioniert Go WebSocket mit anderen Protokollen?

Go WebSocket funktioniert mit anderen Protokollen, darunter: HTTP/HTTPS: WebSocket läuft normalerweise auf HTTP/HTTPS, wobei das WebSocket-Protokoll über einen Handshake-Prozess ausgehandelt wird. gRPC: gRPC ist ein RPC-Framework, das in WebSocket integriert ist, um RPC-Aufrufe mit geringer Latenz und hohem Durchsatz zwischen Clients und Servern durchzuführen.

So funktioniert WebSocket mit anderen Protokollen

WebSocket ist ein Protokoll für die Vollduplex-Kommunikation zwischen Client und Server. Es wird häufig zum Erstellen von Echtzeitanwendungen wie Chat, Messaging und Spielen verwendet. WebSocket kann in einer Vielzahl von Szenarien mit anderen Protokollen wie HTTP, HTTPS, gRPC und WebSockets verwendet werden.

Mit HTTP und HTTPS

WebSockets laufen normalerweise auf HTTP oder HTTPS. Wenn ein Client eine WebSocket-Verbindung zum Server herstellt, sendet er zunächst eine HTTP-Anfrage, die einen speziellen Header namens „Upgrade“ enthält, dessen Wert auf „websocket“ gesetzt ist. Der Server antwortet auf diese Anfrage mit einem „Upgrade“-Header, dessen Wert ebenfalls auf „websocket“ gesetzt ist. Dieser Handshake-Prozess ermöglicht es dem Client und dem Server, die Verwendung des WebSocket-Protokolls auszuhandeln und einen Vollduplex-Kommunikationskanal über HTTP/HTTPS einzurichten.

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

const (
    port = ":8080"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func main() {
    http.HandleFunc("/", indexHandler)
    http.HandleFunc("/ws", websocketHandler)

    log.Printf("Listening on port %s", port)
    if err := http.ListenAndServe(port, nil); err != nil {
        log.Fatal(err)
    }
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the WebSocket page.")
}

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    for {
        mt, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            conn.Close()
            break
        }

        if err := conn.WriteMessage(mt, message); err != nil {
            log.Println(err)
            conn.Close()
            break
        }
    }
}

Verwendung von gRPC

gRPC ist ein leistungsstarkes RPC-Framework (Remote Procedure Call), das mit WebSocket verwendet werden kann. Der Client verwendet gRPC-Funktionen, um serverseitige Methoden aufzurufen, und die serverseitige Methode verwendet WebSocket, um Antworten zu senden. Durch diese Integration können Anwendungen RPC-Aufrufe mit geringer Latenz und hohem Durchsatz verarbeiten.

import (
    "context"
    "fmt"
    "log"
    "net/http"

    "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
    "github.com/gorilla/websocket"
    "google.golang.org/protobuf/proto"
)

const (
    port  = ":8080"
    grpcAddr = ":50051"
)

var upgrader = websocket.Upgrader{}
var mux *runtime.ServeMux

func main() {
    mux = runtime.NewServeMux()

    grpcConn, err := grpc.DialContext(
        context.Background(),
        grpcAddr,
        grpc.WithInsecure(),
        )
    if err != nil {
        log.Fatal(err)
    }

    // 注册 gRPC 服务到网关。
    if err := helloworldpb.RegisterGreeterHandler(context.Background(), mux, grpcConn); err != nil {
        log.Fatal(err)
    }

    http.HandleFunc("/", indexHandler)
    http.HandleFunc("/grpc-ws", websocketHandler)

    log.Printf("Listening on port %s", port)
    if err := http.ListenAndServe(port, nil); err != nil {
        log.Fatal(err)
    }
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the gRPC-WebSocket page.")
}

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    for {
        mt, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            conn.Close()
            break
        }

        req := &helloworldpb.HelloRequest{}
        if err := proto.Unmarshal(message, req); err != nil {
            log.Println(err)
            conn.Close()
            break
        }

        ctx := context.Background()
        resp, err := helloworldpb.NewGreeterClient(grpcConn).SayHello(ctx, req)
        if err != nil {
            log.Println(err)
            conn.Close()
            break
        }

        message, err := proto.Marshal(resp)
        if err != nil {
            log.Println(err)
            conn.Close()
            break
        }

        if err := conn.WriteMessage(mt, message); err != nil {
            log.Println(err)
            conn.Close()
            break
        }
    }
}

Das obige ist der detaillierte Inhalt vonWie funktioniert Go WebSocket mit anderen Protokollen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!