Effiziente WebSocket-Implementierung in Golang für Echtzeit-Apps

Das Senden einer Nachricht und das Erhalten einer sofortigen Antwort, ohne die Seite neu zu laden, ist etwas, das wir selbstverständlich nehmen. In der Vergangenheit war die Bereitstellung von Echtzeitfunktionalität jedoch eine echte Herausforderung für Entwickler. Die Entwicklergemeinschaft hat von HTTP-Long-Polling und AJAX einen großen Schritt gemacht und hat endlich eine Lösung gefunden, um wirklich Echtzeit-Apps zu entwickeln.

Diese Lösung kommt in Form von WebSockets, die es ermöglichen, eine interaktive Sitzung zwischen dem Browser eines Benutzers und einem Server zu öffnen. Golang WebSockets ermöglichen es einem Browser, Nachrichten an einen Server zu senden und eventgesteuerte Antworten zu empfangen, ohne dass der Server nach einer Antwort nachgefragt werden muss.

Bislang sind WebSockets die erste Wahl für die Entwicklung von Echtzeit-Anwendungen: Online-Spiele, Instant-Messenger, Tracking-Apps usw. In diesem Leitfaden wird erläutert, wie Go WebSockets funktionieren und wie man WebSocket-Anwendungen in der Programmiersprache Go erstellt. Außerdem werden die beliebtesten WebSocket-Bibliotheken verglichen, damit Sie die beste für Ihre Bedürfnisse auswählen können.

Um herauszufinden, wie man mit WebSockets in GO beginnt, beginnen wir damit, die Unterscheidung zwischen Netzwerk-Sockets und WebSockets zu treffen.

Netzwerkbuchse

Ein Netzwerkanschluss, oder einfach nur ein Anschluss, dient als internes Endpunkt für den Datenaustausch zwischen Anwendungen, die auf demselben Computer oder auf verschiedenen Computern im selben Netzwerk laufen.

Sockets sind ein wesentlicher Bestandteil von Unix- und Windows-basierten Betriebssystemen und erleichtern es Entwicklern, Netzwerksoftware zu erstellen. Anstatt Netzwerkverbindungen von Grund auf zu erstellen, können App-Entwickler Sockets in ihre Programme einbauen. Da NetzwerkSockets für mehrere Netzwerkprotokolle (HTTP, FTP usw.) verwendet werden, können mehrere Sockets gleichzeitig verwendet werden.

Sockets werden erstellt und verwendet, indem eine Reihe von Funktionsaufrufen verwendet wird, die durch die API (Application Programming Interface) der Socket-Anwendung definiert sind.

Es gibt mehrere Arten von Netzwerkbuchsen:

1. Datagrammsockel (SOCK_DGRAM), auch bekannt als connectionless-Sockets, verwenden das User Datagram Protocol (UDP). Datagram-Sockets unterstützen einen bidirektionalen Nachrichtenfluss und bewahren die Protokollgrenzen bei.
2. Stream-Anschlüsse (SOCK_STREAM), auch bekannt als verbindungsorientierte Sockets, verwenden das Transmission Control Protocol (TCP), das Stream Control Transmission Protocol (SCTP) oder das Datagram Congestion Control Protocol (DCCP). Diese Sockets bieten einen bidirektionalen, zuverlässigen, sequenziellen und unduplizierten Datenfluss ohne Datensperrungen.
3. Roh-Steckverbinder (oder als reine IP-Sockets) sind diese normalerweise in Routern und anderen Netzwerkgeräten erhältlich. Diese Sockets sind normalerweise datagrammorientiert, obwohl ihre genauen Eigenschaften von der von dem Protokoll bereitgestellten Schnittstelle abhängen. Rohsockets werden von den meisten Anwendungen nicht verwendet. Sie dienen der Entwicklung neuer Kommunikationsprotokolle und der Bereitstellung des Zugangs zu spezielleren Funktionen bestehender Protokolle.

Socket-Kommunikation

Jede Netzwerkbuchse wird durch die Adresse identifiziert, die aus einem Transportprotokoll, einer IP-Adresse und einer Portnummer besteht.

Es gibt zwei Hauptprotokolle zur Kommunikation zwischen Hosts: TCP und UDP. Sehen wir uns an, wie Ihre App mit TCP- und UDP-Sockets verbinden kann.

• Anbindung an einen TCP-Socket

Um eine TCP-Verbindung herzustellen, verwendet ein Go-Client die Funktion DialTCP im Paket net. DialTCP gibt ein TCPConn-Objekt zurück. Wenn eine Verbindung hergestellt ist, beginnen der Client und der Server mit dem Austausch von Daten: Der Client sendet eine Anfrage an den Server über ein TCPConn-Objekt, der Server analysiert die Anfrage und sendet eine Antwort, und das TCPConn-Objekt erhält die Antwort vom Server.

Diese Verbindung bleibt gültig, bis der Client oder der Server sie schließt. Die Funktionen zur Erstellung einer Verbindung lauten wie folgt:

Klientside:

 // init
   tcpAddr, err := net.ResolveTCPAddr(resolver, serverAddr)
   wenn err != nil {
        // Fehlerhandhabung
   }
   conn, err := net.DialTCP(network, nil, tcpAddr)
   wenn err != nil {
           // Fehlerhandhabung
   }
   // Nachricht senden
    _, err = conn.Write {message}()
   wenn err != nil {
        // Fehlerhandhabung
   }
   // Nachricht empfangen
   var buf [{buffSize}]Byte
   _, err := conn.Read(buf[0:])
   wenn err != nil {
        // Fehlerhandhabung
   }

Serverseitig:

// init
   tcpAddr, err := net.ResolveTCPAddr(resolver, serverAddr)
       wenn err != nil {
           // Fehlerhandhabung
       }
   
       Listener, err := net.ListenTCP("tcp", tcpAddr)
    wenn err != nil {
        // Fehlerhandhabung
    }
    
    // auf eine eingehende Verbindung warten
    conn, err := listener.Accept()
    wenn err != nil {
        // Fehlerhandhabung
    }
    
    // Nachricht senden
    wenn _, err := conn.Write {message}(); err != nil {
        // Fehlerhandhabung
    }    
    // Nachricht empfangen
    buf := make([]byte, 512)
    n, err := conn.Read(buf[0:])
    wenn err != nil {
        // Fehlerhandhabung
    }

• Anbindung an einen UDP-Socket

Im Gegensatz zu einem TCP-Socket sendet der Client bei einem UDP-Socket einfach ein Datagramm an den Server. Es gibt keine Accept-Funktion, da der Server keine Verbindung akzeptieren muss und nur darauf wartet, dass Datagramme eintreffen.

Andere TCP-Funktionen haben UDP-Ähnlichkeiten; ersetzen Sie einfach TCP durch UDP in den obigen Funktionen.

Klientside:

// init
    raddr, err := net.ResolveUDPAddr("udp", Adresse)
    wenn err != nil {
        // Fehlerhandhabung
    }
       
    conn, err := net.DialUDP("udp", nil, raddr)
    wenn err != nil {
        // Fehlerhandhabung
    }
        ....... 
    // Nachricht senden
    buffer := make([]Byte, maxBufferSize)
    n, addr, err := conn.ReadFrom(buffer)
    wenn err != nil {
        // Fehlerhandhabung
    }
         .......            
    // Nachricht empfangen
    buffer := make([]Byte, maxBufferSize)
    n, err = conn.WriteTo(buffer[:n], addr)
    wenn err != nil {
        // Fehlerhandhabung
    }

Serverseitig:

    // init
    udpAddr, err := net.ResolveUDPAddr(resolver, serverAddr)
    wenn err != nil {
        // Fehlerhandhabung
    }
    
    conn, err := net.ListenUDP("udp", udpAddr)
    wenn err != nil {
        // Fehlerhandhabung
    }
        .......
    // Nachricht senden
    buffer := make([]Byte, maxBufferSize)
    n, addr, err := conn.ReadFromUDP(buffer)
    wenn err != nil {
        // Fehlerhandhabung
    }
         .......
    // Nachricht empfangen
    buffer := make([]Byte, maxBufferSize)
    n, err = conn.WriteToUDP(buffer[:n], addr)
    wenn err != nil {
        // Fehlerhandhabung
    }

Was sind WebSockets?

Das WebSocket-Kommunikationspaket bietet einen vollduplexen Kommunikationskanal über eine einzige TCP-Verbindung. Das bedeutet, dass sowohl der Client als auch der Server jederzeit Daten gleichzeitig senden können, wann immer sie dies benötigen, ohne dass eine Anfrage erforderlich ist.

WebSockets sind eine gute Lösung für Dienste, die eine kontinuierliche Datenübertragung erfordern – beispielsweise Instant-Messenger, Online-Spiele und Echtzeit-Handelssysteme. Um diese Anwendungen zu verbessern, Data Science als Dienstleistung Diese Daten können genutzt werden, um wertvolle Erkenntnisse aus den Streamingdaten zu gewinnen, die Entscheidungsprozesse zu verbessern und präventive Fähigkeiten basierend auf Echtzeitinformationen zu ermöglichen. Sie finden vollständige Informationen zum WebSocket-Protokoll in der Internet Engineering Task Force (IETF). RFC 6455-Spezifikation.

WebSocket-Verbindungen werden von Browsern angefordert und von den Servern beantwortet; anschließend wird eine Verbindung hergestellt. Dieser Vorgang wird oft als „connect()“ bezeichnet. Handshake. Die spezielle Art von Header in WebSockets erfordert nur eine Handshake-Verbindung zwischen Browser und Server, um eine Verbindung herzustellen, die während ihres gesamten Lebenszyklus aktiv bleibt.

Das WebSocket-Protokoll verwendet für eine unsichere Verbindung die Portnummer 80 und für eine sichere Verbindung die Portnummer 443. Das WebSocket Spezifikation Bestimmt, welche einheitlichen Ressourcenidentifikationssysteme für die Protokolle ws (WebSocket) und wss (WebSocket Secure) erforderlich sind.

WebSockets lösen viele der Probleme bei der Entwicklung real-time-fähiger Webanwendungen und haben Mehrere Vorteile gegenüber dem traditionellen HTTP:

• Der leichtere Header reduziert die Datenübertragungskosten.
• Für einen einzelnen Web-Client ist nur eine TCP-Verbindung erforderlich.
• WebSocket-Server können Daten an Web-Clients senden.

Das WebSocket-Protokoll ist relativ einfach zu implementieren. Es nutzt das HTTP-Protokoll für die erste Handshake-Phase. Nach einem erfolgreichen Handshake wird eine Verbindung hergestellt, und das WebSocket verwendet im Wesentlichen den reinen TCP-Protokoll für das Lesen und Schreiben von Daten.

So sieht ein Clientanforderung aus:

  GET /chat HTTP/1.1
    Moderator: server.example.com
    Aktualisierung: websocket
    Verbindung: Upgrade
    Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
    Sec-WebSocket-Protokoll: Chatten, superchat
    Sec-WebSocket-Version: 13
    Herkunft: http://example.com

Und hier ist die Antwort des Servers:

    HTTP/1.1 101 Umschalten Protokolle
    Aktualisierung: websocket
    Verbindung: Upgrade
    Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=
    Sec-WebSocket-Protokoll: Chat

Um die Vorteile von WebSocket für Softwareentwickler zu verstehen, lohnt es sich, sie mit HTTP zu vergleichen, dem grundlegenden Protokoll für die Kommunikation im Internet. Kurz gesagt, WebSocket bietet mehr Möglichkeiten, indem es den Kommunikationsprozess optimiert. Vergleichen wir die Verbindungsarten basierend auf WebSocket und HTTP im Detail.

WebSocket ist die Folge der Entwicklung der Verbindungsprotokolle. Sein Entstehen dient dazu, die Hindernisse zu überwinden, die Entwickler daran gehindert haben könnten, komplexere und benutzerfreundlichere Lösungen zu entwickeln.

Also, lassen Sie uns überprüfen, was für die Erstellung eines WebSocket in Golang erforderlich ist.

Um einen einfachen Go WebSocket-Echo-Server auf der Grundlage der net/http-Bibliothek zu schreiben, müssen Sie Folgendes tun:

1. Starten Sie eine Handschaukel
2. Datenrahmen vom Client empfangen
3. Datenrahmen an den Client senden
4. Schließen Sie den Handshake ab

Schritt 1: Handshake-Initiierung

Zunächst erstellen wir einen HTTP-Handler mit einem WebSocket-Endpunkt:

// HTTP-Server mit WebSocket-Endpunkt
        func Server() {
        http://"/", func(w http.ResponseWriter, r *http.Request) {
            ws, err := NewHandler(w, r)
            wenn err != nil {
                 // Fehlerhandhabung
            }
            wenn err = ws.Handshake(); err != nil {
                // Fehlerhandhabung
            }
        …

Dann initialisieren Sie die WebSocket-Struktur. 

Der erste Handschlag-Anfrage kommt immer vom Client. Nachdem der Server eine WebSocket-Anfrage definiert hat, muss er mit einer Handschlag-Antwort antworten. 

Bitte beachten Sie, dass Sie die Antwort nicht mit dem http.ResponseWriter schreiben können, da dieser die zugrunde liegende TCP-Verbindung schließt, sobald Sie mit dem Senden der Antwort beginnen. 

Daher müssen Sie HTTP-Hijacking verwenden. Mit HTTP-Hijacking können Sie die zugrunde liegende TCP-Verbindung und bufio.Writer übernehmen. Dadurch können Sie Daten lesen und schreiben, ohne die TCP-Verbindung zu schließen.

// NewHandler initialisiert einen neuen Handler
        func NewHandler(w http.ResponseWriter, req *http.Request) (*WS, Fehler) {
        hj, ok := w.(http.Hijacker)
        wenn !ok {
            // Fehlerhandhabung
        }                  .....
}

Um die Handshake-Abfolge abzuschließen, muss der Server mit den entsprechenden Headern antworten.

// Handshake erstellt einen Handshake-Header
    Funktion (ws *WS) Handshake() Fehler:
        
        hash := func(key) String) String {
            h := sha1.New()
            h.Write([]byte(key))
            h.Write([]byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))
        zurück base64.StdEncoding.EncodeToString(h.Sum(nil))
        }(ws.header.Get("Sec-WebSocket-Key"))
      .....
}

“Sec-WebSocket-Key” wird zufällig generiert und ist Base64-encoded. Der Server muss diese Schlüsselangabe nach der Annahme einer Anfrage an eine feste Zeichenkette anfügen. Angenommen, Sie besitzen die Schlüsselangabe x3JJHMbDL1EzLkh9GBhXDw==. In diesem Fall können Sie SHA-1 verwenden, um den Binärwert zu berechnen und ihn mithilfe von Base64 zu codieren. Sie erhalten HSmrc0sMlYUkAGmm5OPpG2HaGWk=. Verwenden Sie diese als Wert in der Antwortheader-Zeichenkette Sec-WebSocket-Accept.

Schritt 2: Übertragung des Datenrahmens

Nach erfolgreicher Handshake-Abwicklung kann Ihre App Daten sowohl von dem Client als auch an den Client lesen und schreiben. WebSocket-Spezifikation Definiert ein spezifisches Rahmenformat, das zwischen einem Client und einem Server verwendet wird. Hier ist das Bitmuster des Rahmens:

Verwenden Sie den folgenden Code, um die Client-Payload zu entschlüsseln: 

// Recv empfängt Daten und gibt einen Frame zurück
    func (ws *WS) Recv() (Frame Frame, _ error) {
        frame = Frame{}
        head, err := ws.read(2)
        wenn err != nil {
            // Fehlerhandhabung
        }

Diese Codezeilen ermöglichen wiederum die Kodierung von Daten: 

// Send sendet einen Frame
    Fehler bei der Funktion (ws *WS) Send(fr Frame):
        // Erstellen Sie eine Bytes-Slice mit der Länge 2
        data := make([]byte, 2)
    
        // Speichert Fragmentierung und Opcodeinformationen im ersten Byte
        data[0] = 0x80 |Fr.Opcode
        wenn fr.IsFragment {
            data[0] &= 0x7F
        }
        .....

Lesen Sie auch: Go vs. Rust: Welche Option soll man 2025 wählen?

Schritt 3: Abschluss einer Handshake-Szene

Ein Handshake wird geschlossen, wenn eine der Parteien einen Close Frame mit dem Status „close“ als Payload sendet. Optional kann die Partei, die den Close Frame sendet, in dem Payload einen Close Reason hinterlassen. Wenn das Schließen vom Client initiiert wird, sollte der Server als Antwort einen entsprechenden Close Frame senden.

// Close sendet einen Close-Frame und schließt die TCP-Verbindung.
Fehlermeldung für die Funktion (ws *Ws) Close():
f := Frame{}
f.Opcode = 8
f.Länge = 2
f.Payload = make([]byte, 2)
binary.BigEndian.PutUint16(f.Payload, ws.status)
Wenn err := ws.Send(f); err != nil {
Returnieren von err
}
ws.conn.Close() zurückgeben
}

Liste der WebSocket-Bibliotheken

Es gibt mehrere Drittanbieterbibliotheken, die die Arbeit mit WebSockets erleichtern und die Arbeit mit WebSocket-Technologien erheblich vereinfachen.

STDLIB (x/net/websocket)

Diese WebSocket-Bibliothek ist Teil der Standardbibliothek von Go. Sie implementiert einen Client und einen Server für das WebSocket-Protokoll, wie in der RFC 6455-Spezifikation beschrieben. Sie muss nicht installiert werden und hat gute offizielle Dokumentation. Auf der anderen Seite fehlt es dennoch an einigen Funktionen, die in anderen WebSocket-Bibliotheken zu finden sind. Golang WebSocket-Implementierungen im Paket /x/net/websocket ermöglichen es den Benutzern nicht, I/O-Buffers zwischen Verbindungen auf eine klare Weise wiederzuverwenden.

Lassen Sie uns prüfen, wie das STDLIB-Paket funktioniert. Hier ist ein Beispielcode für die Durchführung grundlegender Funktionen wie das Erstellen einer Verbindung sowie das Senden und Empfangen von Nachrichten.
Zunächst müssen Sie diese Bibliothek installieren und verwenden, indem Sie diese Codezeile hinzufügen:

Import "golang.org/x/net/websocket"

Klientside:

// Verbindungsaufbau
//schema kann ws:// oder wss:// sein
// host, port – WebSocket-Server
conn, err := websocket.Dial("{schema}://{host}{port}:", "", op.Origin)
Wenn err != nil {
// Fehlerhandhabung
}
defer conn.Close()
.......
// Nachricht senden
Falls err = websocket.JSON.Send(conn, {message}); err != nil {
// Fehlerhandhabung
}
.......
// Nachricht empfangen
// messageType initialisiert eine Art von Nachricht
message := messageType{}
Wenn err := websocket.JSON.Receive(conn, &message); err != nil {
// Fehlerhandhabung
}
.......

Serverseitig:

// WebSocket-Handler + Server initialisieren
mux := http.NewServeMux()
mux.Handle("/", websocket.Handler(func(conn *websocket.Conn) {
func() {
for {// tun etwas, empfangen, senden usw.).
}
}
.......
// Nachricht empfangen
// messageType initialisiert eine Art von Nachricht
message := messageType{}
Wenn err := websocket.JSON.Receive(conn, &message); err != nil {
// Fehlerhandhabung
}
.......
// Nachricht senden
Wenn err := websocket.JSON.Send(conn, message); err != nil {
// Fehlerhandhabung
}
........

GORILLA

Das WebSocket-Paket in der Gorilla Web Toolkit Das WebSocket-Paket verfügt über eine vollständige und getestete Implementierung des WebSocket-Protokolls sowie über eine stabile API. Das WebSocket-Paket ist gut dokumentiert und einfach zu bedienen. Sie können die Dokumentation auf der offiziellen Gorilla-Website finden.

Installation:

Gehen Sie auf github.com/gorilla/websocket.
Beispiele für Code
Klientside:
// init
// Schema – kann ws:// oder wss:// sein
// host, port – WebSocket-Server
u := url.URL{
Schema: {schema},
Moderator: {host}:{port},
Pfad: "/",
}
c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
Wenn err != nil {
// Fehlerhandhabung
}
.......
// Nachricht senden
err := c.WriteMessage(websocket.TextMessage, {message})
Wenn err != nil {
// Fehlerhandhabung
}
.......
// Nachricht empfangen
_, message, err := c.ReadMessage()
Wenn err != nil {
// Fehlerhandhabung
}
.......

Serverseitig:

// init
u := websocket.Upgrader{}
c, err := u.Upgrade(w, r, nil)
Wenn err != nil {
// Fehlerhandhabung
}
.......
// Nachricht empfangen
messageType, message, err := c.ReadMessage()
Wenn err != nil {
// Fehlerhandhabung
}
.......
// Nachricht senden
err = c.WriteMessage(messageType, {message})
Wenn err != nil {
// Fehlerhandhabung
}
.......

Lesen Sie auch: Für welche Projekte sollte man Go verwenden?

Gobwas

Dieses kleine WebSocket-Paket bietet eine umfangreiche Funktionalität, wie z. B. die Möglichkeit, ohne Kopien zu aktualisieren und eine API auf der niedrigen Ebene, die es ermöglicht, eigene Paketverarbeitungslogiken zu erstellen. Gobwas benötigt keine Zwischenzuweisungen beim I/O. Darüber hinaus bietet es hochgradige Umhüllungen und Hilfskontrollen für die API im Paket wsutil, sodass Entwickler schnell beginnen können, ohne sich mit den inneren Details des Protokolls auseinanderzusetzen. Diese Bibliothek verfügt über eine flexible API, die jedoch auf die Usability und Klarheit verzichtet.

Sie können die Dokumentation auf der GoDoc-Website einsehen. Sie können Gobwas installieren, indem Sie die folgende Codezeile einfügen:

Gehen Sie auf github.com/gobwas/ws.

Klientside:

// init
// Schema – kann ws oder wss sein
// Host, Port – WS-Server
conn, _, _, err := ws.DefaultDialer.Dial(ctx, {schema}://{host}:{port})
Wenn err != nil {
// Fehlerhandhabung
}
.......
// Nachricht senden
err = wsutil.WriteClientMessage(conn, ws.OpText, {message})
Wenn err != nil {
// Fehlerhandhabung
}

//.......
// Nachricht empfangen
msg, _, err := wsutil.ReadServerData(conn)
Wenn err != nil {
// Fehlerhandhabung
.......
}

Serverseitig:

// init
Listener, err := net.Listen("tcp", op.Port)
Wenn err != nil {
// Fehlerhandhabung
}
conn, err := listener.Accept()
Wenn err != nil {
// Fehlerhandhabung
}
upgrader := ws.Upgrader{}
Falls _, err = upgrader.Upgrade(conn); err != nil {
// Fehlerhandhabung
}
.......
// Nachricht empfangen
für {
Reader := wsutil.NewReader(conn, ws.StateServerSide)
_, err := reader.NextFrame()
Wenn err != nil {
// Fehlerhandhabung
}
Daten, Fehler: err := ioutil.ReadAll(reader)
Wenn err != nil {
// Fehlerhandhabung
}
.......
}
.......
// Nachricht senden
msg := "neues Server-Nachrichtensendeverfahren"
Wenn err := wsutil.WriteServerText(conn, {message}); err != nil {
// Fehlerhandhabung
}
.......

GOWebsockets

Dieses Tool bietet eine breite Palette an benutzerfreundlichen Funktionen. Es ermöglicht die Konkurrentenkontrolle, die Datenkomprimierung und die Festlegung von Anforderungshirten. GOWebsockets unterstützt Proxys und Subprotokolle zur Abgabe und Empfang von Text- und Binärdaten. Entwickler können außerdem die SSL-Verifizierung aktivieren oder deaktivieren.

Dokumentation und Beispiele für die Verwendung von GOWebsockets finden Sie auf der GoDoc-Website und auf der Projektseite. GitHub-Seite. Installieren Sie das Paket, indem Sie die folgende Codezeile hinzufügen:

Gehen Sie auf github.com/sacOO7/gowebsocket.

Klientside:

// init
// Schema – kann ws oder wss sein
// Host, Port – WS-Server
socket := gowebsocket.New({schema}://{host}{port}:)
socket.Connect()
.......
// Nachricht senden
socket.SendText {message}()
oder
socket.SendBinary {message}()
.......
// Nachricht empfangen
socket.OnTextMessage = Funktion (Message, Socket gowebsocket.Socket) {
// Hande erhielt die Nachricht
};
oder
socket.OnBinaryMessage = func(data [] byte, socket gowebsocket.Socket) {
// Hande erhielt die Nachricht
};
.......

Serverseitig:

// init
// Schema – kann ws oder wss sein
// Host, Port – WS-Server
conn, _, _, err := ws.DefaultDialer.Dial(ctx, {schema}://{host}:{port})
Wenn err != nil {
// Fehlerhandhabung
}
.......
// Nachricht senden
err = wsutil.WriteClientMessage(conn, ws.OpText, {message})
Wenn err != nil {
// Fehlerhandhabung
}
.......
// Nachricht empfangen
msg, _, err := wsutil.ReadServerData(conn)
Wenn err != nil {
// Fehlerhandhabung
}

Vergleich von WebSocket-Bibliotheken

Wir haben vier der am häufigsten verwendeten WebSocket-Bibliotheken für Golang beschrieben. In der folgenden Tabelle ist eine detaillierte Vergleichsarbeit dieser Tools enthalten.

Um ihre Leistung besser analysieren zu können, haben wir außerdem ein paar Benchmarks durchgeführt.

Lesen Sie auch: Die Leistung Ihrer Go-Anwendung überwachen: Warum und wie Sie dies tun sollten

Die Ergebnisse lauten wie folgt:

Lesen Sie auch: Beste Praktiken zur Beschleunigung der JSON-Encoding und -Decoding in Go

• Wie Sie sehen können, hat Gobwas einen erheblichen Vorteil gegenüber anderen Bibliotheken. Es weist weniger Allokationen pro Operation auf und verbraucht pro Allokation weniger Speicher und weniger Zeit. Außerdem weist es keine I/O-Allokationen auf. Außerdem verfügt Gobwas über alle Methoden, die Sie benötigen, um WebSocket-Client-Server-Interaktionen zu erstellen und Nachrichtenteilchen zu empfangen. Sie können es außerdem verwenden, um TCP-Sockets einfach zu verwalten.
• Wenn Sie Gobwas wirklich nicht mögen, können Sie Gorilla verwenden. Es ist ziemlich einfach und bietet fast alle gleichen Funktionen. Sie können auch STDLIB verwenden, aber in der Produktion ist es nicht so gut, da es viele notwendige Funktionen fehlt und, wie Sie in den Benchmarks sehen können, eine schwächere Leistung bietet. GOWebsocket ähnelt STDLIB ziemlich. Aber wenn Sie schnell ein Prototyp oder MVP erstellen müssen, kann dies eine vernünftige Wahl sein.

Neben diesen Tools gibt es auch mehrere alternative Implementierungen, mit denen Sie leistungsstarke Streaming-Lösungen erstellen können. Zu diesen gehören:

• go-socket.io
• Apache Thrift 
• gRPC
• Paket rpc

Die kontinuierliche Entwicklung von Streaming-Technologien und die Verfügbarkeit gut dokumentierter Tools wie WebSockets machen es Entwicklern leicht, wirklich realzeitige Anwendungen zu erstellen. Schreiben Sie uns Wenn Sie Rat benötigen oder Hilfe bei der Entwicklung einer Echtzeit-App mit WebSockets benötigen, hoffen wir, dass Ihnen dieser Tutorial sehr geholfen hat.