Programmering av WebSockets og sanntidssystemer · leksjon

Håndtering av frakoblinger og tilkobling på nytt

Implementer logikk på klient- og serversiden for å oppdage frakoblinger og automatisk forsøke å koble til på nytt.

Leksjon 1 av 412 trinn

Håndtering av frakoblinger og tilkobling på nytt er en gratis leksjon i Programmering av WebSockets og sanntidssystemer på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Programmering av WebSockets og sanntidssystemer, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Programmering av WebSockets og sanntidssystemer inneholder totalt 4 leksjoner.

Hvorfor forbindelser brytes

I den virkelige verden er nettverksforbindelser ikke alltid perfekte. WebSockets kan, til tross for at de er vedvarende, brytes av mange årsaker.

Hvis slike frakoblinger ignoreres, kan det føre til programmer som ikke svarer, og en dårlig brukeropplevelse. I denne leksjonen utforsker vi hvordan slike avbrudd kan håndteres på en kontrollert måte.

Årsaker til tap av forbindelse

Hva kan føre til at en WebSocket-forbindelse brytes?

Nettverksproblemer: Wi-Fi-forbindelsen faller ut, internettbrudd eller problemer med proxyer.
Omstart av serveren: Serverprogrammet kan startes på nytt på grunn av oppdateringer eller vedlikehold.
Klienten er frakoblet: Brukeren lukker nettleseren, mister strømmen eller setter enheten i hvilemodus.
Tidsavbrudd ved inaktivitet: Enkelte proxyer eller brannmurer kan lukke inaktive forbindelser.

Klienten oppdager frakoblinger

På klientsiden tilbyr nettleserens innebygde WebSocket-API hendelser som varsler Dem om endringer i forbindelsesstatusen.

Den viktigste hendelsen for å oppdage en frakobling er onclose-hendelsen. Den utløses når forbindelsen enten lukkes kontrollert av serveren eller går tapt brått.

Enkelt forsøk på å koble til på nytt

Når onclose utløses, kan De forsøke å koble til på nytt umiddelbart. Denne enkle tilnærmingen fungerer ved midlertidige problemer, men kan være problematisk.

Prøv å kjøre dette grunnleggende eksempelet på klientsiden:

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();

Hvorfor enkle nye forsøk mislykkes

Gjentatte forsøk på å koble til på nytt umiddelbart (for eksempel hvert sekund) kan overbelaste både klienten og serveren.

Ressursbruk på klientsiden: Kontinuerlige tilkoblingsforsøk bruker CPU- og nettverksressurser.
Serveroverbelastning: Hvis mange klienter kobles fra og deretter oversvømmer serveren med forespørsler om ny tilkobling, kan det føre til en Denial of Service-situasjon (DoS).
Ingen backoff: Det tas ikke hensyn til langvarige driftsavbrudd.

Smart tilkobling på nytt: Backoff

For å unngå overbelastning og gi en bedre opplevelse bruker vi strategier for backoff ved ny tilkobling.

En backoff-strategi innfører forsinkelser mellom nye tilkoblingsforsøk, og disse forsinkelsene øker vanligvis etter hvert mislykkede forsøk. Dette gir serveren tid til å gjenopprette driften og hindrer et «tordnende flokk»-problem.

Logikk for eksponentiell backoff

Eksponentiell backoff er en vanlig og effektiv strategi. Det betyr at forsinkelsen mellom nye forsøk øker eksponentielt.

Første nye forsøk: 1 sekund
Andre nye forsøk: 2 sekunder
Tredje nye forsøk: 4 sekunder
Fjerde nye forsøk: 8 sekunder

Vanligvis setter man en øvre grense for forsinkelsen for å unngå uforholdsmessig lange ventetider, og legger til litt tilfeldig «jitter» for å unngå synkroniserte nye forsøk.

Klient med eksponentiell backoff

La oss forbedre koden på klientsiden slik at den bruker eksponentiell backoff med en maksimal forsinkelse og litt tilfeldig jitter. Prøv å kjøre den!

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();

Frakoblinger på serversiden

Serveren må også vite når en klient kobler fra. Dette er avgjørende for å frigjøre ressurser, oppdatere lister over tilkoblede brukere eller stoppe datastrømmer for den aktuelle klienten.

Når De bruker et bibliotek som ws i Node.js, utløser WebSocket-serveren en 'close'-hendelse på tilkoblingsobjektet for den enkelte klienten når den kobles fra.

Opprydding på serveren ved frakobling

Her er et grunnleggende Node.js-WebSocket-servereksempel som viser hvordan klientfrakoblinger kan håndteres, og hvordan klientene kan fjernes fra en liste over aktive forbindelser.

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');

Test forståelsen

Se for Dem en WebSocket-applikasjon på klientsiden som må håndtere frakoblinger på en robust måte.

Hvilke av følgende er gode fremgangsmåter for å implementere en strategi for gjenoppretting av tilkoblingen?

Besvar den i den interaktive leksjonen

Oppsummering: Robuste tilkoblinger

Vi har sett på hvor viktig det er å håndtere frakoblinger i sanntidsapplikasjoner. Både klienten og serveren spiller en rolle i å opprettholde en robust tilkobling.

Klienter bruker onclose til å oppdage frakoblinger.
Eksponentiell tilbakeventing med tilfeldig variasjon og en maksimal forsinkelse hindrer overbelastning av serveren under gjenoppretting av tilkoblinger.
Servere bruker on('close') til å frigjøre ressurser når klienter forlater tilkoblingen.

Disse strategiene sørger for at sanntidsapplikasjonene Deres forblir responsive og pålitelige, selv under ustabile nettverksforhold.

Gratis å komme i gang

Lær deg Programmering av WebSockets og sanntidssystemer med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 47

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Håndtering av frakoblinger og tilkobling på nytt» gratis?

Ja – hele teksten i «Håndtering av frakoblinger og tilkobling på nytt» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Programmering av WebSockets og sanntidssystemer-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Programmering av WebSockets og sanntidssystemer inneholder totalt 4 leksjoner.

Hva lærer jeg i «Håndtering av frakoblinger og tilkobling på nytt»?

Implementer logikk på klient- og serversiden for å oppdage frakoblinger og automatisk forsøke å koble til på nytt. Du øver på Programmering av WebSockets og sanntidssystemer med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Programmering av WebSockets og sanntidssystemer?

Ingen tidligere erfaring er nødvendig. Programmering av WebSockets og sanntidssystemer på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Håndtering av frakoblinger og tilkobling på nytt»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Programmering av WebSockets og sanntidssystemer-leksjonen?

Ja. Alle Programmering av WebSockets og sanntidssystemer-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Håndtering av frakoblinger og tilkobling på nytt
Robust feilpropagering og gjenoppretting
Hjerteslag og forbindelsesbevaring
Meldingsbekreftelser og leveringsgarantier

← Tilbake til Programmering av WebSockets og sanntidssystemer