Socket.IO — ce este, biblioteca pentru interacțiune în timp real

Ce este Socket.IO?

Socket.IO este o bibliotecă JavaScript open-source pentru comunicarea bidirecțională orientată pe evenimente între client și server. A fost creată în 2010 de dezvoltatorul Guillermo Rauch și de atunci a devenit standardul de facto pentru aplicațiile în timp real pe Node.js.

Spre deosebire de WebSocket API nativ, Socket.IO oferă abstracții suplimentare: camere, spații de nume, reconectare automată și tipuri de date binare. Biblioteca nu este o implementare separată a WebSocket — utilizează Engine.IO ca strat de transport, care stabilește mai întâi o conexiune HTTP long-polling, apoi încearcă upgrade la WebSocket.

Conform statisticilor npm (2025), săptămânal se descarcă peste 12 milioane de copii ale pachetului socket.io, făcându-l una dintre cele mai populare biblioteci din ecosistemul Node.js. Socket.IO este suportat pe toate platformele moderne: browsere, iOS, Android, React Native și aplicații desktop.

Istoricul creării și versiunile

Socket.IO versiunea 1.0 a fost lansat în 2014 și a introdus conceptul de spații de nume (namespaces), care permit multiplexarea mai multor canale logice printr-o singură conexiune TCP. Versiunea 2.0 (2017) a adăugat suport pentru date binare și a îmbunătățit performanța de parsare. Versiunea curentă 4.x (2020–2025) include suport complet pentru TypeScript, modul de adaptare pentru scalare și compatibilitate inversă îmbunătățită.

Fiecare versiune majoră păstrează compatibilitatea inversă a API — clientul socket.io@2 se poate conecta la serverul socket.io@4 printr-un mod special de compatibilitate. Acest lucru este important pentru proiectele de lungă durată unde actualizarea părții client are loc treptat.

Cum funcționează Socket.IO

Arhitectura Socket.IO constă din două componente: modulul server (pachetul npm socket.io) și modulul client (pachetul npm socket.io-client). Serverul funcționează pe un server HTTP(S) Node.js și utilizează Engine.IO pentru gestionarea stratului de transport.

La prima conectare, clientul trimite o cerere HTTP către server. Engine.IO răspunde și stabilește o conexiune long-polling. După aceea, clientul trimite o cerere de upgrade a protocolului de transport la WebSocket. Dacă serverul suportă WebSocket, upgrade-ul are loc în cadrul aceleiași sesiuni TCP. Dacă nu, conexiunea rămâne pe long-polling, iar codul aplicației nu necesită modificări.

Conform testelor de performanță Socket.IO (2024), la utilizarea WebSocket, latența este de 2–5 ms pentru transmiterea unui mesaj, în timp ce long-polling adaugă 150–300 ms din cauza suprasarcinii HTTP. Alegerea transportului este transparentă pentru dezvoltator.

Protocolul Engine.IO

Engine.IO este stratul de transport de nivel inferior pe care este construit Socket.IO. Acesta se ocupă de stabilirea conexiunii, selectarea transportului, heartbeat (ping/pong) și întreruperea conexiunii. Tipurile principale de pachete Engine.IO: open (inițializare), close (închidere), ping/pong (verificare activitate), upgrade (schimbare transport), message (date).

Socket.IO construiește deasupra Engine.IO propriul model de evenimente — exact cu acesta lucrează dezvoltatorul. Fiecare mesaj Socket.IO este împachetat într-un pachet Engine.IO cu tipul message și un identificator unic pentru confirmarea livrării.

Caracteristici cheie ale Socket.IO

Socket.IO oferă un set de funcții care lipsesc în WebSocket API nativ și care fac dezvoltarea aplicațiilor în timp real semnificativ mai simplă. Să analizăm principalele dintre ele.

Reconectare automată — clientul restabilește automat conexiunea la întrerupere cu o întârziere exponențială (100 ms, 200 ms, 400 ms... până la maxim). Conform documentației Socket.IO (2024), setările de reîncercare sunt disponibile prin parametrii reconnectionDelay și reconnectionAttempts. Această opțiune este critică pentru aplicațiile mobile unde conexiunea se poate întrerupe la schimbarea rețelei.

Suport pentru camere — serverul poate grupa socket-uri în camere și trimite mesaje doar membrilor unei camere specifice. Camerele nu necesită creare explicită — sunt create la prima intrare a unui socket. Camerele sunt implementate la nivel de proces și nu sunt partajate între diferite servere fără un adaptor special.

Spații de nume — separarea logică a canalelor de comunicare pe o singură conexiune. De exemplu, spațiul /chat pentru mesajele de chat și /notifications pentru notificări. Fiecare spațiu de nume are propriile camere, middleware și handler-e. Spațiile de nume sunt multiplexate printr-o singură conexiune TCP, economisind resurse.

Confirmarea livrării — la trimiterea unui mesaj se poate transmite o funcție de callback care va fi apelată când serverul confirmă primirea. Acest lucru este implementat printr-un identificator unic al fiecărui pachet. Mecanismul de confirmare garantează că mesajele critic de importante (de exemplu, tranzacțiile de plată) au fost livrate destinatarului.

Socket.IO vs WebSocket: comparație

Alegerea între Socket.IO și WebSocket nativ depinde de cerințele proiectului. WebSocket este un protocol standardizat (RFC 6455) suportat de toate browserele moderne. Socket.IO este o bibliotecă care utilizează WebSocket ca transport, dar adaugă funcții suplimentare.

Dacă proiectul necesită performanță maximă și dimensiune minimă a clientului — alegeți WebSocket nativ. Dacă aveți nevoie de livrare fiabilă, grupare și model de evenimente — Socket.IO va reduce timpul de dezvoltare de 2–3 ori datorită abstracțiilor gata făcute.

Conform sondajului State of JS 2024, 67% dintre dezvoltatorii de aplicații în timp real preferă Socket.IO datorită confortului API și gestionării încorporate a cazurilor limită (întrerupere rețea, reconectare, date binare).

Cum să conectați Socket.IO în proiect

Instalarea Socket.IO necesită două pachete: server și client. Să analizăm configurația de bază pentru un proiect Node.js. Serverul creează un server HTTP, inițializează Socket.IO și gestionează evenimentele de conectare și deconectare ale clienților.

Conform documentației Socket.IO (2024), serverul poate fi pornit fără Express, utilizând modulul http încorporat, dar în proiectele reale se folosește de obicei Express sau Fastify pentru rutarea cererilor HTTP.

Codul serverului în Node.js

const express = require('express');
const http = require('http');
const Server = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server, {
    cors: { origin: '*' }
});

io.on('connection', (socket) => {
    console.log('Client conectat:', socket.id);

    socket.emit('welcome', { message: 'Hello from server' });

    socket.on('disconnect', () => {
        console.log('Client deconectat');
    });
});

server.listen(3000, () => {
    console.log('Serverul rulează pe portul 3000');
});

Codul clientului în browser

import { io } from 'socket.io-client';

const socket = io('http://localhost:3000', {
    transports: ['websocket', 'polling'],
    reconnectionDelay: 1000
});

socket.on('welcome', (data) => {
    console.log(data.message);
});

socket.emit('chat message', {
    user: 'Alice',
    text: 'Hello everyone!'
});

Evenimente și camere în Socket.IO

Modelul de evenimente Socket.IO se bazează pe evenimente denumite. Serverul și clientul trimit și primesc mesaje asociate unui nume de eveniment specific. Payload-ul poate fi un șir de caractere, un obiect JSON sau date binare (Buffer, ArrayBuffer, Blob).

Fiecare eveniment suportă ACK (acknowledgement) — transmiterea unei funcții de callback care se execută pe partea expeditorului după procesarea evenimentului de către destinatar. Acest lucru permite implementarea modelului request-response deasupra modelului de evenimente. ACK funcționează doar dacă destinatarul apelează explicit funcția de callback.

Conform documentației Socket.IO (2024), dimensiunea maximă a unui singur mesaj nu trebuie să depășească 1 MB pentru performanță optimă. Mesajele mai mari trebuie împărțite în fragmente sau transmise printr-un canal separat.

Lucrul cu camere

io.on('connection', (socket) => {
    socket.join('room-1');

    socket.to('room-1').emit('user joined', {
        userId: socket.id
    });

    io.to('room-1').emit('message', {
        text: 'Broadcast to room'
    });

    socket.leave('room-1');
});

Scalarea Socket.IO

Scalarea orizontală a Socket.IO necesită rezolvarea problemei partajării stării între mai multe procese server. Camerele, spațiile de nume și lista socket-urilor conectate sunt stocate în memoria unui singur proces și nu sunt vizibile pentru alte procese fără un adaptor.

Adaptorii oficiali Socket.IO: redis (prin Redis Pub/Sub), mongodb (prin MongoDB change streams), cluster (pentru modul multiproces Node.js cluster). Adaptorul acționează ca un broker de mesaje între instanțele Socket.IO. La trimiterea unui eveniment către o cameră, adaptorul îl publică în Redis și toate serverele primesc notificarea.

Conform testelor de încărcare Socket.IO (2024), un cluster de 4 servere cu adaptor Redis gestionează până la 400.000 de conexiuni simultane cu o latență sub 10 ms. Fără adaptor, capacitatea maximă a unui singur proces Node.js este de aproximativ 100.000 de conexiuni cu 1 GB de memorie.

Configurarea adaptorului Redis

const Server = require('socket.io');
const RedisAdapter = require('@socket.io/redis-adapter');
const Redis = require('ioredis');

const pubClient = new Redis({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();
const io = new Server(server);
io.adapter(RedisAdapter(pubClient, subClient));

La utilizarea Kubernetes sau Docker Swarm, se recomandă configurarea suplimentară a session affinity (sticky sessions), astfel încât cererile de la un client să ajungă pe același server, altfel la fiecare reconectare asignarea se poate schimba.