WebSockets & Realtime Systems Programming · Lektion

Verbindungen und Wiederverbindungen verwalten

Implementieren Sie client- und serverseitige Logik, um Verbindungsabbrüche zu erkennen und automatisch eine Wiederverbindung zu versuchen.

Lektion 1 von 412 Schritte

Verbindungen und Wiederverbindungen verwalten ist eine kostenlose WebSockets & Realtime Systems Programming-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des WebSockets & Realtime Systems Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der WebSockets & Realtime Systems Programming-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Why Connections Drop

In the real world, network connections aren't always perfect. WebSockets, despite being persistent, can break due to many reasons.

Ignoring these disconnections can lead to unresponsive applications and a poor user experience. This lesson explores how to gracefully handle these interruptions.

Causes of Connection Loss

What makes a WebSocket connection drop?

Network Issues: Wi-Fi drops, internet outages, proxy problems.
Server Restarts: The server application might restart for updates or maintenance.
Client Offline: The user closes their browser, loses power, or puts their device to sleep.
Idle Timeouts: Some proxies or firewalls might close idle connections.

Client Detects Disconnects

On the client side, the browser's native WebSocket API provides events to notify you about connection status changes.

The most important event for detecting a disconnection is the onclose event. It fires when the connection is either gracefully closed by the server or abruptly lost.

Simple Reconnect Attempt

When onclose fires, you can immediately try to reconnect. This simple approach works for temporary glitches but can be problematic.

Try running this basic client-side example:

let ws;
function connect() {
  ws = new WebSocket("ws://localhost:8080");

  ws.onopen = () => console.log("Connected!");
  ws.onmessage = (event) => console.log("Received:", event.data);
  ws.onerror = (error) => console.error("WebSocket Error:", error);

  ws.onclose = () => {
    console.log("Disconnected. Reconnecting...");
    setTimeout(connect, 1000); // Try again in 1 second
  };
}
connect();

Why Simple Retries Fail

Continuously trying to reconnect immediately (e.g., every 1 second) can overwhelm both the client and the server.

Client Resource Drain: Constant connection attempts consume CPU and network resources.
Server Overload: If many clients disconnect and then flood the server with reconnect requests, it can lead to a Denial of Service (DoS) situation.
No Backoff: It doesn't account for prolonged outages.

Smart Reconnection: Backoff

To prevent overloading and provide a better experience, we use reconnection backoff strategies.

A backoff strategy introduces delays between reconnection attempts, and these delays typically increase with each failed attempt. This gives the server time to recover and prevents a "thundering herd" problem.

Exponential Backoff Logic

Exponential backoff is a common and effective strategy. It means the delay between retries increases exponentially.

First retry: 1 second
Second retry: 2 seconds
Third retry: 4 seconds
Fourth retry: 8 seconds

You usually cap the maximum delay to prevent excessively long waits and add some random "jitter" to avoid synchronized retries.

Client with Exponential Backoff

Let's enhance our client-side code to use exponential backoff with a maximum delay and some random jitter. Try running it!

let ws;
let reconnectInterval = 1000; // Start with 1 second
const maxReconnectInterval = 30000; // Max 30 seconds
let reconnectTimer;

function connect() {
  ws = new WebSocket("ws://localhost:8080");

  ws.onopen = () => {
    console.log("Connected!");
    reconnectInterval = 1000; // Reset on successful connection
    clearTimeout(reconnectTimer);
  };
  ws.onmessage = (event) => console.log("Received:", event.data);
  ws.onerror = (error) => console.error("WebSocket Error:", error);

  ws.onclose = () => {
    console.log(`Disconnected. Retrying in ${reconnectInterval / 1000}s...`);
    reconnectTimer = setTimeout(connect, reconnectInterval);
    reconnectInterval = Math.min(reconnectInterval * 2, maxReconnectInterval);
    // Add some random jitter (e.g., +/- 10%) for better distribution
    reconnectInterval += (Math.random() - 0.5) * reconnectInterval * 0.2;
    reconnectInterval = Math.floor(reconnectInterval);
  };
}
connect();

Server-Side Disconnects

The server also needs to know when a client disconnects. This is crucial for cleaning up resources, updating connected user lists, or stopping data streams for that client.

Using a library like ws in Node.js, the WebSocket server emits a 'close' event on the individual client connection object when it disconnects.

Server Cleanup on Disconnect

Here's a basic Node.js WebSocket server example showing how to handle client disconnections and remove them from an active connections list.

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

let clients = new Set();

wss.on('connection', function connection(ws) {
  clients.add(ws);
  console.log('Client connected. Total:', clients.size);

  ws.on('message', function incoming(message) {
    console.log('received: %s', message);
  });

  ws.on('close', function close() {
    clients.delete(ws);
    console.log('Client disconnected. Total:', clients.size);
  });

  ws.send('Welcome!');
});

console.log('WebSocket server started on port 8080');

Check Your Understanding

Consider a client-side WebSocket application that needs to handle disconnections robustly.

Which of the following are good practices for implementing a reconnection strategy?

Beantworte es in der interaktiven Lektion

Recap: Robust Connections

We've explored how crucial it is to handle disconnections in realtime applications. Both client and server play a role in maintaining connection resilience.

Clients use onclose to detect disconnections.
Exponential backoff with jitter and a max delay prevents server overload during reconnections.
Servers use on('close') to clean up resources when clients leave.

These strategies ensure your realtime apps remain responsive and reliable, even in unstable network conditions.

Kostenlos starten

Lerne WebSockets & Realtime Systems Programming mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 12
Lektionen: 47

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Verbindungen und Wiederverbindungen verwalten“ kostenlos?

Ja — der vollständige Text von „Verbindungen und Wiederverbindungen verwalten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des WebSockets & Realtime Systems Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der WebSockets & Realtime Systems Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Verbindungen und Wiederverbindungen verwalten“?

Implementieren Sie client- und serverseitige Logik, um Verbindungsabbrüche zu erkennen und automatisch eine Wiederverbindung zu versuchen. Du übst WebSockets & Realtime Systems Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um WebSockets & Realtime Systems Programming zu starten?

Keine Vorkenntnisse erforderlich. WebSockets & Realtime Systems Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Verbindungen und Wiederverbindungen verwalten“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser WebSockets & Realtime Systems Programming-Lektion Code schreiben und ausführen?

Ja. Jede WebSockets & Realtime Systems Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Verbindungen und Wiederverbindungen verwalten
Robuste Fehlerweitergabe und Wiederherstellung
Heartbeats und Keep-Alives
Nachrichtenbestätigung und Zustellungsgarantien

← Zurück zu WebSockets & Realtime Systems Programming