Programmering av WebSockets og sanntidssystemer · leksjon

Hjerteslag og forbindelsesbevaring

Lær å bruke ping-/pong-rammer og hjerteslag på applikasjonsnivå for å opprettholde aktive forbindelser og oppdage utilgjengelige motparter.

Leksjon 3 av 411 trinn

Hjerteslag og forbindelsesbevaring er en gratis leksjon i Programmering av WebSockets og sanntidssystemer på CoddyKit. Dette er leksjon 3 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 heartbeat-signaler er viktige

I sanntidsapplikasjoner er det avgjørende å opprettholde en aktiv og velfungerende tilkobling. Men hva skjer hvis en tilkobling blir brutt uten at det merkes?

Heartbeat-signaler er små, periodiske meldinger som utveksles mellom tilkoblede parter.
De fungerer som en «pulssjekk» for å bekrefte at både klienten og serveren fortsatt er aktive og responsive.
Dette hjelper med å oppdage «døde» tilkoblinger som ikke er blitt avsluttet på riktig måte, slik at ressurser ikke blir bundet opp på ubestemt tid.

Den stille, døde motparten

Se for Dem at en klient plutselig mister nettverkstilkoblingen (for eksempel fordi Wi-Fi-forbindelsen brytes eller enheten går i hvilemodus), uten å avslutte WebSocket-tilkoblingen på riktig måte.

Serveren kan fortsatt tro at klienten er tilkoblet.
Meldinger som sendes til denne «døde» klienten, kommer aldri frem.
Dette sløser med serverressurser og fører til inkonsistente tilstander i applikasjonen.
Heartbeat-signaler gjør det mulig å oppdage og avslutte disse ikke-responsive tilkoblingene på en proaktiv måte.

Innebygde WebSocket-pingmeldinger

WebSocket-protokollen har innebygde mekanismer for heartbeat-signaler: Ping- og Pong-rammer.

En server (eller klient) kan sende en spesiell Ping-ramme til motparten.
Når motparten mottar en Ping, forventes det at den automatisk svarer med en Pong-ramme.
Disse rammene er lette kontrollmeldinger, ikke applikasjonsdata.
De bekrefter at den underliggende TCP-tilkoblingen fortsatt er aktiv og kan overføre data.

Serveren sender Ping (Node.js)

Slik kan en WebSocket-server i Node.js sende periodiske ping-rammer til de tilkoblede klientene. ws-biblioteket håndterer detaljene på lavt nivå.

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

wss.on('connection', ws => {
  console.log('Client connected');

  // Send a ping every 5 seconds
  const pingInterval = setInterval(() => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.ping();
      console.log('Server sent ping.');
    }
  }, 5000);

  ws.on('pong', () => {
    console.log('Client responded with pong!');
  });

  ws.on('close', () => {
    console.log('Client disconnected');
    clearInterval(pingInterval);
  });

  ws.on('error', error => {
    console.error('WS error:', error);
    clearInterval(pingInterval);
  });
});

console.log('Server running on ws://localhost:8080');

Klienter svarer automatisk med Pong

Når en WebSocket-klient (for eksempel en nettleser eller en Node.js-klient som bruker ws) mottar en innebygd Ping-ramme:

Sender den automatisk en Pong-ramme tilbake uten at De trenger å skrive eksplisitt kode for det.
Dette gjør innebygde pingmeldinger svært effektive for grunnleggende kontroller av om tilkoblingen er aktiv.
Hvis en Ping sendes og ingen Pong mottas innen tidsavbruddet, kan serveren anta at tilkoblingen er død og lukke den.

Mer enn innebygde pingmeldinger

Selv om innebygde Ping/Pong-rammer er gode for å kontrollere om TCP-tilkoblingen er aktiv, har de begrensninger:

De kontrollerer ikke om applikasjonslaget fortsatt er responsivt.
Proxyer eller lastbalanserere kan noen ganger forstyrre disse kontrollrammene eller unnlate å videresende dem på riktig måte.
De gjør det ikke mulig å sende med egendefinerte data, for eksempel et tidsstempel eller en bruker-ID.

Det er her heartbeat-signaler på applikasjonsnivå kommer inn.

Scenarier for heartbeat-signaler på applikasjonsnivå

Heartbeat-signaler på applikasjonsnivå er egendefinerte meldinger som sendes over WebSocket-tilkoblingen, og som er laget for å håndteres av applikasjonslogikken. De er nyttige for å:

oppdage om tilkoblingen er aktiv gjennom proxyer som ikke kjenner WebSocket.
sikre at selve applikasjonen (ikke bare TCP-tilkoblingen) er responsiv.
implementere mer avanserte tidsavbrudd basert på brukeraktivitet, ikke bare nettverksaktivitet.
tillate egendefinerte datamengder, for eksempel klientstatus eller tidspunktet for siste aktivitet.

Heartbeat-signal fra klienten (Node.js)

En klient kan sende egendefinerte «heartbeat»-meldinger med jevne mellomrom. Dette eksempelet bruker en Node.js-klient, men nettleserklienter følger et lignende mønster.

const WebSocket = require('ws');
const ws = new WebSocket('ws://localhost:8080');
let appHeartbeatInterval;

ws.onopen = () => {
  console.log('Connected to server.');
  // Send a custom heartbeat every 3 seconds
  appHeartbeatInterval = setInterval(() => {
    const message = JSON.stringify({
      type: 'APP_HEARTBEAT',
      timestamp: Date.now()
    });
    ws.send(message);
    console.log('Client sent APP_HEARTBEAT.');
  }, 3000);
};

ws.onmessage = event => {
  console.log('Received:', event.data);
};

ws.onclose = () => {
  console.log('Disconnected.');
  clearInterval(appHeartbeatInterval);
};

ws.onerror = error => {
  console.error('WS error:', error);
  clearInterval(appHeartbeatInterval);
};

Serveren sporer heartbeat-signaler på applikasjonsnivå

Serveren mottar disse egendefinerte meldingene og oppdaterer et tidsstempel for «sist sett» for hver klient. Hvis tidsstempelet til en klient ikke blir oppdatert på for lenge, kan serveren lukke tilkoblingen.

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

wss.on('connection', ws => {
  console.log('Client connected');
  ws.lastAppHeartbeat = Date.now(); // Initialize timestamp

  const checkInterval = setInterval(() => {
    // If no app heartbeat in 6 seconds, assume dead
    if (Date.now() - ws.lastAppHeartbeat > 6000) {
      console.log('Client unresponsive (app heartbeat). Terminating.');
      ws.terminate(); // Force close the connection
      clearInterval(checkInterval);
    }
  }, 2000); // Check every 2 seconds

  ws.on('message', message => {
    const parsed = JSON.parse(message);
    if (parsed.type === 'APP_HEARTBEAT') {
      ws.lastAppHeartbeat = Date.now(); // Update timestamp
      // console.log('Received custom APP_HEARTBEAT from client');
    }
    // Handle other messages...
  });

  ws.on('close', () => {
    console.log('Client disconnected');
    clearInterval(checkInterval);
  });

  ws.on('error', error => {
    console.error('WS error:', error);
    clearInterval(checkInterval);
  });
});
console.log('Server running on ws://localhost:8080');

Test forståelsen Deres

Velg alle påstandene som beskriver WebSocket-heartbeat-signaler og keep-alive-mekanismer korrekt:

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

Vi har sett på den viktige rollen heartbeat-signaler spiller for å opprettholde robuste WebSocket-tilkoblinger:

Innebygde Ping/Pong-rammer kontrollerer om TCP-tilkoblingen er aktiv, og klientene svarer automatisk.
Heartbeat-signaler på applikasjonsnivå gir en mer robust og fleksibel måte å sikre at selve applikasjonen er responsiv på, og er spesielt nyttige sammen med proxyer.
Begge metodene hindrer «døde» tilkoblinger i å bruke ressurser og forbedrer systemets robusthet totalt sett.

Å beherske heartbeat-signaler er avgjørende for å bygge stabile og skalerbare sanntidsapplikasjoner.

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 «Hjerteslag og forbindelsesbevaring» gratis?

Ja – hele teksten i «Hjerteslag og forbindelsesbevaring» 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 «Hjerteslag og forbindelsesbevaring»?

Lær å bruke ping-/pong-rammer og hjerteslag på applikasjonsnivå for å opprettholde aktive forbindelser og oppdage utilgjengelige motparter. 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 3 av 4.

Hvor lang tid tar leksjonen «Hjerteslag og forbindelsesbevaring»?

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