Schritt-für-Schritt-Anleitung zur Verwendung von WebSockets in Golang

Wir senden normalerweise eine Nachricht und erhalten sofort eine Antwort, ohne eine Seite zu aktualisieren. Zuvor war es für App-Entwickler jedoch eine große Herausforderung, Echtzeitfunktionen zuzulassen.

Nach langen HTTP-Abfragen und AJAP hat die Entwicklergemeinschaft letztendlich eine Lösung für die Entwicklung von Echtzeitanwendungen gefunden.

WebSockets sind die Lösung für dieses Problem und haben es ermöglicht, eine interaktive Sitzung zwischen einem Server und dem Browser eines Benutzers zu erstellen. Mit WebSockets kann ein Browser Nachrichten an einen Server senden und ereignisgesteuerte Antworten erhalten. Und es ist nicht erforderlich, den Server nach einer Antwort abzufragen.

Derzeit sind WebSockets die erstklassige Lösung für die Entwicklung von Echtzeit-Apps: Tracking-Apps, Instant Messenger, Online-Spiele und mehr.

In dieser schrittweisen Anleitung wird erläutert, wie WebSockets funktionieren und wie WebSocket-Apps in der Sprache Golang erstellt werden. Lass uns einfach weiterlesen!

Was sind WebSockets?

WebSockets sind aktualisierte HTTP-Verbindungen, die so lange bestehen bleiben, bis der Client oder der Server die Verbindung beendet. Über die WebSocket-Verbindung ist es möglich, eine Duplex-Kommunikation durchzuführen. Dies ist eine extravagante Methode, um zu sagen, dass die Kommunikation von und zu dem Server von den Clients über diese einzelne Verbindung möglich ist.

Der beste Aspekt von WebSockets ist, dass sie eine TCP-Verbindung verwenden und die gesamte Verbindung über diese einzige dauerhafte TCP-Verbindung aufgebaut wird.

Dies verringert den Netzwerk-Overhead, der für die Entwicklung von Echtzeit-Apps mithilfe von WebSockets erforderlich ist, erheblich, da keine kontinuierliche Abfrage von HTTP-Endpunkten erforderlich ist.

Wie erstelle ich eine WebSocket App in Golang?

Hier sind einige wichtige Schritte, die Sie ausführen müssen, um einen einfachen WebSocket-Echoserver abhängig von der net / http-Bibliothek zu schreiben:

Schritt 1: Einrichten eines Handshakes

Zunächst müssen Sie mithilfe eines WebSocket-Endpunkts einen HTTP-Handler erstellen:

// HTTP server with WebSocket endpoint
        func Server() {
        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
            ws, err := NewHandler(w, r)
            if err != nil {
                 // handle error
            }
            if err = ws.Handshake(); err != nil {
                // handle error
            }
        …

Führen Sie als Nächstes die WebSocket-Struktur aus.

Der Client sendet immer die erste Handshake-Anfrage. Wenn der Server eine WebSocket-Anforderung authentifiziert hat, muss er mit einer Handshake-Antwort antworten.

Denken Sie daran, dass Sie diese Antwort nicht mit verwenden können http.ResponseWriter, da dadurch die grundlegende TCP-Verbindung getrennt wird, wenn Sie mit dem Senden der Antwort beginnen.

Daher müssen Sie HTTP-Hijacking verwenden, mit dem Sie den grundlegenden TCP-Verbindungshandler und bufio.Writer verwalten können. Dies bietet Ihnen die Möglichkeit, Daten zu lesen und zu schreiben, ohne die TCP-Verbindung zu verhindern.

// NewHandler initializes a new handler
         func NewHandler(w http.ResponseWriter, req http.Request) (WS, error) {
         hj, ok := w.(http.Hijacker)
         if !ok {
             // handle error
         }                  …..
 }

Um den Handshake durchzuführen, muss der Server mit den entsprechenden Headern antworten.

// Handshake creates a handshake header
    func (ws *WS) Handshake() error {
        
        hash := func(key string) string {
            h := sha1.New()
            h.Write([]byte(key))
            h.Write([]byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))

        return base64.StdEncoding.EncodeToString(h.Sum(nil))
        }(ws.header.Get("Sec-WebSocket-Key"))
      .....
}

“Sec-WebSocket-Schlüssel” wird zufällig erstellt und ist Base64-codiert. Nach dem Akzeptieren einer Anforderung muss der Server diesen Schlüssel einer festen Zeichenfolge hinzufügen. Angenommen, Sie haben den Schlüssel x3JJHMbDL1EzLkh9GBhXDw ==.

In diesem Fall können Sie sich für SHA-1 zur Berechnung des Binärwerts und Base64 für die Codierung entscheiden. Sie erhalten HSmrc0sMlYUkAGmm5OPpG2HaGWk =. Verwenden Sie dies als Wert des Sec-WebSocket-Accept-Antwortheaders.

Schritt 2: Übertragen von Datenrahmen

Sobald Sie den Handshake abgeschlossen haben, kann Ihre Anwendung vom und zum Client lesen und schreiben. Die Spezifikation des WebSocket beschreibt ein bestimmtes Rahmenformat, das zwischen einem Server und einem Client verwendet wird.

Das Bild unten zeigt ein kleines Muster des Rahmens:

Verwenden Sie den folgenden Code, um die Client-Nutzdaten zu dekodieren:

// Recv receives data and returns a Frame
    func (ws *WS) Recv() (frame Frame, _ error) {
        frame = Frame{}
        head, err := ws.read(2)
        if err != nil {
            // handle error
        }

In der Reihenfolge ermöglichen diese Codezeilen das Codieren von Daten:

// Send sends a Frame
    func (ws *WS) Send(fr Frame) error {
        // make a slice of bytes of length 2
        data := make([]byte, 2)
    
        // Save fragmentation & opcode information in the first byte
        data[0] = 0x80 | fr.Opcode
        if fr.IsFragment {
            data[0] &= 0x7F
        }
        .....

Schritt 3: Schließen eines Handshakes

Wenn eine der Client-Parteien einen Close-Frame neben einem Close-Status als Nutzlast sendet, wird ein Handshake geschlossen.

Spontan kann die Partei, die den Close-Frame sendet, auch einen Close-Zweck in der Nutzlast senden. Falls der Client das Schließen initiiert, muss der Server der Reihe nach einen entsprechenden Schließrahmen senden.

// Close sends a close frame and closes the TCP connection
func (ws *Ws) Close() error {
    f := Frame{}
    f.Opcode = 8
    f.Length = 2
    f.Payload = make([]byte, 2)
    binary.BigEndian.PutUint16(f.Payload, ws.status)
    if err := ws.Send(f); err != nil {
        return err
    }
    return ws.conn.Close()
}

Liste der WebSocket-Bibliotheken

Viele Bibliotheken von Drittanbietern vereinfachen das Leben von Entwicklern und unterstützen auf erstaunliche Weise die Arbeit mit WebSocket-Apps.

1. STDLIB (x / net / websocket)

Diese WebSocket-Bibliothek gehört zur Standardbibliothek. Es wendet einen Server und einen Client für das WebSocket-Protokoll an. Sie müssen es nicht installieren und es enthält gut offizielle Dokumentation.

Andererseits verfügt es jedoch nicht über einige Funktionen, die in anderen WebSocket-Bibliotheken erkannt werden können. Im STDLIB-Paket (x / net / websocket) ermöglichen Golang WebSocket-Anwendungen Benutzern nicht, E / A-Puffer zwischen Verbindungen erneut zu verwenden.

2. Gorilla

In dem Gorilla Web ToolkitDas WebSocket-Paket bietet eine untersuchte und vollständige Anwendung des WebSocket-Protokolls und eine konsistente Paket-API.

Dieses WebSocket-Paket ist einfach zu verwenden und ordnungsgemäß dokumentiert. Die Dokumentation finden Sie auf der offiziellen Website von Gorilla.

3. GOBWAS

Dies ist ein kleines WebSocket-Paket, das eine umfangreiche Liste von Funktionen enthält, z. B. eine Low-Level-API, mit der die Logik der benutzerdefinierten Paketverarbeitung und eines Upgrades ohne Kopie entwickelt werden kann. GOBWAS benötigt während der E / A keine Zwischenzuweisungen.

Darüber hinaus enthält das WsUtil-Paket hochrangige Helfer und Wrapper rund um die API, sodass Entwickler schnell beginnen können, ohne die Interna des Protokolls zu untersuchen.

Obwohl diese Bibliothek aus einer flexiblen API besteht, geht dies zu Lasten der Klarheit und Benutzerfreundlichkeit. Die Dokumentation finden Sie auf der GoDoc-Website.

4. GOWebsockets

Dieses Golang-Tool bietet eine umfangreiche Auswahl an benutzerfreundlichen Funktionen. Es ermöglicht das Festlegen von Anforderungsheadern, das Komprimieren von Daten und das Steuern der Parallelität. Es unterstützt Proxys und Unterprotokolle beim Übertragen und Abrufen von Binärdaten und Text.

Darüber hinaus können Entwickler die SSL-Überprüfung entweder aktivieren oder deaktivieren. Die Dokumentation und Beispiele für die Verwendung von GOWebsockets finden Sie auf der GoDoc-Website.

Einpacken

In diesem Tutorial wurden einige der Grundlagen von WebSockets und die Entwicklung einer einfachen WebSocket-basierten App in den besten Golang-Tools behandelt. Neben den oben genannten Tools ermöglichen einige andere alternative Anwendungen Entwicklern die Entwicklung starker Streaming-Lösungen.

Dazu gehören Package rpc, gRPC, Apache Thrift und go-socket.io. Die Verfügbarkeit ordnungsgemäß dokumentierter Tools wie WebSockets und die kontinuierliche Weiterentwicklung der Streaming-Technologie erleichtern Entwicklern das Erstellen von Echtzeit-Apps.

Similar Posts

Leave a Reply