SSE — bu nima, Server-Sent Events va bir tomonlama striming

SSE nima?

SSE (Server-Sent Events) — veb-serverga ulanish o'rnatilgandan so'ng istalgan vaqtda mijozga ma'lumot yuborish imkonini beruvchi texnologiya. WHATWG tomonidan HTML Living Standard-ning bir qismi sifatida standartlashtirilgan va text/event-stream MIME turidan foydalanadi. SSE xabar identifikatori, hodisa turi va qayta ulanish kechikishini ko'rsatish imkoniyati bilan matn ma'lumotlarini uzatishni qo'llab-quvvatlaydi.

WebSocket-dan farqli o'laroq, ikki tomonlama protokol va upgrade so'rovini talab qiladigan WebSocket-dan farqli o'laroq, SSE oddiy HTTP ustida ishlaydi. Server Content-Type: text/event-stream sarlavhasini o'rnatadi, ma'lumotlarni qismlarga bo'lib yuboradi va ulanishni ochiq ushlab turadi. Mijoz ma'lumotlarni avtomatik ravishda oqimni tahlil qiladigan va hodisalar yaratadigan brauzer EventSource API-si orqali qabul qiladi.

CanIUse (2025) ma'lumotlariga ko'ra, EventSource API global miqyosda brauzerlarning 97.5 foizida qo'llab-quvvatlanadi. Internet Explorer va ba'zi mobil brauzerlarda (Samsung Internet 7.0 versiyasigacha) qo'llab-quvvatlanmaydi. Bu holatlar uchun XHR streaming orqali EventSource-ni emulyatsiya qiluvchi polifillar mavjud. SSE HTTP/1.1 pipelining bilan ishlamaydi, lekin HTTP/2 server push bilan to'liq mos keladi.

Tarix va standartlashtirish

SSE 2009-yilda HTML5 spetsifikatsiyasining bir qismi sifatida Server-Sent DOM Events nomi bilan taklif qilingan. Birinchi tatbiq Opera 9.0-da, keyin Firefox 6.0 (2011), Chrome 9.0 (2011) va Safari 5.0 (2010)-da paydo bo'ldi. 2015-yilda spetsifikatsiya HTML Living Standard-ning alohida bo'limiga ajratildi. O'n yillik tarixiga qaramay, SSE bir tomonlama tabiati tufayli WebSocket-dan kamroq mashhur bo'lib qolmoqda.

SSE qanday ishlaydi

SSE ishlash mexanizmi quyidagicha: mijoz server endpoint URL-si bilan EventSource namunasini yaratadi. Brauzer Accept: text/event-stream sarlavhasi bilan GET so'rovi yuboradi. Server 200 OK statusi va Content-Type: text/event-stream sarlavhasi bilan javob beradi, so'ngra event-stream formatida ma'lumot yuborishni boshlaydi. Server terminate signalini yubormaguncha yoki mijoz close() chaqirmaguncha ulanish ochiq qoladi.

Server tomonida ma'lumotlar qismlarga bo'lib (chunked transfer encoding) yuboriladi. Har bir ma'lumot bloki maydon satrlaridan (event, data, id, retry) iborat matnli xabardir. Server istalgan vaqtda xabar yuborishi mumkin, bu esa SSE-ni bildirishnomalar va holat yangilanishlari uchun ideal qiladi. Ulanish (WebSocket-dagi kabi) doimiy heartbeat paket almashinuvini talab qilmaydi, garchi retry maydoni qayta ulanish chastotasini boshqaradi.

Ishlash testlariga (2024) ko'ra, SSE 256 bayt xabar hajmida bitta ulanishda sekundiga 10 000 tagacha xabar o'tkazish qobiliyatini ta'minlaydi. Server tomonida har bir SSE ulanishi taxminan 5–10 KB xotira sarflaydi, bu esa bitta serverga 1 GB RAM bilan 50 000+ bir vaqtda ulanishni qo'llab-quvvatlash imkonini beradi. Bu ikkilik protokolning yo'qligi sababli WebSocket-dan sezilarli darajada kam.

Event-stream formati

Format text/event-stream — har bir xabar yangi qator belgilari bilan ajratilgan nomlangan maydonlardan iborat oddiy matn protokoli. Har bir maydon «MaydonNomi: qiymat» formatiga ega. Xabarlar ikkita yangi qator belgisi (\n\n) bilan ajratiladi.

Qo'llab-quvvatlanadigan maydonlar: event (hodisa turi, standart bo'yicha message), data (ma'lumot qatori, ko'p qatorli bo'lishi mumkin), id (oxirgi hodisa identifikatori, Last-Event-ID da saqlanadi), retry (qayta ulanish vaqti millisekundlarda). Sharhlar ikki nuqta (:) bilan boshlanadi va parser tomonidan e'tiborga olinmaydi, lekin heartbeat uchun ishlatilishi mumkin.

Event-stream oqimi namunasi

: heartbeat comment
event: update
data: {"user": "Alice", "action": "typing"}
id: 1001

event: notification
data: {"type": "info", "text": "New version available"}
data: {"type": "action", "url": "/upgrade"}
retry: 3000

event: close
data: Session ended

Mijoz tomonida EventSource API

EventSource API — SSE qabul qilish uchun o'rnatilgan brauzer interfeysi. Ulanish yaratish uchun endpoint URL-si bilan konstruktorni chaqirish kifoya. EventSource avtomatik ravishda ulanishni o'rnatadi, qayta ulanishni boshqaradi va kiruvchi xabarlarni JavaScript hodisalariga tahlil qiladi.

EventSource hodisalari: open (ulanish o'rnatildi), message (event ko'rsatilmagan holda xabar olindi), error (ulanish xatosi). Maxsus hodisalar (event: custom) uchun addEventListener hodisa nomi bilan ishlatilishi mumkin. EventSource qayta ulanishda avtomatik ravishda Last-Event-ID sarlavhasini yuboradi, bu esa serverga oqimni uzilgan joydan tiklash imkonini beradi.

MDN hujjatlariga (2025) ko'ra, EventSource CORS va hisob ma'lumotlarini uzatishni (withCredentials) qo'llab-quvvatlaydi. Maxsus sarlavhalar yoki so'rov tanasini uzatish uchun EventSource mos emas — fetch + ReadableStream orqali qo'lda amalga oshirish talab qilinadi. EventSource ikkilik ma'lumotlarni qo'llab-quvvatlamaydi — faqat matn va JSON.

JavaScript mijoz kodi

const eventSource = new EventSource('/api/events/stream');

eventSource.addEventListener('open', () => {
    console.log('SSE ulanishi ochildi');
});

eventSource.addEventListener('message', (event) => {
    const data = JSON.parse(event.data);
    console.log('Qabul qilindi:', data);
    renderUpdate(data);
});

eventSource.addEventListener('notification', (event) => {
    const notification = JSON.parse(event.data);
    showNotification(notification.text);
});

eventSource.addEventListener('error', (error) => {
    console.error('SSE xatosi:', error);
    // Brauzerning avtomatik qayta ulanishi
});

// Ulanishni yop
eventSource.close();

SSE vs WebSocket: taqqoslash

SSE va WebSocket — real vaqt kommunikatsiyasi uchun turli texnologiyalar, har biri o'zining kuchli tomonlariga ega. WebSocket ikki tomonlama ma'lumot almashinuvi (chatlar, o'yinlar, birgalikda tahrirlash) uchun, SSE esa serverdan mijozga bir tomonlama oqimlar (bildirishnomalar, yangiliklar lentalari, tickerlar) uchun mos.

Asosiy farq — WebSocket HTTP/1.1 dan WebSocket protokoliga (ws://) upgrade so'rovini talab qiladi, bu korporativ proksilar tomonidan bloklanishi mumkin. SSE oddiy HTTP ustida ishlaydi, barcha proksilardan o'tadi va serverning maxsus konfiguratsiyasini talab qilmaydi. SSE shuningdek amalga oshirishda soddaroq — serverga qo'shimcha kutubxona kerak emas, faqat HTTP javobini to'g'ri shakllantirish kifoya.

Taqqoslash testlariga (2024) ko'ra, bitta server jarayonida SSE soddaroq protokol tufayli WebSocket-dan 30–50% ko'proq ulanishlarni qo'llab-quvvatlaydi. Biroq, SSE kechikishi yuqoriroq (50–200 ms WebSocket-dagi 10–50 ms ga qarshi), chunki SSE chunked HTTP dan foydalanadi, ikkilik freymlar bilan to'liq ikki tomonlama oqim emas.

Serverda SSE qanday amalga oshiriladi

Serverda SSE amalga oshirish kutubxona talab qilmaydi — to'g'ri HTTP sarlavhalarini o'rnatish va ma'lumotlarni text/event-stream formatida yuborish kifoya. Ichki http modulidan foydalangan holda Node.js misolini ko'rib chiqaylik. Server Content-Type va Cache-Control sarlavhalarini o'rnatadi, so'ngra har N sekundda xabar yuboradi.

MDN Web Docs (2025) ma'lumotlariga ko'ra, SSE uchun majburiy sarlavhalar: Content-Type: text/event-stream, Cache-Control: no-cache va Connection: keep-alive. Cache-Control bo'lmasa, brauzer SSE oqimini keshlashi mumkin, bu esa yetkazib berishning to'xtashiga olib keladi. Connection: keep-alive brauzerga ulanishni ochiq ushlab turishni aniq ko'rsatadi.

Node.js server kodi

const http = require('http');

http.createServer((req, res) => {
    res.writeHead(200, {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive'
    });

    let eventId = 0;
    const interval = setInterval(() => {
        eventId++;
        res.write(`id: ${eventId}\n`);
        res.write(`event: update\n`);
        res.write(`data: {"vaqt": "${new Date().toISOString()}", "id":${eventId}}\n\n`);
    }, 2000);

    req.on('close', () => {
        clearInterval(interval);
    });
}).listen(3000);

Python (Flask) da SSE

from flask import Response, Flask
import time
import json

app = Flask(__name__)

@app.route('/stream')
def stream():
    def generate():
        event_id = 0
        while True:
            event_id += 1
            data = json.dumps(
                {'ticker': 'AAPL', 'price': 150.25})
            yield f'id: {event_id}\nevent: price\ndata: {data}\n\n'
            time.sleep(1)
    return Response(generate(),
        mimetype='text/event-stream')

Mobil ilovalarda SSE

Mobil ilovalarda SSE dan foydalanish iOS va Android uchun EventSource-ning mahalliy tatbiqining yo'qligi bilan cheklangan. Mobil platformalarda SSE tashqi kutubxonalar orqali amalga oshiriladi: iOS da — URLSession bilan NSURLProtocol orqali, Android da — OkHttp bilan SSE qo'llab-quvvatlashi (okhttp-sse) orqali. React Native va Flutter uchun EventSource-ni emulyatsiya qiluvchi paketlar mavjud.

iOS da mahalliy SSE tatbiqi URLSessionDataDelegate orqali mumkin. urlSession(_:dataTask:didReceive:) metodida ma'lumot qabul qilganda, ilova bufer to'playdi va event-stream formatini qo'lda tahlil qiladi. iOS rivojlanish blogiga (2024) ko'ra, iOS da SSE bilan batareya iste'moli doimiy WebSocket ulanishidan 40% past, heartbeat paketlarining yo'qligi sababli.

Android da OkHttp SSE oqimlariga obuna bo'lish uchun EventSource.Factory sinfini taqdim etadi. Android ilovalari FCM mavjud bo'lmaganda bildirishnomalar uchun yoki fon rejimida ma'lumot sinxronizatsiyasi uchun SSE dan foydalanishi mumkin. Android da SSE uzoq muddatli fon vazifalari uchun WorkManager bilan yaxshi ishlaydi. OkHttp hujjatlariga (2025) ko'ra, okhttp-sse maxsus listener bilan avtomatik qayta ulanishni qo'llab-quvvatlaydi.