Go Academy · Aula

Uso de gorilla/websocket

Atualize e gerencie conexões

Uso de gorilla/websocket é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

A biblioteca gorilla/websocket

gorilla/websocket é a biblioteca de WebSocket para Go mais usada. Ela gerencia o handshake de upgrade e fornece um objeto de conexão para ler e escrever quadros. Instale-a com go get github.com/gorilla/websocket.

import "github.com/gorilla/websocket"

O Upgrader

Um Upgrader transforma uma solicitação HTTP em uma conexão WebSocket. Você configura os tamanhos dos buffers e uma verificação de origem.

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

CheckOrigin e segurança

Por padrão, o Upgrader rejeita solicitações de origens diferentes. Durante o desenvolvimento, você pode relaxar essa regra, mas, em produção, valide o cabeçalho Origin para evitar o sequestro de WebSocket entre sites.

upgrader.CheckOrigin = func(r *http.Request) bool {
    return r.Header.Get("Origin") == "https://myapp.com"
}

Fazendo o upgrade em um Handler

Dentro de um http.HandlerFunc, chame Upgrade. Em caso de sucesso, você obtém um *websocket.Conn.

func wsHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        return
    }
    defer conn.Close()
    // read/write loop here
}

Lendo mensagens

ReadMessage bloqueia até a chegada de um quadro e retorna o tipo da mensagem e os bytes do conteúdo.

mt, data, err := conn.ReadMessage()
if err != nil {
    return // client closed or error
}
fmt.Printf("got %d bytes\n", len(data))
_ = mt

Escrevendo mensagens

WriteMessage envia um quadro de determinado tipo:

err := conn.WriteMessage(websocket.TextMessage, []byte("hello"))
if err != nil {
    return
}

O loop de eco

Um exemplo clássico lê uma mensagem e a escreve de volta. O loop termina quando Read retorna um erro (o cliente se desconectou).

for {
    mt, msg, err := conn.ReadMessage()
    if err != nil {
        break
    }
    conn.WriteMessage(mt, msg)
}

Auxiliares de JSON

A gorilla fornece ReadJSON e WriteJSON para serializar valores do Go diretamente pelo socket, o que é útil para mensagens estruturadas. O campo da estrutura Msg contém uma anotação json:"text" no código-fonte real.

type Msg struct {
    Text string // tag: json text
}
var m Msg
conn.ReadJSON(&m)
conn.WriteJSON(Msg{Text: "ack"})

Regra de um leitor e um escritor

Importante: uma única conexão permite apenas um leitor concorrente e um escritor concorrente. Se várias gorrotinas escreverem, proteja o acesso com um mutex ou direcione as escritas por meio de uma única gorrotina (abordado na transmissão).

Registrando a rota

Configure o manipulador como qualquer rota HTTP. Os clientes se conectam a ws://host/ws.

http.HandleFunc("/ws", wsHandler)
http.ListenAndServe(":8080", nil)

Executável: analogia de ida e volta com JSON

O código de WebSocket precisa da biblioteca externa; este trecho da biblioteca padrão reproduz o comportamento de ReadJSON/WriteJSON ao desserializar uma mensagem recebida em um mapa e serializar uma resposta.

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    in := []byte("{\"text\":\"ping\"}")
    var m map[string]string
    json.Unmarshal(in, &m)
    reply, _ := json.Marshal(map[string]string{"text": m["text"] + "-ack"})
    fmt.Println(string(reply))
}

Verificação rápida

Teste sua compreensão do uso de gorilla/websocket.

Recapitulação

Você aprendeu a usar gorilla/websocket:

Um Upgrader realiza o handshake; valide CheckOrigin
Upgrade produz um *websocket.Conn
Use ReadMessage/WriteMessage ou os auxiliares de JSON
Uma conexão permite um leitor e um escritor por vez

Perguntas Frequentes

A aula “Uso de gorilla/websocket” é grátis?

Sim — o texto completo de “Uso de gorilla/websocket” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Uso de gorilla/websocket”?

Atualize e gerencie conexões Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Uso de gorilla/websocket”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy