Golang WebSocket

Neste artigo, mostraremos como criar um soquete básico da web em Go. Vamos construir um servidor simples que repete de volta o que você diz. Isso ajudará a apresentá -lo ao mundo do WebSocket e do pacote Gorilla Websocket.

Importações necessárias

A primeira coisa a fazer é importar os pacotes necessários. Para este projeto, precisaremos do pacote FMT, NET/HTTP e o pacote Gorilla.

Podemos fazer essas importações como:

importação (
"FMT"
"net/http"
"Github.com/gorila/webSocket "
)

Uma vez importado, podemos começar a construir nosso servidor.

Atualize a conexão HTTP

O primeiro passo em nosso projeto é levar uma conexão HTTP e atualizá -la para um WebSocket . Podemos fazer isso usando o websocket.Upgrade Struct. Ele leva o tamanho do buffer de leitura e gravação, conforme definido no código -fonte abaixo:

https: // pkg.ir.Dev/Github.com/gorilla/webSocket#Uprader

Para o nosso exemplo, usaremos as opções padrão, mas definiremos o checkorigin como uma função que retorna true. Isso impedirá que o servidor bloqueie a conexão devido a CORS.

VAR Upgrader = WebSocket.Atualizador
Checkorigin: func (r *http.Solicitação) bool
retornar verdadeiro
,

Adicione o manipulador

Em seguida, deixe -nos um manipulador HTTP quando um cliente atingir o fim de extremidade /eco. Vamos definir mais adiante na função principal.

func eco (w http.ResponseWriter, r *http.Solicitar)
Conn, Err: = Upgrador.Upgrade (W, R, Nil)
iferr != nil
registro.Fatal (ERR)
retornar

adiar conn.Fechar()
para
mt, mensagem, err: = Conn.Leia a mensagem()
iferr != nil
registro.Fatal (ERR)
quebrar

fmt.Printf ("recv: %s", mensagem)
err = conn.WriteMessage (MT, mensagem)
iferr != nil
registro.Fatal (ERR)
quebrar

No exemplo acima, definimos uma função que leva o responsável pela resposta e um ponteiro para o HTTP.Resposta.

Nós atualizamos a conexão HTTP com o protocolo WebSocket usando a função de atualizador. Em seguida, usamos um loop para ouvir e ler mensagens de entrada. Em seguida, imprimimos a mensagem para o console e ecoarmos a mensagem de volta ao cliente.

Adicione o WebSocket Endpoint

O próximo passo é adicionar um manipulador HTTP simples para o WebSocket Endpoint. Podemos usar a função como:

Func Home (W HTTP.ResponseWriter, r *http.Solicitar)
WebSockettemplate.Executar (W, "ws: //"+r.Host+"/eco")

Criar cliente

Para interagir com o serviço WebSocket, precisamos criar um cliente. Podemos fazer isso criando um arquivo html simples a partir que usa JavaScript para abrir uma conexão WebSocket com o servidor. Um código de exemplo é como mostrado:

índice.html






Conexão simples do WebSocket



Enviar

const input = document.getElementById ("entrada");
const Output = Documento.getElementById ("saída");
const soket = new websocket ("ws: // localhost: 8000/echo");
soquete.ONOPEN = function ()
saída.inerhtml += "Status: conectado \ n";
;
soquete.onMessage = function (e)
saída.INNERHTML + = "servidor:" + e.dados + "\ n";
;
FUNCTIONSEND ()
soquete.Enviar (entrada.valor);
entrada.value = "";

Executar servidor

O último passo é definir as rotas e chamar os manipuladores HTTP na função principal. O código é como mostrado:

funcmain ()
http.Handlefunc ("/echo", eco)
http.Handlefunc ("/", casa)
http.ListenAndServe (": 8000", nil)

Salve os arquivos e execute:

vá correr ws.ir

Abra o índice.arquivo html em seu navegador. Você deve ver uma mensagem conectada assim que o navegador estabelecer uma conexão.

Se você digitar alguma mensagem no campo, o servidor o responderá de volta.

O código -fonte completo do programa é como mostrado:

Pacote principal
importação (
"FMT"
"registro"
"net/http"
"Github.com/gorila/webSocket "
)
VAR Upgrader = WebSocket.Atualizador
Checkorigin: func (r *http.Solicitação) bool
retornar verdadeiro
,

funcecho (w http.ResponseWriter, r *http.Solicitar)
Conn, Err: = Upgrador.Upgrade (W, R, Nil)
se err != nil
registro.Fatal (ERR)
retornar

deferconn.Fechar()
para
mt, mensagem, err: = Conn.Leia a mensagem()
se err != nil
registro.Fatal (ERR)
quebrar

fmt.Printf ("recv: %s", mensagem)
err = conn.WriteMessage (MT, mensagem)
se err != nil
registro.Fatal (ERR)
quebrar



Funchome (W HTTP.ResponseWriter, r *http.Solicitar)
http.Sertfile (w, r, "índice.html ")

funcmain ()
http.Handlefunc ("/echo", eco)
http.Handlefunc ("/", casa)
http.ListenAndServe (": 8000", nil)

Conclusão

Este foi um guia para iniciantes para trabalhar com WebSocket em Go. Neste guia, abordamos como atualizar uma conexão HTTP com o WebSocket Protocol, lemos mensagens e responde às mensagens de volta ao cliente.