參考

SSE本質

嚴格地說(shuo)，HTTP 協(xie)議無法(fa)做到服務(wu)器主動推送信(xin)息(xi)。但是，有一種變通(tong)方法(fa)，就是服務(wu)器向(xiang)客戶端聲明，接下來要發送的(de)是流(liu)信(xin)息(xi)（streaming）。

也就(jiu)是說，發(fa)送(song)的(de)(de)(de)不(bu)(bu)是一次性的(de)(de)(de)數(shu)據包，而(er)是一個數(shu)據流(liu)，會連(lian)續不(bu)(bu)斷地發(fa)送(song)過(guo)來(lai)。這時(shi)，客戶端不(bu)(bu)會關(guan)閉連(lian)接，會一直等(deng)著服務器(qi)發(fa)過(guo)來(lai)的(de)(de)(de)新(xin)的(de)(de)(de)數(shu)據流(liu)，視頻播(bo)放就(jiu)是這樣的(de)(de)(de)例子。本質上，這種通信(xin)就(jiu)是以流(liu)信(xin)息的(de)(de)(de)方式，完成一次用(yong)時(shi)很長(chang)的(de)(de)(de)下(xia)載。

SSE 就是(shi)利用這種機制，使用流信息(xi)向瀏(liu)覽器推送信息(xi)。它基于 HTTP 協議，目前除了 IE/Edge，其他瀏(liu)覽器都支持。

SSE特點

SSE 與 WebSocket 作用相(xiang)似，都是建立瀏覽(lan)器(qi)(qi)與服務器(qi)(qi)之間的通信渠(qu)道，然后服務器(qi)(qi)向瀏覽(lan)器(qi)(qi)推(tui)送(song)信息。

總體來(lai)說，WebSocket 更強(qiang)大和(he)靈活。因為它是全雙工通道(dao)，可以雙向通信；SSE 是單向通道(dao)，只(zhi)能服(fu)務器(qi)(qi)向瀏覽(lan)器(qi)(qi)發(fa)送(song)，因為流信息本質上(shang)就是下(xia)載。如果(guo)瀏覽(lan)器(qi)(qi)向服(fu)務器(qi)(qi)發(fa)送(song)信息，就變(bian)成(cheng)了(le)另一次 HTTP 請求。

• SSE 使用 HTTP 協議，現有的服務器軟件都支持。WebSocket 是一個獨立協議。
• SSE 屬于輕量級，使用簡單；WebSocket 協議相對復雜。
• SSE 默認支持斷線重連，WebSocket 需要自己實現。
• SSE 一般只用來傳送文本，二進制數據需要編碼后傳送，WebSocket 默認支持傳送二進制數據。
• SSE 支持自定義發送的消息類型。

客戶端 API

1 EventSource 對象

SSE 的(de)客(ke)戶端 API 部署在EventSource對象上。下(xia)面的(de)代碼可以檢測瀏覽器(qi)是否支持 SSE。

    if ('EventSource' in window) {
      // ...
    }

上面(mian)的url可(ke)以與當前網址(zhi)同域，也(ye)可(ke)以跨域。跨域時，可(ke)以指定(ding)第(di)二個參數，打開withCredentials屬性，表示(shi)是否一(yi)起發(fa)送(song) Cookie。

var source = new EventSource(url, { withCredentials: true });

EventSource實(shi)例的readyState屬性(xing)(xing)，表明連接的當前狀態。該屬性(xing)(xing)只讀，可以(yi)取(qu)以(yi)下值。

• 0：相當于常量EventSource.CONNECTING，表示連接還未建立，或者斷線正在重連。
• 1：相當于常量EventSource.OPEN，表示連接已經建立，可以接受數據。
• 2：相當于常量EventSource.CLOSED，表示連接已斷，且不會重連。

2 基本用法

連接一(yi)旦建立，就會觸(chu)發(fa)open事(shi)件，可以在onopen屬性定義回調函數。

source.onopen = function (event) {
  // ...
};

// 另一種寫法
source.addEventListener('open', function (event) {
  // ...
}, false);

客戶端收到服(fu)務器發來的數(shu)據，就會觸發message事件，可以在onmessage屬性的回調函數(shu)。

source.onmessage = function (event) {
  var data = event.data;
  // handle message
};

// 另一種寫法
source.addEventListener('message', function (event) {
  var data = event.data;
  // handle message
}, false);

上面代碼中，事件對象的data屬性就是服務器端傳回的數據（文本格式(shi)）。

如果(guo)發生通信錯誤(wu)（比如連接中(zhong)斷），就會觸(chu)發error事件，可以在onerror屬(shu)性定義回調(diao)函數。

source.onerror = function (event) {
  // handle error event
};

// 另一種寫法
source.addEventListener('error', function (event) {
  // handle error event
}, false);

close方法用于關(guan)閉 SSE 連(lian)接。

source.close();

3 自定義事件

默認(ren)情況下(xia)，服務器發(fa)來的(de)數據，總是觸發(fa)瀏覽器EventSource實例的(de)message事(shi)件。開發(fa)者還(huan)可以自定義 SSE 事(shi)件，這種情況下(xia)，發(fa)送(song)回來的(de)數據不會觸發(fa)message事(shi)件。

source.addEventListener('foo', function (event) {
  var data = event.data;
  // handle message
}, false);

上面代碼中，瀏覽(lan)器對 SSE 的foo事(shi)件進(jin)行監聽(ting)。如(ru)何(he)實現服務器發送foo事(shi)件，請看下(xia)文。

服務器實現

1 數據格式

服務器(qi)向瀏覽器(qi)發(fa)送(song)的 SSE 數據，必須是(shi) UTF-8 編碼(ma)的文本，具有如(ru)下的 HTTP 頭信(xin)息。

Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive

上面三行之中，第一行的Content-Type必須指定 MIME 類型為event-steam。

每一次發送的信息，由若干個message組成，每個message之間用\n\n分隔。每個message內部由若干行組成，每一行都是如下格式，每行是\n結束。

[field]: value\n

上面的(de)field可以取四(si)個值。

• data
• event
• id
• retry

此(ci)外(wai)，還(huan)可以有冒(mao)號開(kai)頭的行，表示注釋(shi)。通常，服務(wu)器每隔一段時間(jian)就會(hui)向瀏(liu)覽(lan)器發送一個注釋(shi)，保持(chi)連接不(bu)中斷。

: This is a comment

下面是一個例子。

: this is a test stream\n\n

data: some text\n\n

data: another message\n
data: with two lines \n\n

2 data 字段

數據(ju)內容(rong)用data字段表示(shi)。

data:  message\n\n

如果數據很長，可以分成多行，最后一行用\n\n結尾，前面行都用\n結尾。

data: begin message\n
data: continue message\n\n

下面是一個發送 JSON 數據的例子。

data: {\n
data: "foo": "bar",\n
data: "baz", 555\n
data: }\n\n

3 id 字段

數據標識(shi)符用id字段表示，相當于每一(yi)條數據的編(bian)號。

id: msg1\n
data: message\n\n

瀏(liu)覽器用lastEventId屬性(xing)讀取(qu)這(zhe)(zhe)個(ge)值。一(yi)旦連接斷線，瀏(liu)覽器會發送一(yi)個(ge) HTTP 頭，里面包(bao)含一(yi)個(ge)特殊的Last-Event-ID頭信息，將這(zhe)(zhe)個(ge)值發送回來，用來幫助服務(wu)器端重建連接。因(yin)此，這(zhe)(zhe)個(ge)頭信息可(ke)以被(bei)視(shi)為一(yi)種同步機制。

4 event 字段

event字段表示自定義的事件類型，默認是message事件。瀏覽器可以用addEventListener()監聽該事件，下面代碼使用了自定義事件foo

event: foo\n
data: a foo event\n\n

data: an unnamed event\n\n

event: bar\n
data: a bar event\n\n

上面的代碼(ma)創造了三(san)條信息(xi)。第一條的名(ming)字是foo，觸(chu)發瀏覽器的foo事件(jian)；第二條未取名(ming)，表示默認類型，觸(chu)發瀏覽器的message事件(jian)；第三(san)條是bar，觸(chu)發瀏覽器的bar事件(jian)。

5 retry 字段

服務器(qi)可以用retry字段，指定瀏(liu)覽(lan)器(qi)重新發起連接的(de)時間(jian)間(jian)隔。

retry: 10000\n

兩種(zhong)(zhong)情況會導(dao)致瀏覽器(qi)重新發起(qi)連(lian)接：一種(zhong)(zhong)是時間間隔到期，二(er)是由于網(wang)絡錯(cuo)誤等原因，導(dao)致連(lian)接出錯(cuo)。

服務器實例

SSE 要求服務器與瀏覽器保持連接。對于不同的服務器軟件來說，所消耗的資源是不一樣的。Apache 服務器，每個連接就是一個線程，如果要維持大量連接，勢必要消耗大量資源。Node 則是所有連接都使用同一個線程，因此消耗的資源會小得多，但是這要求每個連接不能包含很耗時的操(cao)作(zuo)，比如磁盤的 IO 讀寫。

下(xia)面是 springboot的SseEmitter服務(wu)器實例，它使用自定義(yi)的event,添加了id字段

@GetMapping(value = "/sse1", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter handleSse() {
    SseEmitter emitter = new SseEmitter(60_000L); // 超時時間設為 60 秒

    // 異步發送數據（模擬實時推送）
    new Thread(() -> {
        try {
            for (int i = 0; i < 10; i++) {
                // 推送事件（格式為 "data: 內容\n\n"）
                SseEmitter.SseEventBuilder builder = SseEmitter.event()
                        .data("SSEMessage " + i + " - " + System.currentTimeMillis())
                        .id(String.valueOf(i))
                        .name("SSEEvent");
                emitter.send(builder);

                // 休眠 1 秒
                Thread.sleep(1000);
            }
            // 標記完成
            emitter.complete();
        } catch (Exception e) {
            // 發生錯誤時終止連接
            emitter.completeWithError(e);
        }
    }).start();

    return emitter;
}

然后在谷歌瀏(liu)覽器訪問(wen)//localhost:8080/sse1，看一(yi)下(xia)結果如(ru)下(xia)

各大編程語言下的SSE

Python、Go、Java、C# 在 SSE 性能方面的比較

在選擇用于 Server-Sent Events (SSE) 的開發語(yu)言時，性(xing)(xing)能是一個(ge)重要考量因素。以下是這四種(zhong)語(yu)言在 SSE 場景下的性(xing)(xing)能分(fen)析和比(bi)較：

性能綜合對比

語言	并發性能	內存效率	連接開銷	生態系統	適用場景
Go	?????	?????	?????	????	高并發、大規模連接
Java	????	????	???	?????	企業級應用、復雜業務邏輯
C#	????	????	???	????	Windows 環境、.NET 生態系統
Python	??	??	??	????	快速原型、中小規模應用

詳細分析

1. Go (Golang)

優勢：

• 極高的并發性能：Go 的 goroutine 是輕量級線程，可以輕松處理數十萬并發連接
• 低內存開銷：每個 goroutine 的初始棧大小只有 2KB，遠小于傳統線程
• 原生并發支持：語言級別支持并發，編寫高并發程序更加簡單
• 高效的標準庫：net/http 包對長連接有良好支持

示例代碼：

package main

import (
    "fmt"
    "net/http"
    "time"
)

func sseHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")
    w.Header().Set("Access-Control-Allow-Origin", "*")

    flusher, ok := w.(http.Flusher)
    if !ok {
        http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)
        return
    }

    // 模擬持續發送事件
    for {
        fmt.Fprintf(w, "data: %s\n\n", time.Now().Format("2006-01-02 15:04:05"))
        flusher.Flush()
        time.Sleep(1 * time.Second)
    }
}

func main() {
    http.HandleFunc("/events", sseHandler)
    fmt.Println("SSE server running on :8080")
    http.ListenAndServe(":8080", nil)
}

2. Java

優勢：

• 成熟的 NIO 框架：Netty 和 Java NIO 可以高效處理大量并發連接
• 強大的線程池管理：Java 的并發工具包提供了豐富的線程管理選項
• 企業級穩定性：JVM 經過多年優化，在大規模應用中表現穩定
• 豐富的生態系統：Spring Framework 等提供了完善的 SSE 支持

示例代碼（使用 Spring Boot）：

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@RestController
public class SseController {

    @GetMapping(path = "/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public SseEmitter handleSse() {
        SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        
        scheduler.scheduleAtFixedRate(() -> {
            try {
                emitter.send(SseEmitter.event()
                    .data("Current time: " + java.time.LocalDateTime.now()));
            } catch (IOException e) {
                emitter.completeWithError(e);
                scheduler.shutdown();
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        emitter.onCompletion(scheduler::shutdown);
        return emitter;
    }
}

3. C# (.NET)

優勢：

• 高效的異步編程模型：async/await 語法使高并發編程更加簡單
• 性能優化的運行時：.NET Core/.NET 5+ 在性能方面有顯著提升
• IIS 和 Kestrel 服務器：提供高效的連接處理能力
• Windows 集成優勢：在 Windows 環境中表現尤為出色

示例代碼（使用 ASP.NET Core）：

using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

public class SseController : Controller
{
    [HttpGet("events")]
    public async Task GetEvents()
    {
        Response.Headers.Add("Content-Type", "text/event-stream");
        Response.Headers.Add("Cache-Control", "no-cache");
        Response.Headers.Add("Connection", "keep-alive");
        
        while (true)
        {
            await Response.WriteAsync($"data: {DateTime.Now}\n\n");
            await Response.Body.FlushAsync();
            await Task.Delay(1000);
        }
    }
}

4. Python

優勢：

• 開發效率高：代碼簡潔，易于快速實現原型
• 豐富的異步框架：如 aiohttp、FastAPI 等支持異步 SSE
• 強大的生態系統：有大量可用的庫和框架

劣勢：

• 全局解釋器鎖 (GIL)：限制了真正的并行執行，影響高并發性能
• 相對較高的內存開銷：與其他編譯型語言相比，每個連接的內存開銷較大

示例代碼（使用 aiohttp）：

from aiohttp import web
import asyncio
import datetime

async def events(request):
    response = web.StreamResponse()
    response.headers['Content-Type'] = 'text/event-stream'
    response.headers['Cache-Control'] = 'no-cache'
    response.headers['Connection'] = 'keep-alive'
    await response.prepare(request)
    
    while True:
        data = f"data: {datetime.datetime.now()}\n\n"
        await response.write(data.encode('utf-8'))
        await asyncio.sleep(1)

app = web.Application()
app.router.add_get('/events', events)

if __name__ == '__main__':
    web.run_app(app, port=8080)

性能基準測試參考

根據(ju)各種性能(neng)基準測試（如 TechEmpower Web Framework Benchmarks）：

1. Go 通常在處理高并發連接時表現最佳，特別是在使用 fasthttp 等優化庫時
2. Java 在使用 Netty 或 Vert.x 等異步框架時，性能接近 Go，但內存使用較高
3. C# 在 .NET Core 上表現優異，性能與 Java 相當，有時甚至更好
4. Python 在純性能方面通常落后，但在使用 uvloop 等優化時可以有不錯的表現

選擇建議

1. 超大規模并發場景（10萬+連接）：選擇 Go，因其極低的每連接開銷和卓越的并發能力
2. 企業級復雜應用：選擇 Java 或 C#，因其成熟的生態系統和強大的工具支持
3. 快速原型和中小規模應用：選擇 Python，因其開發效率高
4. Windows 環境或 .NET 生態系統：選擇 C#，因其與 Windows 平臺的深度集成
5. 微服務架構：Go 和 Java 都是不錯的選擇，取決于團隊熟悉度

結論

對于 SSE 應用，從純性能角度考慮，Go 是最佳選擇，特別是在需要處理大量并發連接的場景。Java 和 C# 在性能上也非常接近，并且提供了更豐富的企業級功能。Python 雖(sui)然性能相對較低，但其開(kai)發(fa)效率和豐富的庫生態系統使(shi)其在中小(xiao)規(gui)模(mo)應用中仍然是一個(ge)可行(xing)的選擇(ze)。

最終的選(xuan)擇應該(gai)基(ji)于您(nin)的具(ju)體(ti)需(xu)求、團隊技術棧熟悉度、現有基(ji)礎設施(shi)以(yi)及性能要求來綜合考慮。

參考鏈接