Socket.IO — ano ito, library para sa real-time na interaksyon

Ano ang Socket.IO?

Socket.IO ay isang open-source na JavaScript library para sa two-way na komunikasyong nakabatay sa kaganapan sa pagitan ng client at server. Ito ay nilikha noong 2010 ng developer na si Guillermo Rauch at mula noon ay naging de facto na pamantayan para sa mga real-time na application sa Node.js.

Hindi tulad ng native na WebSocket API, ang Socket.IO ay nagbibigay ng mga karagdagang abstraksyon: mga silid, namespace, awtomatikong muling pagkonekta, at mga binary na uri ng data. Ang library ay hindi isang hiwalay na implementasyon ng WebSocket — ginagamit nito ang Engine.IO bilang layer ng transportasyon, na unang nagtatag ng HTTP long-polling na koneksyon, pagkatapos ay sumusubok na mag-upgrade sa WebSocket.

Ayon sa npm statistics (2025), mahigit 12 milyong kopya ng socket.io package ang nai-download kada linggo, na ginagawa itong isa sa pinakasikat na library sa Node.js ecosystem. Ang Socket.IO ay sinusuportahan sa lahat ng modernong platform: mga browser, iOS, Android, React Native, at desktop application.

Kasaysayan ng paglikha at mga bersyon

Ang Socket.IO bersyon 1.0 ay inilabas noong 2014 at ipinakilala ang konsepto ng mga namespace, na nagpapahintulot sa multiplexing ng maraming lohikal na channel sa pamamagitan ng isang TCP connection. Ang bersyon 2.0 (2017) ay nagdagdag ng suporta para sa binary data at pinabuti ang pagganap ng parsing. Ang kasalukuyang bersyon 4.x (2020–2025) ay may kasamang buong suporta sa TypeScript, flagship adaptation mode para sa pag-scale, at pinahusay na backward compatibility.

Ang bawat pangunahing release ay nagpapanatili ng backward compatibility ng API — ang socket.io@2 client ay maaaring kumonekta sa socket.io@4 server sa pamamagitan ng isang espesyal na compatibility mode. Ito ay mahalaga para sa mga pangmatagalang proyekto kung saan ang pag-update ng client side ay unti-unting nagaganap.

Paano gumagana ang Socket.IO

Arkitektura ng Socket.IO ay binubuo ng dalawang bahagi: server module (npm package socket.io) at client module (npm package socket.io-client). Ang server ay gumagana sa ibabaw ng Node.js HTTP(S) server at gumagamit ng Engine.IO para sa pamamahala ng layer ng transportasyon.

Sa unang koneksyon, ang client ay nagpapadala ng HTTP request sa server. Ang Engine.IO ay tumutugon at nagtatag ng long-polling na koneksyon. Pagkatapos nito, ang client ay nagpapadala ng request para i-upgrade ang transport protocol sa WebSocket. Kung sinusuportahan ng server ang WebSocket, ang upgrade ay nagaganap sa loob ng parehong TCP session. Kung hindi, ang koneksyon ay nananatili sa long-polling at ang application code ay hindi nangangailangan ng mga pagbabago.

Ayon sa Socket.IO performance tests (2024), kapag gumagamit ng WebSocket, ang latency ay 2–5 ms bawat pagpapadala ng mensahe, habang ang long-polling ay nagdaragdag ng 150–300 ms dahil sa HTTP overhead. Ang pagpili ng transportasyon ay transparent para sa developer.

Engine.IO protocol

Engine.IO ay ang mababang antas na layer ng transportasyon kung saan itinayo ang Socket.IO. Ito ay responsable para sa pagtatag ng koneksyon, pagpili ng transportasyon, heartbeat (ping/pong), at pagputol ng koneksyon. Ang mga pangunahing uri ng Engine.IO packet: open (initialization), close (pagsasara), ping/pong (pagsusuri ng buhay), upgrade (pagbabago ng transportasyon), message (data).

Ang Socket.IO ay nagtatayo ng sarili nitong modelo ng kaganapan sa ibabaw ng Engine.IO — ito ang ginagamit ng developer. Bawat Socket.IO na mensahe ay nakabalot sa Engine.IO packet na may uri na message at natatanging identifier para sa kumpirmasyon ng paghahatid.

Mga pangunahing tampok ng Socket.IO

Socket.IO ay nagbibigay ng isang hanay ng mga tampok na wala sa native na WebSocket API at ginagawang mas simple ang pag-develop ng mga real-time na application. Talakayin natin ang mga pangunahing.

Awtomatikong muling pagkonekta — awtomatikong ibinabalik ng client ang koneksyon kapag naputol na may exponential na pagkaantala (100 ms, 200 ms, 400 ms... hanggang sa maximum). Ayon sa Socket.IO documentation (2024), ang mga setting ng retry ay available sa pamamagitan ng mga parameter na reconnectionDelay at reconnectionAttempts. Ang opsyong ito ay kritikal para sa mga mobile application kung saan ang koneksyon ay maaaring maputol kapag nagbabago ng network.

Suporta sa mga silid — maaaring pangkatin ng server ang mga socket sa mga silid at magpadala ng mga mensahe lamang sa mga miyembro ng isang partikular na silid. Ang mga silid ay hindi nangangailangan ng tahasang paggawa — sila ay nilikha sa unang pagsali ng isang socket. Ang mga silid ay ipinatupad sa antas ng proseso at hindi ibinabahagi sa pagitan ng iba't ibang server nang walang espesyal na adapter.

Mga namespace — lohikal na paghihiwalay ng mga channel ng komunikasyon sa isang koneksyon. Halimbawa, ang namespace na /chat para sa mga mensahe ng chat at /notifications para sa mga notification. Bawat namespace ay may sariling mga silid, middleware, at handler. Ang mga namespace ay nami-multiplex sa pamamagitan ng isang TCP connection, na nakakatipid ng mga mapagkukunan.

Kumpirmasyon ng paghahatid — kapag nagpapadala ng mensahe, maaaring magbigay ng callback function na tatawagin kapag kinumpirma ng server ang pagtanggap. Ito ay ipinatupad sa pamamagitan ng natatanging identifier ng bawat packet. Ang mekanismo ng kumpirmasyon ay ginagarantiyahan na ang mga kritikal na mahahalagang mensahe (hal., mga transaksyon sa pagbabayad) ay naihatid sa tatanggap.

Socket.IO vs WebSocket: paghahambing

Ang pagpili sa pagitan ng Socket.IO at native na WebSocket ay depende sa mga kinakailangan ng proyekto. Ang WebSocket ay isang standardized protocol (RFC 6455) na sinusuportahan ng lahat ng modernong browser. Ang Socket.IO ay isang library na gumagamit ng WebSocket bilang transportasyon, ngunit nagdaragdag ng mga karagdagang function.

Kung ang proyekto ay nangangailangan ng maximum na pagganap at minimal na laki ng client — piliin ang native na WebSocket. Kung kailangan ang maaasahang paghahatid, pagpapangkat, at modelo ng kaganapan — ang Socket.IO ay magpapaikli ng oras ng pag-develop ng 2–3 beses dahil sa mga handa nang abstraksyon.

Ayon sa State of JS 2024 survey, 67% ng mga developer ng real-time na application ay mas gusto ang Socket.IO dahil sa kaginhawahan ng API at built-in na paghawak ng mga edge case (pagputol ng network, muling pagkonekta, binary data).

Paano ikonekta ang Socket.IO sa proyekto

Pag-install ng Socket.IO ay nangangailangan ng dalawang package: server at client. Tingnan natin ang pangunahing configuration para sa isang Node.js project. Gumagawa ang server ng HTTP server, ini-initialize ang Socket.IO, at hinahawakan ang mga kaganapan ng koneksyon at pagputol ng mga client.

Ayon sa Socket.IO documentation (2024), ang server ay maaaring patakbuhin nang walang Express, gamit ang built-in na http module, ngunit sa mga totoong proyekto karaniwang ginagamit ang Express o Fastify para sa pagruta ng mga HTTP request.

Server code sa 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('Konektado ang client:', socket.id);

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

    socket.on('disconnect', () => {
        console.log('Nagdiskonekta ang client');
    });
});

server.listen(3000, () => {
    console.log('Tumatakbo ang server sa port 3000');
});

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

Mga kaganapan at silid sa Socket.IO

Modelo ng kaganapan ng Socket.IO ay batay sa pinangalanang mga kaganapan. Ang server at client ay nagpapadala at tumatanggap ng mga mensahe na nakatali sa isang partikular na pangalan ng kaganapan. Ang payload ay maaaring string, JSON object, o binary data (Buffer, ArrayBuffer, Blob).

Ang bawat kaganapan ay sumusuporta sa ACK (acknowledgement) — pagpapasa ng callback function na isinasagawa sa panig ng nagpadala pagkatapos maproseso ang kaganapan ng tatanggap. Ito ay nagpapahintulot sa pagpapatupad ng request-response pattern sa ibabaw ng modelo ng kaganapan. Ang ACK ay gumagana lamang kung ang tatanggap ay tahasang tumawag sa callback.

Ayon sa Socket.IO documentation (2024), ang maximum na laki ng isang mensahe ay hindi dapat lumampas sa 1 MB para sa optimal na pagganap. Ang mas malalaking mensahe ay dapat hatiin sa mga fragment o ipadala sa pamamagitan ng hiwalay na channel.

Pagtatrabaho sa mga silid

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

Pag-scale ng Socket.IO

Horizontal scaling ng Socket.IO ay nangangailangan ng paglutas ng problema ng pagbabahagi ng estado sa pagitan ng maraming proseso ng server. Ang mga silid, namespace, at listahan ng mga konektadong socket ay nakaimbak sa memorya ng isang proseso at hindi nakikita ng ibang mga proseso nang walang adapter.

Opisyal na Socket.IO adapter: redis (sa pamamagitan ng Redis Pub/Sub), mongodb (sa pamamagitan ng MongoDB change streams), cluster (para sa multiprocess mode ng Node.js cluster). Ang adapter ay gumaganap bilang isang message broker sa pagitan ng Socket.IO instances. Kapag nagpapadala ng kaganapan sa isang silid, ini-publish ito ng adapter sa Redis at lahat ng server ay tumatanggap ng notification.

Ayon sa Socket.IO load tests (2024), isang cluster ng 4 na server na may Redis adapter ay humahawak ng hanggang 400,000 sabay-sabay na koneksyon na may latency na mas mababa sa 10 ms. Nang walang adapter, ang maximum capacity ng isang Node.js process ay humigit-kumulang 100,000 koneksyon na may 1 GB memory.

Configuration ng Redis adapter

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

Kapag gumagamit ng Kubernetes o Docker Swarm, inirerekumenda na karagdagang i-configure ang session affinity (sticky sessions), upang ang mga request mula sa parehong client ay mapunta sa parehong server, kung hindi, ang assignment ay maaaring magbago sa bawat muling pagkonekta.