Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React
WebSockets i Server-Sent Events w React
W tej lekcji3
Radar stacji ma pokazywać pozycje statków na bieżąco. Zwykłe REST API działa jak list: klient pyta, serwer odpowiada i rozmowa się kończy. Żeby widzieć zmiany, musiałbyś pytać co sekundę, marnując łącze i baterię. Komunikacja w czasie rzeczywistym odwraca ten model: serwer sam wysyła dane, gdy coś się wydarzy. W przeglądarce masz do tego dwie technologie: WebSocket i Server-Sent Events (SSE).
WebSockets - dwukierunkowa komunikacja w czasie rzeczywistym
WebSocket zaczyna jak zwykłe żądanie HTTP, a potem przełącza się na własny protokół (ws:// albo szyfrowany wss://). Od tej chwili obie strony mogą wysyłać wiadomości tekstowe lub binarne w dowolnym momencie. To najlepszy wybór dla czatu, powiadomień na żywo, danych giełdowych i gier, czyli wszędzie, gdzie klient też często nadaje.
Podstawowa implementacja WebSocket
Hook useWebSocket zamyka cały cykl życia połączenia: łączenie, odbiór, wysyłkę, rozłączanie i ponawianie:
// hooks/useWebSocket.js
import { useState, useEffect, useRef, useCallback } from 'react';
const useWebSocket = (url, options = {}) => {
const [socket, setSocket] = useState(null);
const [lastMessage, setLastMessage] = useState(null);
const [readyState, setReadyState] = useState(0);
const [connectionError, setConnectionError] = useState(null);
// Gniazdo, listenery i licznik prób w refach - ich zmiana nie wywołuje renderu
const socketRef = useRef(null);
const messageListeners = useRef(new Set());
const retryTimeoutRef = useRef(null);
const reconnectAttemptsRef = useRef(0);
// Najnowsze opcje z ostatniego renderu: callbacki podane inline
// nie zmieniają connect, więc efekt nie łączy się od nowa
const optionsRef = useRef(options);
useEffect(() => {
optionsRef.current = options;
});
const { heartbeatInterval = 30000 } = options;
// Funkcja do tworzenia połączenia - zależy tylko od url
const connect = useCallback(() => {
const { protocols, reconnectAttempts = 5, reconnectInterval = 3000 } = optionsRef.current;
try {
const ws = new WebSocket(url, protocols);
socketRef.current = ws;
ws.onopen = (event) => {
console.log('WebSocket połączony:', url);
setReadyState(1); // OPEN
setConnectionError(null);
reconnectAttemptsRef.current = 0;
optionsRef.current.onOpen?.(event);
};
ws.onmessage = (event) => {
let parsedData;
try {
parsedData = JSON.parse(event.data);
} catch {
parsedData = event.data;
}
setLastMessage({
data: parsedData,
timestamp: Date.now(),
raw: event.data
});
// Wywołaj wszystkie zarejestrowane listenery
messageListeners.current.forEach(listener => {
listener(parsedData, event);
});
optionsRef.current.onMessage?.(parsedData, event);
};
ws.onclose = (event) => {
// Zdarzenia starego gniazda (po reconnect albo odmontowaniu) pomijamy
if (socketRef.current !== ws) return;
console.log('WebSocket rozłączony:', event.code, event.reason);
setReadyState(3); // CLOSED
setSocket(null);
optionsRef.current.onClose?.(event);
// Automatyczne ponowne łączenie
if (!event.wasClean && reconnectAttemptsRef.current < reconnectAttempts) {
reconnectAttemptsRef.current++;
console.log(`Ponowne łączenie (${reconnectAttemptsRef.current}/${reconnectAttempts})...`);
retryTimeoutRef.current = setTimeout(() => {
connect();
}, reconnectInterval * reconnectAttemptsRef.current);
}
};
ws.onerror = (error) => {
if (socketRef.current !== ws) return;
console.error('WebSocket błąd:', error);
setConnectionError(error);
optionsRef.current.onError?.(error);
};
setSocket(ws);
setReadyState(0); // CONNECTING
} catch (error) {
console.error('Nie udało się utworzyć WebSocket:', error);
setConnectionError(error);
}
}, [url]);
// Wysyłanie wiadomości
const sendMessage = useCallback((message) => {
const ws = socketRef.current;
if (ws && ws.readyState === WebSocket.OPEN) {
const dataToSend = typeof message === 'string' ? message : JSON.stringify(message);
ws.send(dataToSend);
return true;
} else {
console.warn('WebSocket nie jest połączony');
return false;
}
}, []);
// Dodawanie listenera wiadomości
const addMessageListener = useCallback((listener) => {
messageListeners.current.add(listener);
return () => messageListeners.current.delete(listener);
}, []);
// Ręczne połączenie
const reconnect = useCallback(() => {
clearTimeout(retryTimeoutRef.current);
socketRef.current?.close();
reconnectAttemptsRef.current = 0;
connect();
}, [connect]);
// Rozłączenie
const disconnect = useCallback(() => {
clearTimeout(retryTimeoutRef.current);
socketRef.current?.close(1000, 'Zamknięte przez użytkownika');
}, []);
// Automatyczne połączenie przy mount
useEffect(() => {
connect();
return () => {
clearTimeout(retryTimeoutRef.current);
const ws = socketRef.current;
socketRef.current = null; // onclose starego gniazda nic już nie zrobi
ws?.close();
};
}, [connect]);
// Heartbeat - ping/pong
useEffect(() => {
if (socket && readyState === 1 && heartbeatInterval > 0) {
const interval = setInterval(() => {
if (socket.readyState === WebSocket.OPEN) {
sendMessage({ type: 'ping', timestamp: Date.now() });
}
}, heartbeatInterval);
return () => clearInterval(interval);
}
}, [socket, readyState, heartbeatInterval, sendMessage]);
return {
socket,
lastMessage,
readyState,
connectionError,
sendMessage,
addMessageListener,
reconnect,
disconnect,
isConnecting: readyState === 0,
isOpen: readyState === 1,
isClosing: readyState === 2,
isClosed: readyState === 3
};
};
export default useWebSocket;readyState odwzorowuje stany gniazda (0 łączenie, 1 otwarte, 2 zamykanie, 3 zamknięte), więc wskaźnik statusu masz za darmo. sendMessage wysyła tylko przy otwartym połączeniu, a po nieczystym zamknięciu hook ponawia próbę z rosnącym odstępem. Heartbeat co 30 sekund wysyła ping, żeby pośrednicy nie zerwali bezczynnego łącza.
Hook omija dwie pułapki. Callbacki, jak onOpen podany inline w czacie poniżej, i tablica protocols są nowe przy każdym renderze, więc gdyby connect od nich zależał, efekt otwierałby połączenie od nowa po każdym renderze. Dlatego hook czyta opcje z optionsRef, odświeżanego po każdym renderze, a connect zależy tylko od url. Samo gniazdo leży w socketRef, bo cleanup widziałby inaczej socket z renderu, w którym efekt wystartował, czyli null. Zdarzenia starego gniazda, zamkniętego przez reconnect albo przy odmontowaniu, hook pomija, więc nie wznowi połączenia po wyjściu z czatu.
Czat w czasie rzeczywistym
ChatRoom po otwarciu połączenia wysyła wiadomość join, a każdą odebraną wiadomość rozdziela instrukcją switch według pola type:
// components/ChatRoom.jsx
import React, { useState, useEffect, useRef } from 'react';
import useWebSocket from '../hooks/useWebSocket';
const ChatRoom = ({ roomId, userId, userName }) => {
const [messages, setMessages] = useState([]);
const [newMessage, setNewMessage] = useState('');
const [typingUsers, setTypingUsers] = useState(new Set());
const [onlineUsers, setOnlineUsers] = useState(new Map());
const messagesEndRef = useRef(null);
const typingTimeoutRef = useRef(null);
const {
sendMessage,
lastMessage,
isOpen,
connectionError,
addMessageListener
} = useWebSocket(`ws://localhost:8080/chat/${roomId}`, {
onOpen: () => {
// Dołącz do pokoju
sendMessage({
type: 'join',
roomId,
userId,
userName
});
}
});
// Obsługa otrzymanych wiadomości
useEffect(() => {
if (!lastMessage) return;
const { data } = lastMessage;
switch (data.type) {
case 'message':
setMessages(prev => [...prev, {
id: data.id,
text: data.text,
userId: data.userId,
userName: data.userName,
timestamp: data.timestamp
}]);
break;
case 'typing':
setTypingUsers(prev => {
const newSet = new Set(prev);
if (data.isTyping && data.userId !== userId) {
newSet.add(data.userName);
} else {
newSet.delete(data.userName);
}
return newSet;
});
break;
case 'userJoined':
setOnlineUsers(prev => new Map(prev).set(data.userId, data.userName));
setMessages(prev => [...prev, {
id: `system-${Date.now()}`,
text: `${data.userName} dołączył do czatu`,
type: 'system',
timestamp: Date.now()
}]);
break;
case 'userLeft':
setOnlineUsers(prev => {
const newMap = new Map(prev);
newMap.delete(data.userId);
return newMap;
});
setMessages(prev => [...prev, {
id: `system-${Date.now()}`,
text: `${data.userName} opuścił czat`,
type: 'system',
timestamp: Date.now()
}]);
break;
case 'messageDeleted':
setMessages(prev => prev.filter(msg => msg.id !== data.messageId));
break;
case 'messageEdited':
setMessages(prev => prev.map(msg =>
msg.id === data.messageId
? { ...msg, text: data.newText, edited: true }
: msg
));
break;
}
}, [lastMessage, userId]);
// Auto-scroll do najnowszej wiadomości
useEffect(() => {
messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
}, [messages]);
// Wysyłanie wiadomości
const handleSendMessage = (e) => {
e.preventDefault();
if (newMessage.trim() && isOpen) {
sendMessage({
type: 'message',
text: newMessage.trim(),
roomId,
userId,
userName
});
setNewMessage('');
handleStopTyping();
}
};
// Obsługa pisania
const handleTyping = (e) => {
setNewMessage(e.target.value);
if (!typingTimeoutRef.current) {
sendMessage({
type: 'typing',
isTyping: true,
userId,
userName,
roomId
});
}
clearTimeout(typingTimeoutRef.current);
typingTimeoutRef.current = setTimeout(() => {
handleStopTyping();
}, 2000);
};
const handleStopTyping = () => {
if (typingTimeoutRef.current) {
clearTimeout(typingTimeoutRef.current);
typingTimeoutRef.current = null;
sendMessage({
type: 'typing',
isTyping: false,
userId,
userName,
roomId
});
}
};
// Usuwanie wiadomości
const handleDeleteMessage = (messageId) => {
sendMessage({
type: 'deleteMessage',
messageId,
userId
});
};
if (connectionError) {
return (
<div className="chat-error">
<h3>Błąd połączenia z czatem</h3>
<p>{connectionError.message}</p>
<button onClick={() => window.location.reload()}>
Spróbuj ponownie
</button>
</div>
);
}
return (
<div className="chat-room">
<div className="chat-header">
<h2>Pokój: {roomId}</h2>
<div className="online-users">
Online ({onlineUsers.size}): {Array.from(onlineUsers.values()).join(', ')}
</div>
<div className="connection-status">
Status: {isOpen ? 'Połączony' : 'Rozłączony'}
</div>
</div>
<div className="chat-messages">
{messages.map(message => (
<div
key={message.id}
className={`message ${message.type === 'system' ? 'system' : ''} ${message.userId === userId ? 'own' : ''}`}
>
{message.type !== 'system' && (
<div className="message-header">
<span className="username">{message.userName}</span>
<span className="timestamp">
{new Date(message.timestamp).toLocaleTimeString()}
</span>
{message.userId === userId && (
<button
onClick={() => handleDeleteMessage(message.id)}
className="delete-btn"
>
Usuń
</button>
)}
</div>
)}
<div className="message-text">
{message.text}
{message.edited && <span className="edited"> (edytowane)</span>}
</div>
</div>
))}
{typingUsers.size > 0 && (
<div className="typing-indicator">
{Array.from(typingUsers).join(', ')} pisze...
</div>
)}
<div ref={messagesEndRef} />
</div>
<form onSubmit={handleSendMessage} className="chat-input">
<input
type="text"
value={newMessage}
onChange={handleTyping}
onBlur={handleStopTyping}
disabled={!isOpen}
maxLength={500}
/>
<button type="submit" disabled={!isOpen || !newMessage.trim()}>
Wyślij
</button>
</form>
</div>
);
};
export default ChatRoom;Typy typing, userJoined i messageEdited to protokół umówiony z serwerem, a nie część standardu WebSocket. Wskaźnik pisania wysyła isTyping: false po dwóch sekundach ciszy, więc nie zalewa serwera wiadomościami.
Middleware i autoryzacja
Wraz z rozwojem czatu przybywa reguł dla wiadomości. WebSocketMiddleware przepuszcza je przez łańcuch funkcji, jak celnik na śluzie:
// utils/websocketMiddleware.js
class WebSocketMiddleware {
constructor() {
this.middlewares = [];
}
use(middleware) {
this.middlewares.push(middleware);
}
async processIncoming(message, socket) {
let processedMessage = message;
for (const middleware of this.middlewares) {
try {
processedMessage = await middleware.incoming(processedMessage, socket);
if (!processedMessage) break; // Middleware może zatrzymać przetwarzanie
} catch (error) {
console.error('Middleware error (incoming):', error);
break;
}
}
return processedMessage;
}
async processOutgoing(message, socket) {
let processedMessage = message;
for (const middleware of this.middlewares) {
try {
processedMessage = await middleware.outgoing(processedMessage, socket);
if (!processedMessage) break;
} catch (error) {
console.error('Middleware error (outgoing):', error);
break;
}
}
return processedMessage;
}
}
// Middleware do autentykacji
const authMiddleware = {
incoming: async (message, socket) => {
if (message.type === 'auth') {
const token = message.token;
const isValid = await validateToken(token);
if (isValid) {
socket.isAuthenticated = true;
socket.userId = getUserIdFromToken(token);
return { type: 'authSuccess', userId: socket.userId };
} else {
socket.close(4001, 'Unauthorized');
return null;
}
}
if (!socket.isAuthenticated && message.type !== 'auth') {
socket.send(JSON.stringify({
type: 'error',
message: 'Authentication required'
}));
return null;
}
return message;
},
outgoing: async (message, socket) => {
if (!socket.isAuthenticated && message.type !== 'authRequired') {
return null;
}
return message;
}
};
// Middleware do rate limiting
const rateLimitMiddleware = {
incoming: async (message, socket) => {
if (!socket.messageCount) {
socket.messageCount = 0;
socket.lastReset = Date.now();
}
const now = Date.now();
const timePassed = now - socket.lastReset;
// Reset co minutę
if (timePassed > 60000) {
socket.messageCount = 0;
socket.lastReset = now;
}
socket.messageCount++;
// Maksymalnie 100 wiadomości na minutę
if (socket.messageCount > 100) {
socket.send(JSON.stringify({
type: 'error',
message: 'Rate limit exceeded'
}));
return null;
}
return message;
},
outgoing: async (message, socket) => message
};
// Hook z middleware
const useAdvancedWebSocket = (url, options = {}) => {
// Middleware rejestrujemy raz, przy pierwszym renderze (efekt StrictMode uruchomiłby dwa razy)
const middleware = useRef(null);
if (middleware.current === null) {
middleware.current = new WebSocketMiddleware();
middleware.current.use(authMiddleware);
middleware.current.use(rateLimitMiddleware);
}
const { sendMessage: baseSendMessage, socket, ...rest } = useWebSocket(url, {
...options,
onMessage: async (data, event) => {
const processed = await middleware.current.processIncoming(data, event.target);
if (processed) {
options.onMessage?.(processed, event);
}
}
});
const sendMessage = useCallback(async (message) => {
if (socket) {
const processed = await middleware.current.processOutgoing(message, socket);
if (processed) {
return baseSendMessage(processed);
}
}
return false;
}, [socket, baseSendMessage]);
return {
...rest,
sendMessage,
socket
};
};Middleware zwracający null zatrzymuje wiadomość. useAdvancedWebSocket rejestruje middleware raz, przy pierwszym renderze, a gniazdo bierze z useWebSocket. Prawdziwa autoryzacja i limitowanie muszą jednak działać na serwerze, bo kod w przeglądarce użytkownik może zmienić, a po stronie klienta taki middleware tylko porządkuje ruch.
Server-Sent Events (SSE) - jednostronna komunikacja
SSE to zwykła odpowiedź HTTP z typem text/event-stream, której serwer nie zamyka, tylko dopisuje kolejne zdarzenia. Dane płyną wyłącznie od serwera do klienta i tylko jako tekst. W zamian przeglądarkowy EventSource sam wznawia zerwane połączenie i wysyła nagłówek Last-Event-ID, żeby nie zgubić zdarzeń. Hook useServerSentEvents opakowuje go i obsługuje nazwane zdarzenia:
// hooks/useServerSentEvents.js
import { useState, useEffect, useRef, useCallback } from 'react';
const useServerSentEvents = (url, options = {}) => {
const [data, setData] = useState(null);
const [readyState, setReadyState] = useState(0);
const [error, setError] = useState(null);
const eventSourceRef = useRef(null);
const listenersRef = useRef(new Map());
// Najnowsze opcje bez ponownego łączenia, jak w useWebSocket
const optionsRef = useRef(options);
useEffect(() => {
optionsRef.current = options;
});
const { withCredentials = false } = options;
const connect = useCallback(() => {
try {
const eventSource = new EventSource(url, { withCredentials });
eventSourceRef.current = eventSource;
eventSource.onopen = (event) => {
console.log('SSE połączone:', url);
setReadyState(1); // OPEN
setError(null);
optionsRef.current.onOpen?.(event);
};
eventSource.onmessage = (event) => {
let parsedData;
try {
parsedData = JSON.parse(event.data);
} catch {
parsedData = event.data;
}
setData({
data: parsedData,
timestamp: Date.now(),
id: event.lastEventId,
type: event.type
});
optionsRef.current.onMessage?.(parsedData, event);
};
eventSource.onerror = (event) => {
console.error('SSE błąd:', event);
setReadyState(eventSource.readyState); // 0 = przeglądarka łączy się ponownie, 2 = zamknięte
setError(event);
optionsRef.current.onError?.(event);
};
// Dodaj custom event listeners
listenersRef.current.forEach((listener, eventType) => {
eventSource.addEventListener(eventType, listener);
});
} catch (err) {
console.error('Nie udało się utworzyć EventSource:', err);
setError(err);
}
}, [url, withCredentials]);
const addEventListener = useCallback((eventType, listener) => {
listenersRef.current.set(eventType, listener);
if (eventSourceRef.current) {
eventSourceRef.current.addEventListener(eventType, listener);
}
return () => {
listenersRef.current.delete(eventType);
if (eventSourceRef.current) {
eventSourceRef.current.removeEventListener(eventType, listener);
}
};
}, []);
const close = useCallback(() => {
if (eventSourceRef.current) {
eventSourceRef.current.close();
eventSourceRef.current = null;
setReadyState(2);
}
}, []);
useEffect(() => {
connect();
return () => {
close();
};
}, [connect, close]);
return {
data,
readyState,
error,
addEventListener,
close,
reconnect: connect,
isConnecting: readyState === 0,
isOpen: readyState === 1,
isClosed: readyState === 2
};
};
export default useServerSentEvents;onmessage łapie zdarzenia bez nazwy, a addEventListener('metrics', ...) te z polem event: metrics. W onerror hook zapisuje eventSource.readyState: 0 oznacza, że przeglądarka sama łączy się ponownie, a 2, że połączenie zamknięto na dobre. O ponowieniach decyduje przeglądarka i pole retry: od serwera, więc hook nie liczy prób sam. Opcje czyta z optionsRef, tak jak useWebSocket, więc onMessage podany inline nie otwiera połączenia od nowa przy każdym renderze.
LiveDashboard nasłuchuje czterech nazwanych zdarzeń: metryk, powiadomień, statusu i alertów:
// components/LiveDashboard.jsx
import React, { useState, useEffect } from 'react';
import useServerSentEvents from '../hooks/useServerSentEvents';
const LiveDashboard = () => {
const [metrics, setMetrics] = useState({
activeUsers: 0,
serverLoad: 0,
memoryUsage: 0,
requestsPerSecond: 0
});
const [notifications, setNotifications] = useState([]);
const [systemStatus, setSystemStatus] = useState('healthy');
const [lastUpdate, setLastUpdate] = useState(null);
const { data, isOpen, error, addEventListener } = useServerSentEvents(
'/api/dashboard/stream',
{
onMessage: (data) => {
setLastUpdate(new Date());
}
}
);
// Handler dla różnych typów eventów
useEffect(() => {
const removeMetricsListener = addEventListener('metrics', (event) => {
const metricsData = JSON.parse(event.data);
setMetrics(metricsData);
});
const removeNotificationListener = addEventListener('notification', (event) => {
const notification = JSON.parse(event.data);
setNotifications(prev => [notification, ...prev.slice(0, 9)]); // Maksymalnie 10 notyfikacji
});
const removeStatusListener = addEventListener('status', (event) => {
const status = JSON.parse(event.data);
setSystemStatus(status.level);
});
const removeAlertListener = addEventListener('alert', (event) => {
const alert = JSON.parse(event.data);
// Pokazuj alert jako browser notification
if (Notification.permission === 'granted') {
new Notification(`System Alert: ${alert.type}`, {
body: alert.message,
icon: '/icons/alert.png'
});
}
setNotifications(prev => [{
...alert,
type: 'alert',
timestamp: Date.now()
}, ...prev.slice(0, 9)]);
});
return () => {
removeMetricsListener();
removeNotificationListener();
removeStatusListener();
removeAlertListener();
};
}, [addEventListener]);
// O zgodę pytaj po kliknięciu: Firefox i Safari ignorują prośbę bez gestu użytkownika
const [notificationPermission, setNotificationPermission] = useState(Notification.permission);
const requestNotifications = async () => {
setNotificationPermission(await Notification.requestPermission());
};
const getStatusColor = (status) => {
switch (status) {
case 'healthy': return '#4CAF50';
case 'warning': return '#FF9800';
case 'critical': return '#F44336';
default: return '#9E9E9E';
}
};
const getMetricColor = (value, thresholds) => {
if (value >= thresholds.critical) return '#F44336';
if (value >= thresholds.warning) return '#FF9800';
return '#4CAF50';
};
if (error) {
return (
<div className="dashboard-error">
<h2>Błąd połączenia z dashboard</h2>
<p>Nie można nawiązać połączenia z serwerem monitoringu.</p>
<button onClick={() => window.location.reload()}>
Odśwież stronę
</button>
</div>
);
}
return (
<div className="live-dashboard">
<header className="dashboard-header">
<h1>Live Dashboard</h1>
<div className="connection-info">
<span
className={`status-indicator ${isOpen ? 'connected' : 'disconnected'}`}
style={{ backgroundColor: isOpen ? '#4CAF50' : '#F44336' }}
/>
{isOpen ? 'Połączony' : 'Rozłączony'}
{lastUpdate && (
<span className="last-update">
Ostatnia aktualizacja: {lastUpdate.toLocaleTimeString()}
</span>
)}
</div>
{notificationPermission === 'default' && (
<button onClick={requestNotifications}>Włącz powiadomienia</button>
)}
</header>
<div className="metrics-grid">
<div className="metric-card">
<h3>Aktywni użytkownicy</h3>
<div
className="metric-value"
style={{ color: getMetricColor(metrics.activeUsers, { warning: 1000, critical: 1500 }) }}
>
{metrics.activeUsers.toLocaleString()}
</div>
</div>
<div className="metric-card">
<h3>Obciążenie serwera</h3>
<div
className="metric-value"
style={{ color: getMetricColor(metrics.serverLoad, { warning: 70, critical: 90 }) }}
>
{metrics.serverLoad}%
</div>
<div className="progress-bar">
<div
className="progress-fill"
style={{
width: `${metrics.serverLoad}%`,
backgroundColor: getMetricColor(metrics.serverLoad, { warning: 70, critical: 90 })
}}
/>
</div>
</div>
<div className="metric-card">
<h3>Użycie pamięci</h3>
<div
className="metric-value"
style={{ color: getMetricColor(metrics.memoryUsage, { warning: 80, critical: 95 }) }}
>
{metrics.memoryUsage}%
</div>
<div className="progress-bar">
<div
className="progress-fill"
style={{
width: `${metrics.memoryUsage}%`,
backgroundColor: getMetricColor(metrics.memoryUsage, { warning: 80, critical: 95 })
}}
/>
</div>
</div>
<div className="metric-card">
<h3>Żądania/sek</h3>
<div
className="metric-value"
style={{ color: getMetricColor(metrics.requestsPerSecond, { warning: 1000, critical: 2000 }) }}
>
{metrics.requestsPerSecond}
</div>
</div>
</div>
<div className="system-status">
<h3>Status systemu</h3>
<div
className="status-badge"
style={{
backgroundColor: getStatusColor(systemStatus),
color: 'white',
padding: '8px 16px',
borderRadius: '20px',
display: 'inline-block'
}}
>
{systemStatus.toUpperCase()}
</div>
</div>
<div className="notifications-panel">
<h3>Powiadomienia ({notifications.length})</h3>
<div className="notifications-list">
{notifications.map((notification, index) => (
<div
key={index}
className={`notification ${notification.type || 'info'}`}
>
<div className="notification-content">
<strong>{notification.title || notification.type}</strong>
<p>{notification.message}</p>
</div>
<div className="notification-time">
{new Date(notification.timestamp).toLocaleTimeString()}
</div>
</div>
))}
</div>
</div>
</div>
);
};
export default LiveDashboard;Każdy listener zwraca funkcję sprzątającą, więc cleanup efektu odpina je wszystkie. Alert trafia też do systemowego powiadomienia, jeśli użytkownik wcześniej się na nie zgodził. O zgodę prosi przycisk, bo Firefox i Safari ignorują prośbę o uprawnienie, która nie wynika z gestu użytkownika.
Wybór między WebSockets a SSE
Kiedy używać WebSockets
Edytor we współpracy to podręcznikowy przypadek WebSocket: każdy użytkownik nadaje zmiany tekstu i ruchy kursora, a jednocześnie odbiera cudze:
// Przykład: Aplikacja do kolaboracji w czasie rzeczywistym
const CollaborativeEditor = () => {
const { sendMessage, lastMessage, isOpen } = useWebSocket('/ws/document/123');
const [documentContent, setDocumentContent] = useState('');
const [cursors, setCursors] = useState(new Map());
const handleTextChange = (newContent, position) => {
setDocumentContent(newContent);
// Wyślij zmianę do innych użytkowników
sendMessage({
type: 'content_change',
content: newContent,
position,
userId: currentUser.id
});
};
const handleCursorMove = (position) => {
sendMessage({
type: 'cursor_move',
position,
userId: currentUser.id
});
};
useEffect(() => {
if (lastMessage) {
switch (lastMessage.data.type) {
case 'content_change':
setDocumentContent(lastMessage.data.content);
break;
case 'cursor_move':
setCursors(prev => new Map(prev).set(
lastMessage.data.userId,
lastMessage.data.position
));
break;
}
}
}, [lastMessage]);
return (
<div className="collaborative-editor">
{/* Edytor z real-time collaboration */}
</div>
);
};Ruch płynie w obie strony wiele razy na sekundę, więc jedno trwałe połączenie wygrywa z serią osobnych żądań HTTP.
Kiedy używać SSE
Kanał wiadomości to odwrotny przypadek: czytelnik tylko odbiera nowe artykuły, więc wystarczy SSE:
// Przykład: Live feed aktualności
const NewsFeed = () => {
const [articles, setArticles] = useState([]);
const [newArticleCount, setNewArticleCount] = useState(0);
const { data, addEventListener } = useServerSentEvents('/api/news/stream');
useEffect(() => {
const removeArticleListener = addEventListener('new_article', (event) => {
const article = JSON.parse(event.data);
setArticles(prev => [article, ...prev]);
setNewArticleCount(prev => prev + 1);
});
const removeUpdateListener = addEventListener('article_update', (event) => {
const updatedArticle = JSON.parse(event.data);
setArticles(prev => prev.map(article =>
article.id === updatedArticle.id ? updatedArticle : article
));
});
return () => {
removeArticleListener();
removeUpdateListener();
};
}, [addEventListener]);
return (
<div className="news-feed">
{newArticleCount > 0 && (
<div className="new-articles-banner">
{newArticleCount} nowych artykułów
<button onClick={() => setNewArticleCount(0)}>
Oznacz jako przeczytane
</button>
</div>
)}
{articles.map(article => (
<ArticleCard key={article.id} article={article} />
))}
</div>
);
};Nie ma tu żadnego sendMessage. Jeśli klient czasem coś wysyła, na przykład oznacza artykuł jako przeczytany, zrobi to zwykłym żądaniem HTTP.
Porównanie i najlepsze praktyki
Na koniec pomocnik, który wybiera technologię na podstawie wymagań:
// Wybór technologii na podstawie wymagań - zwykła funkcja, nie hook
const chooseTransport = ({
bidirectional = false,
authentication = false,
highFrequency = false,
binaryData = false
} = {}) =>
bidirectional || authentication || highFrequency || binaryData ? 'websocket' : 'sse';
// Każdy kanał to osobny komponent, który zawsze wywołuje ten sam hook
function WebSocketChannel({ url }) {
const { sendMessage, lastMessage } = useWebSocket(url.replace('http', 'ws'));
// Logika dla WebSocket
return <div>Kanał WebSocket</div>;
}
function SseChannel({ url }) {
const { data, addEventListener } = useServerSentEvents(url);
// Logika dla SSE
return <div>Kanał SSE</div>;
}
// Przykład użycia
const SmartComponent = () => {
const transport = chooseTransport({
bidirectional: true, // Wymaga WebSocket
authentication: true
});
return transport === 'websocket'
? <WebSocketChannel url="/api/data" />
: <SseChannel url="/api/data" />;
};authentication wskazuje WebSocket, bo EventSource nie pozwala dodać własnych nagłówków, jak Authorization. Sam wybór to zwykła funkcja, a hooki wywołują osobne komponenty, więc każdy z nich woła zawsze ten sam hook w tej samej kolejności, czego wymagają zasady hooków. Warunkowe wywołanie useWebSocket albo useServerSentEvents w jednym komponencie te zasady łamie.
Moja rada: gdy dane płyną tylko od serwera, zacznij od SSE, bo to zwykłe HTTP z automatycznym wznawianiem. Po WebSocket sięgaj, gdy klient też często nadaje. W ćwiczeniu zbudujesz własny hook z połączeniem, rozłączaniem, wysyłką i wskaźnikiem statusu.
Pamiętaj: WebSocket to dwukierunkowy kanał radiowy, a SSE to nadajnik, który tylko nadaje - wybierz ten, który pasuje do rozmowy.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef, useCallback } from 'react';
// Symulacja serwera WebSocket: strumień telemetrii statku i odpowiedzi na komendy klienta
// Prawdziwy kod użyłby new WebSocket(url) z handlerami onopen, onmessage i onclose
class MockWebSocketServer {
constructor() {
this.handlers = null;
this.openTimer = null;
this.interval = null;
}
connect(handlers) {
this.handlers = handlers;
this.openTimer = setTimeout(() => {
handlers.onOpen();
this.interval = setInterval(() => {
handlers.onMessage({
type: 'TELEMETRY',
timestamp: Date.now(),
data: {
speed: (27600 + Math.random() * 400).toFixed(0),
altitude: (408 + Math.random() * 2).toFixed(1),
fuel: (85 - Math.random() * 0.5).toFixed(1),
temperature: (20 + Math.random() * 3).toFixed(1),
oxygen: (98.5 + Math.random() * 1.5).toFixed(1),
},
});
}, 1500);
}, 400);
}
// Serwer odpowiada na komendę klienta - komunikacja w obie strony
send(message) {
setTimeout(() => {
this.handlers?.onMessage({ type: 'ACK', command: message.command, timestamp: Date.now() });
}, 300);
}
// Zerwane łącze: zamknięcie bez czystego zakończenia (wasClean: false)
drop() {
const handlers = this.handlers;
this.stop();
handlers?.onClose({ wasClean: false });
}
close() {
const handlers = this.handlers;
this.stop();
handlers?.onClose({ wasClean: true });
}
stop() {
clearTimeout(this.openTimer);
clearInterval(this.interval);
this.handlers = null;
}
}
// Symulacja Server-Sent Events: serwer sam wysyła powiadomienia misji, klient tylko słucha
class MockSSEServer {
subscribe(onEvent) {
const events = [
{ type: 'mission_update', data: 'Misja Nebula: etap 3 ukończony' },
{ type: 'alert', data: 'Wykryto anomalię grawitacyjną w sektorze 7' },
{ type: 'crew_message', data: 'Dr. Stellar: analiza próbek zakończona' },
{ type: 'system', data: 'Dostępna aktualizacja oprogramowania nawigacyjnego' },
{ type: 'alert', data: 'Zbliżamy się do pola asteroid - zmiana kursu' },
{ type: 'mission_update', data: 'Nowa misja przydzielona: eksploracja Io' },
];
let index = 0;
const interval = setInterval(() => {
const event = events[index % events.length];
index++;
onEvent({ ...event, id: index, timestamp: new Date().toLocaleTimeString('pl') });
}, 2500);
return () => clearInterval(interval);
}
}
const MAX_RETRIES = 3;
const RETRY_DELAY = 2000;
// Hook do obsługi WebSocket: po zerwaniu łącza próbuje połączyć się ponownie
// co 2 sekundy, najwyżej 3 razy; zamknięcie przez użytkownika nie wznawia połączenia
function useWebSocket() {
const [status, setStatus] = useState('DISCONNECTED');
const [messages, setMessages] = useState([]);
const [attempt, setAttempt] = useState(0);
const serverRef = useRef(null);
const retryRef = useRef({ count: 0, timer: null });
const connect = useCallback(function openConnection() {
const server = new MockWebSocketServer();
serverRef.current = server;
setStatus('CONNECTING');
server.connect({
onOpen: () => {
retryRef.current.count = 0;
setAttempt(0);
setStatus('CONNECTED');
},
onMessage: (message) => setMessages((prev) => [message, ...prev].slice(0, 20)),
onClose: ({ wasClean }) => {
serverRef.current = null;
if (wasClean || retryRef.current.count >= MAX_RETRIES) {
setStatus('DISCONNECTED');
return;
}
// Nieczyste zamknięcie: kolejna próba po RETRY_DELAY
retryRef.current.count += 1;
setAttempt(retryRef.current.count);
setStatus('RECONNECTING');
retryRef.current.timer = setTimeout(openConnection, RETRY_DELAY);
},
});
}, []);
const disconnect = useCallback(() => {
clearTimeout(retryRef.current.timer);
retryRef.current.count = 0;
setAttempt(0);
if (serverRef.current) serverRef.current.close();
else setStatus('DISCONNECTED');
}, []);
const simulateDrop = useCallback(() => {
serverRef.current?.drop();
}, []);
const sendCommand = useCallback((command) => {
const message = { type: 'COMMAND', command, timestamp: Date.now() };
setMessages((prev) => [message, ...prev].slice(0, 20));
serverRef.current?.send(message);
}, []);
// Odmontowanie: zatrzymaj serwer i zaplanowaną próbę połączenia
useEffect(() => {
const retry = retryRef.current;
return () => {
clearTimeout(retry.timer);
serverRef.current?.stop();
};
}, []);
return { status, attempt, messages, connect, disconnect, simulateDrop, sendCommand };
}
const STATUS_LABELS = {
CONNECTING: 'Łączenie...',
CONNECTED: 'Połączono',
RECONNECTING: 'Ponowne łączenie',
DISCONNECTED: 'Rozłączono',
};
const STATUS_COLORS = { CONNECTING: '#ffa500', CONNECTED: '#00ff88', RECONNECTING: '#ffa500', DISCONNECTED: '#ff6b6b' };
function TelemetryPanel() {
const { status, attempt, messages, connect, disconnect, simulateDrop, sendCommand } = useWebSocket();
const latest = messages.find((message) => message.type === 'TELEMETRY')?.data;
const lastAck = messages.find((message) => message.type === 'ACK');
const connected = status === 'CONNECTED';
const idle = status === 'DISCONNECTED';
const metrics = latest ? [
{ label: 'Prędkość', value: `${latest.speed} km/h` },
{ label: 'Wysokość', value: `${latest.altitude} km` },
{ label: 'Paliwo', value: `${latest.fuel}%` },
{ label: 'Temperatura', value: `${latest.temperature} °C` },
{ label: 'Tlen', value: `${latest.oxygen}%` },
] : [];
return (
<div style={styles.panel}>
<div style={styles.panelHeader}>
<h3 style={styles.heading}>WebSocket - telemetria</h3>
<div style={{ display: 'flex', gap: '8px', alignItems: 'center' }}>
<span style={{ ...styles.dot, background: STATUS_COLORS[status] }} />
<span style={{ color: '#8892b0', fontSize: '12px' }}>
{STATUS_LABELS[status]}{status === 'RECONNECTING' ? ` (${attempt}/${MAX_RETRIES})` : ''}
</span>
</div>
</div>
<div style={styles.buttons}>
<button onClick={connect} disabled={!idle} style={{ ...styles.btn, opacity: idle ? 1 : 0.4 }}>Połącz</button>
<button onClick={disconnect} disabled={idle} style={{ ...styles.btnDanger, opacity: idle ? 0.4 : 1 }}>Rozłącz</button>
<button onClick={simulateDrop} disabled={!connected} style={{ ...styles.btnDanger, opacity: connected ? 1 : 0.4 }}>Zerwij łącze</button>
<button onClick={() => sendCommand('PING')} disabled={!connected} style={{ ...styles.btn, opacity: connected ? 1 : 0.4 }}>Wyślij ping</button>
</div>
{latest && (
<div style={styles.metrics}>
{metrics.map((metric) => (
<div key={metric.label} style={styles.metricCard}>
<div style={{ color: '#8892b0', fontSize: '11px' }}>{metric.label}</div>
<div style={{ color: '#00d4ff', fontSize: '17px', fontWeight: 'bold' }}>{metric.value}</div>
</div>
))}
</div>
)}
{lastAck && <p style={{ color: '#00ff88', fontSize: '12px', margin: '12px 0 0' }}>Serwer potwierdził komendę {lastAck.command} o {new Date(lastAck.timestamp).toLocaleTimeString('pl')}</p>}
{!latest && idle && <p style={styles.empty}>Kliknij "Połącz", aby uruchomić strumień danych.</p>}
</div>
);
}
const EVENT_LABELS = { mission_update: 'misja', alert: 'alarm', crew_message: 'załoga', system: 'system' };
const EVENT_COLORS = { mission_update: '#00ff88', alert: '#ff6b6b', crew_message: '#ffa500', system: '#00d4ff' };
function SSENotificationsPanel() {
const [events, setEvents] = useState([]);
const [listening, setListening] = useState(false);
const unsubscribeRef = useRef(null);
const startListening = () => {
unsubscribeRef.current = new MockSSEServer().subscribe((event) => {
setEvents((prev) => [event, ...prev].slice(0, 15));
});
setListening(true);
};
const stopListening = () => {
unsubscribeRef.current?.();
unsubscribeRef.current = null;
setListening(false);
};
// Przy odmontowaniu zamknij subskrypcję
useEffect(() => () => unsubscribeRef.current?.(), []);
return (
<div style={styles.panel}>
<div style={styles.panelHeader}>
<h3 style={styles.heading}>SSE - powiadomienia</h3>
<button onClick={listening ? stopListening : startListening} style={listening ? styles.btnDanger : styles.btn}>
{listening ? 'Zatrzymaj' : 'Subskrybuj'}
</button>
</div>
<div style={{ maxHeight: '300px', overflowY: 'auto' }}>
{events.length === 0 && <p style={styles.empty}>Brak powiadomień - kliknij "Subskrybuj".</p>}
{events.map((event) => (
<div key={event.id} style={{ ...styles.event, borderLeftColor: EVENT_COLORS[event.type] }}>
<div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: '2px' }}>
<span style={{ color: EVENT_COLORS[event.type], fontSize: '11px', textTransform: 'uppercase', fontWeight: 'bold' }}>{EVENT_LABELS[event.type]}</span>
<span style={{ color: '#8892b0', fontSize: '11px' }}>{event.timestamp}</span>
</div>
<div style={{ color: '#e0e1dd', fontSize: '13px' }}>{event.data}</div>
</div>
))}
</div>
</div>
);
}
function App() {
return (
<div style={styles.container}>
<h1 style={styles.title}>Centrum łączności w czasie rzeczywistym</h1>
<p style={styles.subtitle}>WebSockets i Server-Sent Events w React</p>
<div style={styles.grid}>
<TelemetryPanel />
<SSENotificationsPanel />
</div>
<p style={styles.note}>WebSocket przesyła dane w obie strony: serwer wysyła telemetrię, a klient komendy, jak ping. "Zerwij łącze" pokazuje ponowne łączenie. SSE płynie tylko od serwera do klienta, więc panel powiadomień niczego nie wysyła.</p>
</div>
);
}
const styles = {
container: { minHeight: '100vh', background: 'linear-gradient(135deg, #0d1b2a 0%, #1a1a3e 100%)', padding: '24px 16px', color: '#e0e1dd', fontFamily: 'system-ui, sans-serif', boxSizing: 'border-box' },
title: { textAlign: 'center', color: '#00d4ff', margin: '0 0 4px', fontSize: '24px' },
subtitle: { textAlign: 'center', color: '#8892b0', marginBottom: '20px' },
grid: { display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(280px, 1fr))', gap: '16px' },
panel: { background: 'rgba(0,0,0,0.3)', borderRadius: '12px', padding: '16px', border: '1px solid rgba(0,212,255,0.2)' },
panelHeader: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: '8px', flexWrap: 'wrap', marginBottom: '12px' },
heading: { color: '#00d4ff', margin: 0, fontSize: '17px' },
dot: { width: '10px', height: '10px', borderRadius: '50%', display: 'inline-block' },
buttons: { display: 'flex', gap: '8px', flexWrap: 'wrap', marginBottom: '12px' },
metrics: { display: 'grid', gridTemplateColumns: 'repeat(auto-fill, minmax(90px, 1fr))', gap: '8px' },
metricCard: { padding: '10px', background: 'rgba(0,212,255,0.05)', borderRadius: '8px', textAlign: 'center', border: '1px solid rgba(0,212,255,0.15)' },
event: { padding: '8px 12px', borderLeft: '3px solid', background: 'rgba(0,0,0,0.2)', marginBottom: '6px', borderRadius: '0 6px 6px 0' },
empty: { color: '#8892b0', textAlign: 'center', fontSize: '13px' },
btn: { padding: '8px 12px', background: 'rgba(0,212,255,0.15)', border: '1px solid #00d4ff', borderRadius: '6px', color: '#00d4ff', cursor: 'pointer', fontSize: '13px' },
btnDanger: { padding: '8px 12px', background: 'rgba(255,107,107,0.15)', border: '1px solid #ff6b6b', borderRadius: '6px', color: '#ff6b6b', cursor: 'pointer', fontSize: '13px' },
note: { maxWidth: '760px', margin: '16px auto 0', color: '#8892b0', fontSize: '13px', lineHeight: 1.5 },
};
export default App;Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Kiedy WebSocket jest lepszym wyborem niż REST API w aplikacji React?
2. Czym Server-Sent Events (SSE) różni się od WebSocket?
Zadania praktyczne w grze
- Edytor kodu
Dokończ hook useMissionSocket, który obsługuje kanał łączności ze stacją. Gniazdo tworzy createSocket(url) - w podglądzie to symulator stacji o takim samym interfejsie jak WebSocket. ___BLANK1___: w onmessage zamień tekst z event.data na obiekt wiadomości przez JSON.parse. ___BLANK2___: funkcja cleanup efektu zamyka gniazdo metodą close(), gdy komponent znika (także przy podwójnym uruchomieniu efektu w StrictMode). ___BLANK3___: send wysyła obiekt { text } zamieniony na tekst przez JSON.stringify. Po kilku sekundach w podglądzie pojawi się telemetria, a każda Twoja wiadomość wróci jako echo.