Robust feilpropagering og gjenoppretting
Utvikle strategier for feilhåndtering, logging og kontrollert funksjonsreduksjon i WebSocket-applikasjoner.
Robust feilpropagering og gjenoppretting er en gratis leksjon i Programmering av WebSockets og sanntidssystemer på CoddyKit. Dette er leksjon 2 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.
Håndtering av sanntidsfeil
Å bygge pålitelige sanntidsapplikasjoner krever mer enn bare å håndtere frakoblinger. De trenger en solid strategi for å håndtere feil som oppstår i WebSocket-kommunikasjonen.
Robust feilhåndtering sørger for at applikasjonen forblir stabil, gir en god brukeropplevelse og hjelper Dem med å finne årsaken til problemer raskt.
Ulike feiltyper
Feil i WebSocket-applikasjoner kan ha flere årsaker:
- Protokollfeil: Dette er problemer som feilformaterte rammer eller ugyldige opkoder. WebSocket-biblioteket håndterer vanligvis disse automatisk.
- Feil i applikasjonslogikken: Feil i server- eller klientkoden som fører til uventet oppførsel eller krasj under behandling av meldinger.
- Nettverksfeil: Problemer som brannmurer, proxyproblemer eller ustabile internettilkoblinger, som ofte fører til tap av tilkoblingen.
Vi fokuserer på å håndtere applikasjons- og nettverksrelaterte feil på en effektiv måte.
Feilhåndtering på serveren
På serveren tilbyr WebSocket-biblioteker mekanismer for å fange opp feil. I Node.js med det populære ws-biblioteket kan både serverforekomsten og individuelle klienttilkoblinger utløse 'error'-hendelser.
Det er avgjørende å lytte etter disse hendelsene for å hindre at serveren krasjer, og for å loggføre problemer slik at de kan feilsøkes.
Serverfeil i praksis
Dette Node.js-eksempelet viser en enkel WebSocket-server som med vilje utløser en feil når den mottar en bestemt melding. Legg merke til hvordan håndtererne wss.on('error') og ws.on('error') fanger opp feilen.
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });
wss.on('connection', function connection(ws) {
console.log('Client connected');
ws.on('message', function incoming(message) {
console.log('Received: %s', message);
if (message.toString() === 'cause error') {
// Simulate an application logic error
try {
throw new Error('Simulated application error!');
} catch (e) {
console.error('Caught application error:', e.message);
// In a real app, you might send this error to the client
ws.send(JSON.stringify({ type: 'error', message: e.message }));
}
} else {
ws.send(`Echo: ${message}`);
}
});
ws.on('error', (error) => {
console.error('WebSocket connection error:', error.message);
});
ws.on('close', () => {
console.log('Client disconnected');
});
});
wss.on('error', (error) => {
console.error('WebSocket server error:', error.message);
});
console.log('WebSocket server started on port 8080');
// To run this example:
// 1. npm init -y
// 2. npm install ws
// 3. node server.js
// Then connect with a client and send 'cause error'Feilhåndtering på klienten
På klientsiden tilbyr nettleserens innebygde WebSocket-objekt en onerror-hendelse. Denne hendelsen utløses når det oppstår feil under etablering av tilkoblingen eller på et hvilket som helst tidspunkt mens tilkoblingen er aktiv.
Merk at onerror ofte kommer før eller samtidig med en onclose-hendelse, noe som indikerer at tilkoblingen ble avsluttet på en problematisk måte.
Klientfeil i praksis
Dette HTML- og JavaScript-utdraget viser hvordan De setter opp en onerror-håndterer for en WebSocket-klient. Prøv å kjøre serveren fra den forrige scenen og deretter denne klienten i nettleseren.
<!DOCTYPE html>
<html>
<head>
<title>WebSocket Client Error Handling</title>
</head>
<body>
<h1>Client Error Handler</h1>
<p id="status">Connecting...</p>
<script>
const statusElement = document.getElementById('status');
const ws = new WebSocket('ws://localhost:8080');
ws.onopen = () => {
statusElement.textContent = 'Connected! Try sending "cause error" from a different client.';
console.log('WebSocket connected.');
ws.send('Hello server!');
};
ws.onmessage = (event) => {
console.log('Message from server:', event.data);
statusElement.textContent = `Received: ${event.data}`;
};
ws.onerror = (error) => {
// The error object itself might not contain detailed info
// but it signals that an error occurred.
statusElement.textContent = 'Error occurred! Check console.';
console.error('WebSocket error event:', error);
};
ws.onclose = (event) => {
statusElement.textContent = `Disconnected. Code: ${event.code}, Reason: ${event.reason}`;
console.log('WebSocket disconnected:', event);
};
</script>
</body>
</html>Videreformidling av egendefinerte feil
Noen ganger handler feil ikke om selve tilkoblingen, men om logikken i applikasjonen. Det kan for eksempel være en bruker som prøver å få tilgang til data uten nødvendige tillatelser, eller som sender inn ugyldige data. I slike tilfeller må De sende en feilmelding eksplisitt.
Det er god praksis å strukturere disse som standardiserte meldinger (for eksempel JSON) med en bestemt type eller status, slik at de kan skilles fra vanlige data.
Serveren sender egendefinerte feil
Slik kan en server sende en strukturert feilmelding tilbake til klienten. Klienten må deretter tolke og håndtere denne spesifikke meldingstypen for å reagere på riktig måte.
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8081 }); // Using a different port
wss.on('connection', function connection(ws) {
console.log('Client connected to custom error server');
ws.on('message', function incoming(message) {
const msgStr = message.toString();
if (msgStr === 'fetch_sensitive_data') {
// Simulate an authorization error
const errorResponse = {
type: 'error',
code: 403,
message: 'Access denied: You are not authorized for this data.'
};
ws.send(JSON.stringify(errorResponse));
} else {
ws.send(`Echo: ${msgStr}`);
}
});
ws.on('error', (error) => console.error('Connection error:', error.message));
ws.on('close', () => console.log('Client disconnected from custom error server'));
});
console.log('WebSocket server for custom errors started on port 8081');
// To run this example:
// 1. npm init -y
// 2. npm install ws
// 3. node server_custom_error.js
// Then connect a client and send 'fetch_sensitive_data'Gradvis redusert funksjonalitet
Når det oppstår en alvorlig feil, kan applikasjonen i stedet for å slutte å fungere fullstendig «redusere funksjonaliteten på en kontrollert måte». Det betyr at den tilbyr en begrenset, men fortsatt brukbar opplevelse.
- Delvis funksjonalitet: Deaktiver funksjoner som er avhengige av den problematiske komponenten, men la de andre fortsette å fungere.
- Reservefunksjoner: Bruk alternative metoder, for eksempel mindre sanntidsbaserte metoder som å hente data på nytt med tradisjonelle HTTP-forespørsler.
- Informer brukeren: Forklar tydelig hva problemet er, og hvilken funksjonalitet som er berørt, slik at brukerens forventninger blir riktige.
Kontroll av feilstrategi
Hvilken av følgende strategier er effektiv for gradvis redusert funksjonalitet i en WebSocket-applikasjon når en kritisk feil på serversiden hindrer sanntidsoppdateringer?
Oppsummering av feilhåndtering
De har lært at robust feilhåndtering i WebSocket-applikasjoner innebærer å forstå ulike feiltyper, fange opp hendelser både på server- og klientsiden og videreformidle feil på applikasjonsnivå eksplisitt.
Det er spesielt viktig å implementere gradvis redusert funksjonalitet. Da forblir applikasjonen robust og brukervennlig selv når noe går galt. Fortsett å øve på disse strategiene for å bygge mer robuste sanntidssystemer!
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
Ofte stilte spørsmål
Er leksjonen «Robust feilpropagering og gjenoppretting» gratis?
Ja – hele teksten i «Robust feilpropagering og gjenoppretting» 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 «Robust feilpropagering og gjenoppretting»?
Utvikle strategier for feilhåndtering, logging og kontrollert funksjonsreduksjon i WebSocket-applikasjoner. 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 2 av 4.
Hvor lang tid tar leksjonen «Robust feilpropagering og gjenoppretting»?
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