Socket.IO — mi ez, valós idejű interakciós könyvtár

Mi az a Socket.IO?

A Socket.IO egy nyílt forráskódú JavaScript könyvtár a kétirányú eseményvezérelt kommunikációhoz kliens és szerver között. 2010-ben hozta létre Guillermo Rauch fejlesztő, és azóta a Node.js valós idejű alkalmazásainak de facto szabványává vált.

A natív WebSocket API-val ellentétben a Socket.IO további absztrakciókat kínál: szobák, névterek, automatikus újracsatlakozás és bináris adattípusok. A könyvtár nem a WebSocket különálló implementációja — az Engine.IO-t használja szállítási rétegként, amely először HTTP long-polling kapcsolatot hoz létre, majd megpróbál WebSocket-re frissíteni.

A npm-statisztikák (2025) szerint hetente több mint 12 millió példányt töltenek le a socket.io csomagból, ami a Node.js ökoszisztéma egyik legnépszerűbb könyvtárává teszi. A Socket.IO minden modern platformon támogatott: böngészők, iOS, Android, React Native és asztali alkalmazások.

Létrehozásának története és verziók

A Socket.IO 1.0-s verziója 2014-ben jelent meg, és bevezette a névterek (namespaces) koncepcióját, amelyek lehetővé teszik több logikai csatorna multiplexelését egyetlen TCP-kapcsolaton keresztül. A 2.0-s verzió (2017) bináris adattámogatást adott hozzá, és javította az elemzési teljesítményt. A jelenlegi 4.x verzió (2020–2025) teljes TypeScript-támogatást, skálázáshoz zászlóshajó adaptációs módot és javított visszafelé kompatibilitást tartalmaz.

Minden nagyobb kiadás megőrzi az API visszafelé kompatibilitását — a socket.io@2 kliens egy speciális kompatibilitási mód segítségével csatlakozhat a socket.io@4 szerverhez. Ez fontos a hosszú életű projekteknél, ahol a kliens oldal frissítése fokozatosan történik.

Hogyan működik a Socket.IO

A Socket.IO architektúrája két komponensből áll: a szervermodulból (npm-csomag socket.io) és a kliensmodulból (npm-csomag socket.io-client). A szerver egy Node.js HTTP(S) szerver felett működik, és az Engine.IO-t használja a szállítási réteg kezelésére.

Az első kapcsolódáskor a kliens HTTP-kérést küld a szervernek. Az Engine.IO válaszol, és létrehoz egy long-polling kapcsolatot. Ezt követően a kliens kérést küld a szállítási protokoll WebSocketre frissítésére. Ha a szerver támogatja a WebSocketet, a frissítés ugyanazon a TCP-munkameneten belül történik. Ha nem, a kapcsolat long-polling marad, és az alkalmazáskód nem igényel változtatást.

A Socket.IO teljesítménytesztjei (2024) szerint WebSocket használatakor a késleltetés 2–5 ms üzenetenként, míg a long-polling 150–300 ms többletet ad a HTTP többletterhelése miatt. A szállítási mód kiválasztása átlátható a fejlesztő számára.

Engine.IO protokoll

Az Engine.IO az alacsony szintű szállítási réteg, amelyre a Socket.IO épül. Felelős a kapcsolat létrehozásáért, a szállítási mód kiválasztásáért, a heartbeat-ért (ping/pong) és a kapcsolat bontásáért. Az Engine.IO fő csomagtípusai: open (inicializálás), close (lezárás), ping/pong (életbenlét ellenőrzése), upgrade (szállítási mód váltása), message (adatok).

A Socket.IO az Engine.IO fölé építi a saját eseménymodelljét — a fejlesztő ezzel dolgozik. Minden Socket.IO üzenet egy Engine.IO csomagba van csomagolva message típussal és egyedi azonosítóval a kézbesítés megerősítéséhez.

A Socket.IO főbb funkciói

A Socket.IO olyan funkciókat kínál, amelyek hiányoznak a natív WebSocket API-ból, és jelentősen leegyszerűsítik a valós idejű alkalmazások fejlesztését. Tekintsük át a legfontosabbakat.

Automatikus újracsatlakozás — a kliens automatikusan helyreállítja a kapcsolatot megszakadáskor exponenciális késleltetéssel (100 ms, 200 ms, 400 ms... a maximumig). A Socket.IO dokumentációja (2024) szerint az újrapróbálkozási beállítások a reconnectionDelay és reconnectionAttempts paramétereken keresztül érhetők el. Ez a lehetőség kritikus fontosságú a mobilalkalmazásoknál, ahol a kapcsolat megszakadhat hálózatváltáskor.

Szobák támogatása — a szerver csoportosíthatja a socketeket szobákba, és csak egy adott szoba tagjainak küldhet üzeneteket. A szobák nem igényelnek explicit létrehozást — az első socket csatlakozásakor jönnek létre. A szobák folyamatszinten vannak implementálva, és különleges adapter nélkül nem oszthatók meg különböző szerverek között.

Névterek — a kommunikációs csatornák logikai elkülönítése egyetlen kapcsolaton. Például a /chat névtér csevegőüzenetekhez és a /notifications értesítésekhez. Minden névtérnek saját szobái, middleware-je és kezelői vannak. A névterek egyetlen TCP-kapcsolaton keresztül multiplexelődnek, ami erőforrásokat takarít meg.

Kézbesítési megerősítés — üzenet küldésekor átadható egy callback függvény, amely akkor hívódik meg, amikor a szerver megerősíti a fogadást. Ez minden csomag egyedi azonosítóján keresztül van implementálva. A megerősítési mechanizmus garantálja, hogy a kritikus fontosságú üzenetek (pl. fizetési tranzakciók) kézbesítve lettek a címzettnek.

Socket.IO vs WebSocket: összehasonlítás

A választás a Socket.IO és a natív WebSocket között a projekt követelményeitől függ. A WebSocket egy szabványosított protokoll (RFC 6455), amelyet minden modern böngésző támogat. A Socket.IO egy könyvtár, amely a WebSocketet használja szállítási rétegként, de további funkciókat ad hozzá.

Ha a projekt maximális teljesítményt és minimális kliensméretet igényel — válassza a natív WebSocketet. Ha megbízható kézbesítésre, csoportosításra és eseménymodellre van szükség — a Socket.IO 2–3-szor lerövidíti a fejlesztési időt a kész absztrakcióknak köszönhetően.

A State of JS 2024 felmérése szerint a valós idejű alkalmazásfejlesztők 67%-a a Socket.IO-t részesíti előnyben az API kényelme és a beépített szélsőséges esetek kezelése (hálózati megszakadás, újracsatlakozás, bináris adatok) miatt.

Socket.IO csatlakoztatása a projektben

A Socket.IO telepítése két csomagot igényel: szerver és kliens. Tekintsük át az alapkonfigurációt egy Node.js projekthez. A szerver létrehoz egy HTTP szervert, inicializálja a Socket.IO-t, és kezeli a kliensek csatlakozási és bontási eseményeit.

A Socket.IO dokumentációja (2024) szerint a szerver elindítható Express nélkül is, a beépített http modul használatával, de valós projektekben általában Express vagy Fastify van használatban a HTTP kérések útválasztásához.

Szerveroldali kód Node.js-ben

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('Kliens csatlakozott:', socket.id);

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

    socket.on('disconnect', () => {
        console.log('Kliens lecsatlakozott');
    });
});

server.listen(3000, () => {
    console.log('Szerver fut a 3000-es porton');
});

Kliensoldali kód böngészőben

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!'
});

Események és szobák a Socket.IO-ban

A Socket.IO eseménymodellje elnevezett eseményeken alapul. A szerver és a kliens egy adott eseménynévhez kötött üzeneteket küld és fogad. A payload lehet string, JSON objektum vagy bináris adat (Buffer, ArrayBuffer, Blob).

Minden esemény támogatja az ACK (acknowledgement) — egy callback függvény átadását, amely a feladó oldalán hajtódik végre, miután a címzett feldolgozta az eseményt. Ez lehetővé teszi a request-response minta implementálását az eseménymodell felett. Az ACK csak akkor működik, ha a címzett kifejezetten meghívja a callbacket.

A Socket.IO dokumentációja (2024) szerint egyetlen üzenet maximális mérete nem haladhatja meg az 1 MB-t az optimális teljesítmény érdekében. A nagyobb üzeneteket töredékekre kell bontani, vagy külön csatornán kell továbbítani.

Munka szobákkal

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');
});

Socket.IO skálázása

A Socket.IO horizontális skálázása megköveteli az állapotmegosztás problémájának megoldását több szerverfolyamat között. A szobák, névterek és a csatlakoztatott socketek listája egyetlen folyamat memóriájában tárolódnak, és adapter nélkül nem láthatók más folyamatok számára.

A hivatalos Socket.IO adapterek: redis (Redis Pub/Sub segítségével), mongodb (MongoDB change streams segítségével), cluster (Node.js cluster többfolyamatos módjához). Az adapter üzenetközvetítőként működik a Socket.IO példányok között. Amikor egy eseményt küldenek egy szobába, az adapter közzéteszi azt Redis-ben, és minden szerver értesítést kap.

A Socket.IO terheléses tesztjei (2024) szerint egy 4 szerverből álló klaszter Redis adapterrel akár 400 000 egyidejű kapcsolatot is kezel 10 ms alatti késleltetéssel. Adapter nélkül egyetlen Node.js folyamat maximális kapacitása körülbelül 100 000 kapcsolat 1 GB memóriával.

A Redis adapter konfigurációja

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));

Kubernetes vagy Docker Swarm használatakor ajánlott a session affinity (sticky sessions) további beállítása, hogy az egy klienstől érkező kérések ugyanarra a szerverre jussanak, ellenkező esetben minden újracsatlakozáskor változhat a hozzárendelés.