Golang WebSocket

In questo articolo, ti mostreremo come creare una presa web di base in GO. Costruiremo un semplice server che ripete ciò che dici. Questo ti aiuterà a presentarti al mondo di WebSocket e al pacchetto Gorilla WebSocket.

Importazioni richieste

La prima cosa da fare è importare i pacchetti richiesti. Per questo progetto, avremo bisogno del pacchetto FMT, Net/HTTP e il pacchetto Gorilla.

Possiamo fare queste importazioni come:

importazione (
"FMT"
"net/http"
"Github.com/gorilla/websocket "
)

Una volta importato, possiamo iniziare a costruire il nostro server.

Aggiorna la connessione HTTP

Il primo passo nel nostro progetto è prendere una connessione HTTP e aggiornarla a un WebSocket . Possiamo farlo usando il websocket.Aggiornamento struct. Prende la dimensione del buffer di lettura e scrittura come definito nel codice sorgente seguente:

https: // pkg.andare.dev/github.com/gorilla/websocket#aggiornatore

Per il nostro esempio, utilizzeremo le opzioni predefinite ma imposteremo il checkorigin su una funzione che restituisce vero. Ciò impedirà al server di bloccare la connessione a causa delle cors.

var upgrader = WebSocket.Aggiornatore
Checkorigin: func (r *http.Richiesta) bool
restituire vero
,

Aggiungi gestore

Quindi, lasciaci un gestore HTTP quando un client colpisce l'endpoint /echo. Definiremo più avanti nella funzione principale.

func echo (w http.Responsewriter, r *http.Richiesta)
Conn, err: = aggiornatore.Aggiornamento (W, R, NIL)
iferr != nil
tronco d'albero.Fatale (err)
ritorno

Defer Conn.Vicino()
per
MT, messaggio, err: = Conn.ReadMessage ()
iferr != nil
tronco d'albero.Fatale (err)
rottura

fmt.Printf ("recv: %s", messaggio)
err = Conn.WriteMessage (MT, messaggio)
iferr != nil
tronco d'albero.Fatale (err)
rottura

Nell'esempio sopra, definiamo una funzione che porta la risposta di risposta e un puntatore a HTTP.Risposta.

Aggiorniamo la connessione HTTP al protocollo WebSocket utilizzando la funzione Aggiornatore. Successivamente, utilizziamo un ciclo per ascoltare e leggere i messaggi in arrivo. Quindi stampiamo il messaggio sulla console e riecheggiamo il messaggio al client.

Aggiungi Endpoint WebSocket

Il prossimo passo è aggiungere un semplice gestore HTTP per l'endpoint websocket. Possiamo usare la funzione come:

Func Home (W http.Responsewriter, r *http.Richiesta)
WebSockettemplate.Eseguire (w, "ws: //"+r.Host+"/echo")

Crea client

Per interagire con il servizio WebSocket, dobbiamo creare un client. Possiamo farlo creando un semplice file HTML da che utilizza JavaScript per aprire una connessione WebSocket al server. Un codice di esempio è come mostrato:

indice.html






Connessione WebSocket semplice



Inviare

const input = document.getElementById ("input");
const output = documento.getElementById ("output");
const socket = new WebSocket ("ws: // localhost: 8000/echo");
PRESA.onopen = function ()
produzione.InnerHtml += "Stato: connesso \ n";
;
PRESA.onmessage = function (e)
produzione.InnerHtml + = "Server:" + E.dati + "\ n";
;
functionSend ()
PRESA.Invia (input.valore);
ingresso.value = "";

Esegui server

L'ultimo passo è definire i percorsi e chiamare i gestori HTTP nella funzione principale. Il codice è come mostrato:

funcmain ()
http.Handlefunc ("/echo", eco)
http.Handlefunc ("/", casa)
http.Ascolta

Salva i file ed esegui:

Vai a correre WS.andare

Apri l'indice.file html nel browser. Dovresti vedere un messaggio connesso una volta che il browser stabilisce una connessione.

Se si digita un messaggio nel campo, il server lo risponde.

Il codice sorgente completo del programma è come mostrato:

Pacchetto principale
importazione (
"FMT"
"tronco d'albero"
"net/http"
"Github.com/gorilla/websocket "
)
var upgrader = WebSocket.Aggiornatore
Checkorigin: func (r *http.Richiesta) bool
restituire vero
,

funcecho (w http.Responsewriter, r *http.Richiesta)
Conn, err: = aggiornatore.Aggiornamento (W, R, NIL)
Se err != nil
tronco d'albero.Fatale (err)
ritorno

DeferConn.Vicino()
per
MT, messaggio, err: = Conn.ReadMessage ()
Se err != nil
tronco d'albero.Fatale (err)
rottura

fmt.Printf ("recv: %s", messaggio)
err = Conn.WriteMessage (MT, messaggio)
Se err != nil
tronco d'albero.Fatale (err)
rottura



Funchome (w http.Responsewriter, r *http.Richiesta)
http.Servefile (w, r, "indice.html ")

funcmain ()
http.Handlefunc ("/echo", eco)
http.Handlefunc ("/", casa)
http.Ascolta

Conclusione

Questa era una guida per principianti per lavorare con WebSocket in Go. In questa guida, abbiamo trattato come aggiornare una connessione HTTP al protocollo WebSocket, leggere i messaggi e rispondere ai messaggi al client.