Biblioteca WebSocket Gorilla para Go | Guia

Biblioteca Gorilla WebSocket para Go (Golang)

Gorilla WebSocket é uma das bibliotecas mais populares e estáveis para trabalhar com o protocolo WebSocket na linguagem Go (Golang). Ela faz parte do ecossistema Gorilla Toolkit e fornece aos desenvolvedores uma ferramenta poderosa, flexível e de alto desempenho para criar aplicações em tempo real: chats, notificações em tempo real, jogos online, painéis de monitoramento e muito mais.

A biblioteca implementa completamente a especificação RFC 6455, suporta tanto o lado do servidor quanto do cliente, e lida automaticamente com fragmentação de mensagens, mecanismos de ping/pong e controle de conexão. Gorilla WebSocket é escrita em Go puro, sem dependências externas, o que a torna leve e rápida.

Principais recursos

Suporte completo ao protocolo WebSocket (RFC 6455).
API simples e intuitiva.
Suporte a mensagens de texto e binárias.
Gerenciamento automático de ping/pong para manter a conexão.
Possibilidade de verificar a origem da solicitação (Origin).
Suporte à compressão de mensagens (permessage-deflate).
Funciona com TLS/HTTPS.
Alto desempenho e baixo consumo de memória.

Instalação

Para instalar a biblioteca, execute o comando:

go get github.com/gorilla/websocket

Depois disso, importe o pacote no seu código:

import "github.com/gorilla/websocket"

Exemplo de servidor WebSocket em Go

Abaixo está um servidor simples que aceita conexões WebSocket e envia de volta as mensagens recebidas (servidor eco):

package main

import (    "fmt"    "log"    "net/http"

    "github.com/gorilla/websocket")

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // Permite todas as origens (para desenvolvimento)    },}

func echoHandler(w http.ResponseWriter, r *http.Request) {    // Estabelece a conexão WebSocket    conn, err := upgrader.Upgrade(w, r, nil)    if err != nil {        log.Print("Erro no upgrade:", err)        return    }    defer conn.Close()

    // Loop infinito de leitura de mensagens    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Erro de leitura:", err)            break        }        log.Printf("Mensagem recebida: %s", message)

        // Envia a mensagem de volta        err = conn.WriteMessage(messageType, message)        if err != nil {            log.Println("Erro de escrita:", err)            break        }    }}

func main() {    http.HandleFunc("/echo", echoHandler)    fmt.Println("Servidor iniciado na porta :8080")    log.Fatal(http.ListenAndServe(":8080", nil))}

Cliente WebSocket em Go

Exemplo de um cliente simples que se conecta ao servidor e envia uma mensagem:

package main

import (    "fmt"    "log"    "net/url"

    "github.com/gorilla/websocket")

func main() {    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/echo"}    fmt.Printf("Conectando a %s", u.String())

    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)    if err != nil {        log.Fatal("Erro de conexão:", err)    }    defer conn.Close()

    // Envia uma mensagem de texto    err = conn.WriteMessage(websocket.TextMessage, []byte("Olá, WebSocket!"))    if err != nil {        log.Fatal("Erro ao enviar:", err)    }

    // Lê a resposta    _, message, err := conn.ReadMessage()    if err != nil {        log.Fatal("Erro de leitura:", err)    }    fmt.Printf("Resposta recebida: %s", message)}