Golang Websocket

En este artículo, le mostraremos cómo crear un socket web básico en Go. Construiremos un servidor simple que repita lo que dice. Esto ayudará a presentarle el mundo de WebSocket y el paquete Gorilla WebSocket.

Importaciones requeridas

Lo primero que debe hacer es importar los paquetes requeridos. Para este proyecto, necesitaremos el paquete FMT, NET/HTTP y el paquete Gorilla.

Podemos hacer estas importaciones como:

importar (
"FMT"
"net/http"
"Github.com/gorila/websocket "
)

Una vez importado, podemos comenzar a construir nuestro servidor.

Actualizar la conexión HTTP

El primer paso en nuestro proyecto es tomar una conexión HTTP y actualizarla a un WebSocket . Podemos hacer esto usando el WebSocket.Struct de actualización. Se necesita el tamaño del búfer de lectura y escritura como se define en el código fuente a continuación:

https: // pkg.ir.dev/github.com/gorila/websocket#actualizador

Para nuestro ejemplo, utilizaremos las opciones predeterminadas, pero establezcan el checkOrigin en una función que devuelve verdaderas. Esto evitará que el servidor bloquee la conexión debido a CORS.

VAR actualizador = websocket.Actualizador
Checkorigin: func (r *http.Solicitud) bool
Devolver verdadero
,

Handler Agregar

A continuación, permítanos un controlador HTTP cuando un cliente llegue al punto final /eco. Definiremos más adelante en la función principal.

Func Echo (w http.Responsewriter, r *http.Pedido)
Conn, err: = actualizador.Actualización (W, R, Nil)
zahrán != nulo
registro.Fatal (err)
devolver

diferir a Conn.Cerca()
para
mt, mensaje, err: = Conn.Leer el mensaje()
zahrán != nulo
registro.Fatal (err)
romper

fmt.Printf ("Recv: %s", mensaje)
ERR = Conn.WriteMessage (MT, mensaje)
zahrán != nulo
registro.Fatal (err)
romper

En el ejemplo anterior, definimos una función que toma el Responsewriter y un puntero al HTTP.Respuesta.

Actualizamos la conexión HTTP al protocolo WebSocket utilizando la función de actualización. A continuación, usamos un bucle for para escuchar y leer mensajes entrantes. Luego imprimimos el mensaje en la consola y hacemos eco del mensaje al cliente.

Agregar punto final de WebSocket

El siguiente paso es agregar un controlador HTTP simple para el punto final de WebSocket. Podemos usar la función como:

Func Home (w http.Responsewriter, r *http.Pedido)
WebSockettemplate.Ejecutar (w, "ws: //"+r.Host+"/echo")

Crear cliente

Para interactuar con el servicio de WebSocket, necesitamos crear un cliente. Podemos hacer esto creando un archivo HTML simple desde que usa JavaScript para abrir una conexión WebSocket al servidor. Un código de ejemplo es como se muestra:

índice.html






Conexión de WebSocket simple



Enviar

const entrada = documento.getElementById ("entrada");
ESTUCTURA DE CONST = Documento.getElementById ("salida");
const Socket = new WebSocket ("ws: // localhost: 8000/eco");
enchufe.onopen = function ()
producción.innerhtml += "estado: conectado \ n";
;
enchufe.onMessage = function (e)
producción.innerhtml + = "servidor:" + e.datos + "\ n";
;
functionsend ()
enchufe.enviar (entrada.valor);
aporte.valor = "";

Ejecutar servidor

El último paso es definir las rutas y llamar a los controladores HTTP en la función principal. El código es como se muestra:

funcmain ()
http.HandleFunc ("/Echo", Echo)
http.HandleFunc ("/", Inicio)
http.Listenandserve (": 8000", nulo)

Guarde los archivos y ejecute:

ir a correr ws.ir

Abra el índice.archivo html en su navegador. Debería ver un mensaje conectado una vez que el navegador establezca una conexión.

Si escribe cualquier mensaje en el campo, el servidor lo responde.

El código fuente completo del programa es como se muestra:

paquete principal
importar (
"FMT"
"registro"
"net/http"
"Github.com/gorila/websocket "
)
VAR actualizador = websocket.Actualizador
Checkorigin: func (r *http.Solicitud) bool
Devolver verdadero
,

FunceCho (w http.Responsewriter, r *http.Pedido)
Conn, err: = actualizador.Actualización (W, R, Nil)
Si err != nulo
registro.Fatal (err)
devolver

diferir.Cerca()
para
mt, mensaje, err: = Conn.Leer el mensaje()
Si err != nulo
registro.Fatal (err)
romper

fmt.Printf ("Recv: %s", mensaje)
ERR = Conn.WriteMessage (MT, mensaje)
Si err != nulo
registro.Fatal (err)
romper



Funchome (w http.Responsewriter, r *http.Pedido)
http.ServFile (W, R, "índice.html ")

funcmain ()
http.HandleFunc ("/Echo", Echo)
http.HandleFunc ("/", Inicio)
http.Listenandserve (": 8000", nulo)

Conclusión

Esta fue una guía para principiantes para trabajar con WebSocket en GO. En esta guía, cubrimos cómo actualizar una conexión HTTP al protocolo WebSocket, leer mensajes y responder mensajes al cliente.