Golang WebSocket

I denne artikkelen vil vi vise deg hvordan du oppretter en grunnleggende nettkontakt i Go. Vi vil bygge en enkel server som gjentar tilbake det du sier. Dette vil bidra til å introdusere deg for Websockets verden og Gorilla WebSocket -pakken.

Påkrevd import

Den første tingen å gjøre er å importere de nødvendige pakkene. For dette prosjektet trenger vi FMT -pakken, Net/HTTP og Gorilla -pakken.

Vi kan gjøre denne importen som:

import (
"FMT"
"Nett/http"
"Github.com/gorilla/websocket "
)

Når vi er importert, kan vi begynne å bygge serveren vår.

Oppgrader HTTP -tilkobling

Det første trinnet i prosjektet vårt er å ta en HTTP -tilkobling og oppgradere det til en websocket . Vi kan gjøre dette ved hjelp av websocket.Oppgradert struktur. Det tar les og skriver bufferstørrelse som definert i kildekoden nedenfor:

https: // pkg.gå.dev/github.com/gorilla/websocket#oppgradering

For vårt eksempel vil vi bruke standardalternativene, men angi sjekkorigin til en funksjon som returnerer sann. Dette vil forhindre at serveren blokkerer forbindelsen på grunn av CORS.

var oppgradering = websocket.Oppgradering
Checkorigin: func (r *http.Forespørsel) bool
Returner sann
,

Legg til behandler

Neste, la oss en HTTP -handler når en klient treffer /ekko endepunktet. Vi vil definere senere i hovedfunksjonen.

func ekko (w http.ResponseWriter, R *http.Be om)
Conn, feil: = oppgradering.Oppgradering (W, R, NIL)
iferr != nil
Logg.Fatal (feil)
komme tilbake

utsett Conn.Lukk()
for
MT, melding, feil: = conn.ReadMessage ()
iferr != nil
Logg.Fatal (feil)
gå i stykker

fmt.Printf ("recv: %s", melding)
err = conn.Writemessage (MT, melding)
iferr != nil
Logg.Fatal (feil)
gå i stykker

I eksemplet ovenfor definerer vi en funksjon som tar responsforfatteren og en peker til HTTP.Respons.

Vi oppgraderer HTTP -forbindelsen til WebSocket -protokollen ved å bruke oppgraderingsfunksjonen. Deretter bruker vi en for loop for å lytte og lese innkommende meldinger. Vi skriver deretter ut meldingen til konsollen og gjenspeiler meldingen tilbake til klienten.

Legg til endepunkt for websocket

Neste trinn er å legge til en enkel HTTP -behandler for endepunktet for websocket. Vi kan bruke funksjonen som:

func hjem (w http.ResponseWriter, R *http.Be om)
WebSockettemplate.Utfør (w, "ws: //"+r.Vert+"/ekko")

Opprett klient

For å samhandle med websocket -serveringen, må vi opprette en klient. Vi kan gjøre dette ved å lage en enkel HTML -fil fra som bruker JavaScript for å åpne en websocket -tilkobling til serveren. Et eksempelkode er som vist:

indeks.html






Enkel WebSocket -tilkobling



Sende

const input = dokument.getElementById ("input");
const output = dokument.getElementById ("output");
const socket = new WebSocket ("ws: // localhost: 8000/ekko");
stikkontakt.onopen = funksjon ()
produksjon.indrehtml += "Status: tilkoblet \ n";
;
stikkontakt.onMessage = funksjon (e)
produksjon.indrehtml + = "server:" + e.data + "\ n";
;
funksjonsend ()
stikkontakt.Send (input.verdi);
inngang.verdi = "";

Kjør server

Det siste trinnet er å definere rutene og ringe HTTP -håndtererne i hovedfunksjonen. Koden er som vist:

FUNCMAIN ()
http.HandleFunc ("/Echo", Echo)
http.HandleFunc ("/", hjem)
http.ListenandServe (": 8000", null)

Lagre filene og kjør:

gå løp ws.gå

Åpne indeksen.HTML -fil i nettleseren din. Du bør se en tilkoblet melding når nettleseren etablerer en tilkobling.

Hvis du skriver inn en melding i feltet, svarer serveren den tilbake.

Full kildekode for programmet er som vist:

pakkehoved
import (
"FMT"
"Logg"
"Nett/http"
"Github.com/gorilla/websocket "
)
var oppgradering = websocket.Oppgradering
Checkorigin: func (r *http.Forespørsel) bool
Returner sann
,

funcecho (w http.ResponseWriter, R *http.Be om)
Conn, feil: = oppgradering.Oppgradering (W, R, NIL)
Hvis feil != nil
Logg.Fatal (feil)
komme tilbake

Deferconn.Lukk()
for
MT, melding, feil: = conn.ReadMessage ()
Hvis feil != nil
Logg.Fatal (feil)
gå i stykker

fmt.Printf ("recv: %s", melding)
err = conn.Writemessage (MT, melding)
Hvis feil != nil
Logg.Fatal (feil)
gå i stykker



Funchome (W http.ResponseWriter, R *http.Be om)
http.Serverfile (w, r, "indeks.html ")

FUNCMAIN ()
http.HandleFunc ("/Echo", Echo)
http.HandleFunc ("/", hjem)
http.ListenandServe (": 8000", null)

Konklusjon

Dette var en nybegynnerguide for å jobbe med WebSocket i Go. I denne guiden dekket vi hvordan du oppgraderer en HTTP -tilkobling til WebSocket -protokollen, leser meldinger og svarer meldinger tilbake til klienten.