Надёжная передача и восстановление после ошибок
Разработайте стратегии обработки ошибок, ведения журналов и плавного снижения функциональности в приложениях на основе WebSocket.
«Надёжная передача и восстановление после ошибок» — бесплатный урок WebSockets & Realtime Systems Programming на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения WebSockets & Realtime Systems Programming, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс WebSockets & Realtime Systems Programming содержит 4 уроков всего.
Части этого урока еще не переведены и отображаются на английском.
Handling Realtime Errors
Building reliable realtime applications requires more than just handling disconnections. You need a solid strategy for dealing with errors that occur within your WebSocket communication.
Robust error handling ensures your application remains stable, provides a good user experience, and helps you diagnose issues quickly.
Different Error Types
Errors in WebSocket applications can come from various sources:
- Protocol Errors: These are issues like malformed frames or invalid opcodes. Your WebSocket library usually handles these automatically.
- Application Logic Errors: Bugs in your server or client code that cause unexpected behavior or crashes during message processing.
- Network Errors: Problems like firewalls, proxy issues, or unstable internet connections, often leading to connection loss.
We'll focus on handling application and network-related errors effectively.
Server Error Handling
On the server, WebSocket libraries provide mechanisms to catch errors. For example, in Node.js with the popular ws library, both the server instance and individual client connections can emit 'error' events.
It's crucial to listen for these events to prevent your server from crashing and to log issues for debugging.
Server Error in Action
This Node.js example shows a simple WebSocket server that intentionally throws an error when a specific message is received. Notice how the wss.on('error') and ws.on('error') handlers catch it.
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'Client Error Handling
On the client side, the browser's native WebSocket object provides an onerror event. This event fires when errors occur during connection establishment, or at any point during the connection's lifetime.
It's important to note that onerror often precedes or accompanies a onclose event, indicating a problematic connection termination.
Client Error in Action
This HTML and JavaScript snippet demonstrates how to set up an onerror handler for a WebSocket client. Try running the server from the previous scene and then this client in your browser.
<!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>Propagating Custom Errors
Sometimes, errors aren't about the connection itself, but about your application's logic. For example, a user trying to access unauthorized data or submitting invalid input. In these cases, you need to explicitly send an error message.
It's best practice to structure these as standard messages (e.g., JSON) with a specific type or status to differentiate them from regular data.
Server Sending Custom Errors
Here's how a server can send a structured error message back to the client. The client then needs to parse and handle this specific message type to react appropriately.
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'Graceful Degradation
When a severe error occurs, instead of completely failing, your application can "gracefully degrade" its functionality. This means offering a reduced but still usable experience.
- Partial Functionality: Disable features that rely on the problematic component, but keep others working.
- Fallback Mechanisms: Use alternative (perhaps less real-time) methods, like refreshing data via traditional HTTP requests.
- Inform User: Clearly communicate the issue and what functionality is affected, managing their expectations.
Error Strategy Check
Which of the following is an effective strategy for graceful degradation in a WebSocket application when a critical server-side error prevents real-time updates?
Error Handling Summary
You've learned that robust error handling in WebSocket applications involves understanding different error types, catching both server-side and client-side events, and explicitly propagating application-level errors.
Crucially, implementing graceful degradation ensures your application remains resilient and user-friendly even when things go wrong. Keep practicing these strategies to build more robust realtime systems!
Часто задаваемые вопросы
Урок «Надёжная передача и восстановление после ошибок» бесплатный?
Да — полный текст урока «Надёжная передача и восстановление после ошибок» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс WebSockets & Realtime Systems Programming, подпишись на CoddyKit PRO. Курс WebSockets & Realtime Systems Programming содержит 4 уроков всего.
Чему я научусь в уроке «Надёжная передача и восстановление после ошибок»?
Разработайте стратегии обработки ошибок, ведения журналов и плавного снижения функциональности в приложениях на основе WebSocket. Ты практикуешь WebSockets & Realtime Systems Programming с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.
Нужен ли мне опыт, чтобы начать WebSockets & Realtime Systems Programming?
Предыдущий опыт не требуется. WebSockets & Realtime Systems Programming на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.
Сколько времени занимает урок «Надёжная передача и восстановление после ошибок»?
Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.
Можно ли писать и запускать код в этом уроке WebSockets & Realtime Systems Programming?
Да. Каждый урок WebSockets & Realtime Systems Programming включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.
Все уроки этого курса
- Обработка отключений и повторных подключений
- Надёжная передача и восстановление после ошибок
- Сигналы активности и поддержание соединения
- Подтверждение сообщений и гарантии доставки