Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React

WebSockets i Server-Sent Events w React

17 min czytania ·
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. 1. Kiedy WebSocket jest lepszym wyborem niż REST API w aplikacji React?

  2. 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.

  1. PytanieWebSocket vs REST
  2. Zadanie z kodemPraktyka: Komunikacja WebSocket
  3. PytanieServer-Sent Events vs WebSocket

Przydatne artykuły