Socket.IO — какво е, библиотека за взаимодействие в реално време

Какво е Socket.IO?

Socket.IO е JavaScript библиотека с отворен код за двупосочна комуникация, базирана на събития между клиент и сървър. Създадена е през 2010 г. от разработчика Guillermo Rauch и оттогава се превърна в de facto стандарт за приложения в реално време на Node.js.

За разлика от вградения WebSocket API, Socket.IO предоставя допълнителни абстракции: стаи, именни пространства, автоматично повторно свързване и двоични типове данни. Библиотеката не е отделна имплементация на WebSocket — тя използва Engine.IO като транспортен слой, който първо установява HTTP long-polling връзка, а след това опитва upgrade към WebSocket.

Според npm статистиката (2025), над 12 милиона копия на пакета socket.io се изтеглят седмично, което го прави една от най-популярните библиотеки в екосистемата на Node.js. Socket.IO се поддържа на всички съвременни платформи: браузъри, iOS, Android, React Native и десктоп приложения.

История на създаване и версии

Socket.IO версия 1.0 беше пусната през 2014 г. и въведе концепцията за именни пространства (namespaces), които позволяват мултиплексиране на няколко логически канала през една TCP връзка. Версия 2.0 (2017) добави поддръжка за двоични данни и подобри производителността при парсиране. Текущата версия 4.x (2020–2025) включва пълна поддръжка на TypeScript, флагмански режим на адаптация за мащабиране и подобрена обратна съвместимост.

Всяка основна версия запазва обратна съвместимост на API — клиент socket.io@2 може да се свърже със сървър socket.io@4 чрез специален режим на съвместимост. Това е важно за дългогодишни проекти, където обновяването на клиентската част става постепенно.

Как работи Socket.IO

Архитектурата на Socket.IO се състои от два компонента: сървърен модул (npm пакет socket.io) и клиентски модул (npm пакет socket.io-client). Сървърът работи над Node.js HTTP(S) сървър и използва Engine.IO за управление на транспортния слой.

При първото свързване клиентът изпраща HTTP заявка към сървъра. Engine.IO отговаря и установява long-polling връзка. След това клиентът изпраща заявка за upgrade на транспортния протокол до WebSocket. Ако сървърът поддържа WebSocket, upgrade-ът се случва в рамките на същата TCP сесия. Ако не, връзката остава на long-polling и кодът на приложението не изисква промени.

Според тестовете за производителност на Socket.IO (2024), при използване на WebSocket латентността е 2–5 ms за предаване на съобщение, докато long-polling добавя 150–300 ms поради допълнителните разходи на HTTP. Изборът на транспорт е прозрачен за разработчика.

Протокол Engine.IO

Engine.IO е ниско ниво на транспортния слой, върху който е изграден Socket.IO. Той отговаря за установяване на връзка, избор на транспорт, heartbeat (ping/pong) и прекъсване на връзката. Основните типове пакети на Engine.IO: open (инициализация), close (затваряне), ping/pong (проверка на живота), upgrade (смяна на транспорт), message (данни).

Socket.IO изгражда над Engine.IO свой собствен събитиен модел — точно с това работи разработчикът. Всяко Socket.IO съобщение е опаковано в Engine.IO пакет с тип message и уникален идентификатор за потвърждение на доставката.

Основни възможности на Socket.IO

Socket.IO предоставя набор от функции, които липсват във вградения WebSocket API и които правят разработката на приложения в реално време значително по-лесна. Нека разгледаме основните от тях.

Автоматично повторно свързване — клиентът автоматично възстановява връзката при прекъсване с експоненциално забавяне (100 ms, 200 ms, 400 ms... до максимум). Според документацията на Socket.IO (2024), настройките за повторен опит са достъпни чрез параметрите reconnectionDelay и reconnectionAttempts. Тази опция е критична за мобилни приложения, където връзката може да се прекъсне при смяна на мрежата.

Поддръжка на стаи — сървърът може да групира сокети в стаи и да изпраща съобщения само до членовете на конкретна стая. Стаите не изискват изрично създаване — те се създават при първото присъединяване на сокет. Стаите са имплементирани на ниво процес и не се споделят между различни сървъри без специален адаптер.

Именни пространства — логическо разделяне на комуникационните канали на една връзка. Например, пространство /chat за съобщения в чат и /notifications за известия. Всяко именно пространство има собствени стаи, middleware и манипулатори. Именните пространства се мултиплексират през една TCP връзка, което спестява ресурси.

Потвърждение за доставка — при изпращане на съобщение може да се предаде callback функция, която ще бъде извикана, когато сървърът потвърди получаването. Това е имплементирано чрез уникален идентификатор на всеки пакет. Механизмът за потвърждение гарантира, че критично важни съобщения (напр. платежни транзакции) са доставени до получателя.

Socket.IO срещу WebSocket: сравнение

Изборът между Socket.IO и вградения WebSocket зависи от изискванията на проекта. WebSocket е стандартизиран протокол (RFC 6455), поддържан от всички съвременни браузъри. Socket.IO е библиотека, която използва WebSocket като транспорт, но добавя допълнителни функции.

Ако проектът изисква максимална производителност и минимален размер на клиента — изберете вградения WebSocket. Ако е необходима надеждна доставка, групиране и събитиен модел — Socket.IO ще съкрати времето за разработка 2–3 пъти благодарение на готовите абстракции.

Според проучването State of JS 2024, 67% от разработчиците на приложения в реално време предпочитат Socket.IO заради удобството на API и вградената обработка на гранични случаи (прекъсване на мрежа, повторно свързване, двоични данни).

Как да свържете Socket.IO в проекта

Инсталирането на Socket.IO изисква два пакета: сървърен и клиентски. Нека разгледаме основната конфигурация за Node.js проект. Сървърът създава HTTP сървър, инициализира Socket.IO и обработва събитията на свързване и прекъсване на клиентите.

Според документацията на Socket.IO (2024), сървърът може да бъде стартиран без Express, като се използва вграденият http модул, но в реални проекти обикновено се използва Express или Fastify за маршрутизиране на HTTP заявки.

Сървърен код на 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('Клиент свързан:', socket.id);

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

    socket.on('disconnect', () => {
        console.log('Клиент прекъсна');
    });
});

server.listen(3000, () => {
    console.log('Сървърът работи на порт 3000');
});

Клиентски код в браузъра

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

Събития и стаи в Socket.IO

Събитийният модел на Socket.IO се основава на именувани събития. Сървърът и клиентът изпращат и получават съобщения, свързани с конкретно име на събитие. Payload-ът може да бъде низ, JSON обект или двоични данни (Buffer, ArrayBuffer, Blob).

Всяко събитие поддържа ACK (acknowledgement) — предаване на callback функция, която се изпълнява от страна на изпращача след обработка на събитието от получателя. Това позволява имплементиране на модела request-response върху събитийния модел. ACK работи само ако получателят изрично извика callback функцията.

Според документацията на Socket.IO (2024), максималният размер на едно съобщение не трябва да надвишава 1 MB за оптимална производителност. По-големите съобщения трябва да бъдат разделени на фрагменти или предавани през отделен канал.

Работа със стаи

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

Хоризонталното мащабиране на Socket.IO изисква решаване на проблема за споделяне на състояние между множество сървърни процеси. Стаите, именните пространства и списъкът на свързаните сокети се съхраняват в паметта на един процес и не са видими за други процеси без адаптер.

Официални адаптери на Socket.IO: redis (чрез Redis Pub/Sub), mongodb (чрез MongoDB change streams), cluster (за мултипроцесен режим на Node.js cluster). Адаптерът действа като брокер на съобщения между инстанциите на Socket.IO. При изпращане на събитие до стая, адаптерът го публикува в Redis и всички сървъри получават известие.

Според тестовете за натоварване на Socket.IO (2024), клъстер от 4 сървъра с Redis адаптер обработва до 400 000 едновременни връзки с латентност под 10 ms. Без адаптер максималният капацитет на един Node.js процес е около 100 000 връзки с 1 GB памет.

Конфигурация на 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));

При използване на Kubernetes или Docker Swarm се препоръчва допълнително конфигуриране на session affinity (sticky sessions), така че заявките от един и същ клиент да попадат на същия сървър, в противен случай присвояването може да се промени при всяко повторно свързване.