Golang Websocket

In diesem Artikel zeigen wir Ihnen, wie Sie eine grundlegende Web -Socket in Go erstellen können. Wir werden einen einfachen Server erstellen, der wiederholt, was Sie sagen. Dies wird Ihnen helfen, Sie in die Welt von Websocket und das Gorilla Websocket -Paket vorzustellen.

Erforderliche Importe

Das erste, was zu tun ist, ist, die erforderlichen Pakete zu importieren. Für dieses Projekt benötigen wir das FMT -Paket, Net/HTTP und das Gorilla -Paket.

Wir können diese Importe als:

importieren (
"fmt"
"net/http"
"Github.com/gorilla/webocket "
)

Nach dem Import können wir mit dem Erstellen unseres Servers beginnen.

Aktualisieren Sie die HTTP -Verbindung

Der erste Schritt in unserem Projekt besteht darin, eine HTTP -Verbindung herzustellen und sie auf ein WebSocket zu aktualisieren . Wir können dies mit dem WebSocket tun.Upgrade -Struktur. Es wird im Quellcode unten gelesen und geschrieben Puffergröße wie definiert:

https: // pkg.gehen.dev/github.Com/Gorilla/Websocket#Upgrader

In unserem Beispiel werden wir die Standardoptionen verwenden, den Checkorigin auf eine Funktion einstellen, die true zurückgibt. Dies verhindert, dass der Server die Verbindung aufgrund von CORs blockiert.

var upgracer = webocket.Upgrader
Checkorigin: Func (r *http.Anfrage) bool
RECHT WAHR
,

Handler hinzufügen

Lassen Sie uns als Nächst. Wir werden später in der Hauptfunktion definieren.

Func Echo (W HTTP.Antwortschreiber, r *http.Anfrage)
Conn, ERR: = Upgrader.Upgrade (W, R, Nil)
ISTERR != nil
Protokoll.Tödlich (arr)
zurückkehren

Verschiebung Conn.Schließen()
für
MT, Nachricht, ERR: = conn.Lies die Nachricht()
ISTERR != nil
Protokoll.Tödlich (arr)
brechen

fmt.Printf ("recv: %s", Nachricht)
err = conn.WriteMessage (MT, Nachricht)
ISTERR != nil
Protokoll.Tödlich (arr)
brechen

Im obigen Beispiel definieren wir eine Funktion, die den Antwortschreiber und einen Zeiger auf die HTTP bringt.Antwort.

Wir die Upgrade der HTTP -Verbindung mit der Upgrader -Funktion auf das WebSocket -Protokoll aufrüsten. Als nächstes verwenden wir eine für Schleife, um eingehende Nachrichten anzuhören und zu lesen. Anschließend drucken wir die Nachricht an die Konsole und stellt die Nachricht an den Client zurück.

Fügen Sie WebSocket -Endpunkt hinzu

Der nächste Schritt besteht darin, einen einfachen HTTP -Handler für den WebSocket -Endpunkt hinzuzufügen. Wir können die Funktion als:

Func Home (W HTTP.Antwortschreiber, r *http.Anfrage)
Websockettemplate.Ausführen (w, "WS: //"+r.Host+"/echo")

Client erstellen

Um mit dem WebSocket -Aufschlag zu interagieren, müssen wir einen Kunden erstellen. Wir können dies tun, indem wir eine einfache HTML -Datei von JavaScript erstellen, um eine WebSocket -Verbindung zum Server zu öffnen. Ein Beispielcode ist wie gezeigt:

Index.html






Einfache Websocket -Verbindung



Schicken

const input = dokument.getElementById ("Eingabe");
const output = dokument.getElementById ("output");
const socket = new WebSocket ("WS: // localhost: 8000/echo");
Steckdose.onopen = function ()
Ausgang.Innerhtml += "Status: verbunden \ n";
;
Steckdose.OnMessage = Funktion (e)
Ausgang.Innerhtml + = "Server:" + e.Daten + "\ n";
;
functionSend ()
Steckdose.Senden (Eingabe.Wert);
Eingang.value = "";

Server ausführen

Der letzte Schritt besteht darin, die Routen zu definieren und die HTTP -Handler in der Hauptfunktion aufzurufen. Der Code ist wie gezeigt:

funcmain ()
http.Handlefunc ("/echo", echo)
http.Handlefunc ("/", zu Hause)
http.Hörenserve (": 8000", nil)

Speichern Sie die Dateien und führen Sie aus:

Geh renn ws.gehen

Öffnen Sie den Index.HTML -Datei in Ihrem Browser. Sie sollten eine verbundene Nachricht sehen, sobald der Browser eine Verbindung herstellt.

Wenn Sie eine Nachricht in das Feld eingeben, antwortet der Server sie zurück.

Der vollständige Quellcode des Programms ist wie gezeigt:

Paket Main
importieren (
"fmt"
"Protokoll"
"net/http"
"Github.com/gorilla/webocket "
)
var upgracer = webocket.Upgrader
Checkorigin: Func (r *http.Anfrage) bool
RECHT WAHR
,

Funcecho (W Http.Antwortschreiber, r *http.Anfrage)
Conn, ERR: = Upgrader.Upgrade (W, R, Nil)
Wenn er irrt != nil
Protokoll.Tödlich (arr)
zurückkehren

DeferConn.Schließen()
für
MT, Nachricht, ERR: = conn.Lies die Nachricht()
Wenn er irrt != nil
Protokoll.Tödlich (arr)
brechen

fmt.Printf ("recv: %s", Nachricht)
err = conn.WriteMessage (MT, Nachricht)
Wenn er irrt != nil
Protokoll.Tödlich (arr)
brechen



Funchome (W Http.Antwortschreiber, r *http.Anfrage)
http.Serve file (W, r, "Index.html ")

funcmain ()
http.Handlefunc ("/echo", echo)
http.Handlefunc ("/", zu Hause)
http.Hörenserve (": 8000", nil)

Abschluss

Dies war ein Anfänger für die Arbeit mit WebSocket in Go. In diesem Handbuch haben wir behandelt, wie Sie eine HTTP -Verbindung auf das WebSocket -Protokoll aktualisieren, Nachrichten lesen und Nachrichten an den Client zurückführen.