Zum Inhalt

Schnellstart-Anleitung

Diese Anleitung hilft Ihnen, den Socket.IO-Client für Go in weniger als 5 Minuten zu verwenden.

Installation

Erfordert Go 1.18 oder höher.

go get github.com/arcaela/socket.io-client-go

Ihre erste Verbindung

Erstellen Sie eine Datei main.go mit folgendem Code:

package main

import (
  "fmt"
  socketio "github.com/arcaela/socket.io-client-go"
)

func main() {
  // Client erstellen
  client := socketio.New("ws://localhost:3000")
  defer client.Close()

  // Erfolgreiche Verbindung behandeln
  client.OnConnect(func() {
    fmt.Println("✅ Mit Server verbunden")
  })

  // Trennung behandeln
  client.OnDisconnect(func(reason string) {
    fmt.Printf("❌ Getrennt: %s\n", reason)
  })

  // Event vom Server empfangen
  client.On("welcome", func(data ...interface{}) {
    fmt.Printf("📩 Nachricht vom Server: %v\n", data[0])
  })

  // Event an Server senden
  client.Emit("hello", "Hallo von Go!")

  // Anwendung am Laufen halten
  select {}
}

Führen Sie Ihre Anwendung aus:

go run main.go

Grundlegende Konzepte

Socket

Der Socket ist der Hauptclient, der die Verbindung zum Socket.IO-Server verwaltet. Er wird mit socketio.New() erstellt und bietet Methoden zum Senden und Empfangen von Events.

client := socketio.New("ws://localhost:3000")

Events

Events sind Nachrichten, die zwischen Client und Server gesendet werden. Sie können Events mit On() empfangen und mit Emit() senden.

// Empfangen
client.On("message", func(data ...interface{}) {
  fmt.Println(data[0])
})

// Senden
client.Emit("message", "Hallo Welt")

Namespaces

Namespaces ermöglichen das Multiplexen von Verbindungen über eine einzige WebSocket-Verbindung. Der Standard-Namespace ist /.

// Standard-Namespace
client.On("news", handler)

// Benutzerdefinierter Namespace
chat := client.Of("/chat")
chat.On("message", handler)

Lebenszyklus

Die Verbindung hat verschiedene Zustände, die Sie überwachen können:

client.OnConnect(func() {
  fmt.Println("Verbunden")
})

client.OnDisconnect(func(reason string) {
  fmt.Println("Getrennt:", reason)
})

client.OnError(func(err error) {
  fmt.Println("Fehler:", err)
})

Grundlegende Konfiguration

Sie können das Verhalten des Clients mit Optionen anpassen:

client := socketio.New("ws://localhost:3000", socketio.Options{
  // Authentifizierung
  Auth: map[string]interface{}{
    "token": "ihr-geheimes-token",
  },

  // Automatische Wiederverbindung
  ReconnectAttempts: 5,
  ReconnectDelay:    time.Second,
  ReconnectDelayMax: 5 * time.Second,

  // Timeouts
  Timeout:    30 * time.Second,
  AckTimeout: 5 * time.Second,
})

Häufige Muster

Emit mit Antwort (Acknowledgment)

client.EmitWithAck("request", func(response ...interface{}) {
  fmt.Println("Antwort vom Server:", response[0])
}, "Anfragedaten")

Verwaltung der Wiederverbindung

client.OnReconnectAttempt(func(attempt int) {
  fmt.Printf("Wiederverbindungsversuch #%d\n", attempt)
})

client.OnReconnectError(func(err error) {
  fmt.Println("Fehler bei Wiederverbindung:", err)
})

client.OnReconnectFailed(func() {
  fmt.Println("Wiederverbindung fehlgeschlagen nach allen Versuchen")
})

Verbindungsstatus überprüfen

if client.IsConnected() {
  fmt.Println("Der Client ist verbunden")
}

state := client.GetState()
// state kann sein: StateDisconnected, StateConnecting, StateConnected, usw.

Nächste Schritte

Jetzt, wo Sie eine funktionierende Basisverbindung haben, erkunden Sie:

Vollständige Beispiele

Das Repository enthält vollständige Beispiele im Ordner examples/:

  • examples/basic/ - Verbindung und grundlegende Events
  • examples/authentication/ - Authentifizierung mit JWT
  • examples/chat/ - Echtzeit-Chat-Anwendung
  • examples/namespaces/ - Mehrere Namespaces
  • examples/reconnection/ - Verwaltung der Wiederverbindung

Jedes Beispiel kann mit einem einzigen Befehl ausgeführt werden:

cd examples/basic
go run .