在实时通信的世界里，WebSocket的光芒常常盖过了它的兄弟——SSE（Server-Sent Events）。但你可能不知道，这个看似简单的技术背后，是一套优雅、成熟且被所有现代浏览器原生支持的HTTP标准协议。今天，让我们深入挖掘SSE的真相。
很多人误以为SSE是某种HTTP连接的"hack"用法。实际上，SSE是一个完整的W3C标准：
标准文档：W3C Server-Sent Events Specification
当前状态：W3C Recommendation（正式推荐标准）
发布时间：2015年2月3日
标准链接：https://www.w3.org/TR/eventsource/
// 这不是某个库的API，而是浏览器原生实现
const eventSource = new EventSource('/api/stream');
// 遵循W3C EventSource接口规范应用层：SSE协议（基于HTTP）
传输层：HTTP/1.1或HTTP/2（Keep-Alive连接）
网络层：TCP/IP
物理层：以太网/WiFi/5GHTTP/1.1 200 OK
Content-Type: text/event-stream # 核心标识
Cache-Control: no-cache # 禁止缓存
Connection: keep-alive # 保持连接
Transfer-Encoding: chunked # 分块传输（可选）关键点：text/event-stream是IANA注册的标准MIME类型（RFC 2046），不是随意字符串。
// 一个完整的SSE消息单元
data: 这是消息内容\n // 数据行（可多行）
data: 继续上一消息的第二行\n
id: 42\n // 消息ID（用于重连）
event: message\n // 事件类型
retry: 10000\n // 重连间隔（毫秒）
\n // 空行表示消息结束
// 浏览器接收到的对象：
{
data: "这是消息内容\n继续上一消息的第二行",
lastEventId: "42",
type: "message"
}// Go语言实现SSE连接的核心逻辑
func serveSSE(w http.ResponseWriter, r *http.Request) {
// 1. 设置标准响应头
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
// 2. 获取刷新器（强制立即发送）
flusher, _ := w.(http.Flusher)
// 3. 保持HTTP连接，持续发送消息
for {
select {
case <-r.Context().Done():
return // 客户端断开
case msg := <-messageChannel:
// 4. 遵循SSE格式发送
fmt.Fprintf(w, "data: %s\n\n", msg)
flusher.Flush() // 立即发送到网络
}
}
// 连接在函数返回或客户端断开时结束
}客户端->服务器: GET /stream HTTP/1.1
客户端->服务器: Accept: text/event-stream
服务器->客户端: HTTP/1.1 200 OK
服务器->客户端: Content-Type: text/event-stream
服务器->客户端: Connection: keep-alive
服务器->客户端:
服务器->客户端: data: 欢迎连接\n\n
服务器->客户端: data: 实时数据...\n\n
服务器->客户端: data: 持续推送...\n\n
Note right of 客户端: 连接保持打开
Note left of 服务器: 可随时推送新消息客户端请求：
GET /api/events HTTP/1.1
Host: example.com
Accept: text/event-stream
服务器响应流：
HTTP/1.1 200 OK
Content-Type: text/event-stream
Connection: keep-alive
: 心跳保持连接
data: 用户alice登录
event: user-login
id: 101
data: {"temperature": 23.5}
event: sensor-data
id: 102
data: 系统即将维护
event: system-alert
id: 103
retry: 30000
... 持续不断 ...// 浏览器内置的重连逻辑
const es = new EventSource('/stream');
es.onerror = function(event) {
// 自动重连流程：
// 1. 关闭当前连接
// 2. 等待 retry 指定的时间（默认3秒）
// 3. 重新发起请求
// 4. 如果设置了 Last-Event-ID，会自动发送
};
// 服务器可控制重连间隔
// retry: 10000 表示10秒后重试// 服务器端：发送带ID的消息
func sendMessageWithID(w io.Writer, id int, data string) {
fmt.Fprintf(w, "id: %d\n", id)
fmt.Fprintf(w, "data: %s\n\n", data)
}
// 断线重连时，浏览器会自动发送
// Last-Event-ID: 最后收到的消息ID
// 服务器可以据此发送遗漏的消息// 服务器发送不同类型事件
data: 普通消息\n
event: notification\n
\n
data: 温度: 23.5°C\n
event: sensor-update\n
\n
data: 用户123已登录\n
event: user-activity\n
\n
// 客户端分别监听
eventSource.addEventListener('notification', handleNotification);
eventSource.addEventListener('sensor-update', handleSensorUpdate);
eventSource.addEventListener('user-activity', handleUserActivity);// 浏览器限制：每个域名最多6个并发HTTP/1.1连接
// 如果打开6个SSE连接，其他AJAX请求会被阻塞# HTTP/2的多路复用特性
# 一个TCP连接上可并行多个SSE流
客户端 → 打开一个TCP连接
→ 流1: GET /sensors/temperature
→ 流2: GET /sensors/humidity
→ 流3: GET /notifications
→ 流4: POST /api/data (AJAX请求)
→ 所有流共享同一连接，互不阻塞// 浏览器自动处理协议版本
const es = new EventSource('https://api.example.com/stream');
// 浏览器根据服务器支持情况选择HTTP/1.1或HTTP/2// 需要双向通信时（使用WebSocket）
// 如：在线游戏、视频聊天、实时对战
// 需要二进制数据传输时
// 如：文件传输、音视频流
// 需要低延迟控制消息时
// SSE有HTTP头部开销，WebSocket更轻量// 默认遵循同源策略
const es = new EventSource('/api/stream'); // 同源，正常
// 跨域需要CORS
const es2 = new EventSource('https://other-domain.com/stream');
// 服务器必须响应：Access-Control-Allow-Origin: *// 方案1：Cookie自动携带
const es = new EventSource('/private-stream');
// Cookie自动在请求头中发送
// 方案2：URL参数
const es = new EventSource('/stream?token=abc123');
// 方案3：自定义头部（需要CORS预检）
// EventSource不支持自定义头部，这是限制// 服务器端安全措施
func secureSSEHandler(w http.ResponseWriter, r *http.Request) {
// 1. 验证身份
token := r.URL.Query().Get("token")
if !validateToken(token) {
http.Error(w, "Unauthorized", 401)
return
}
// 2. 限制连接数
if connectionCount > maxConnections {
http.Error(w, "Too many connections", 429)
return
}
// 3. 设置安全头
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("X-Content-Type-Options", "nosniff")
// 4. 连接超时控制
ctx, cancel := context.WithTimeout(r.Context(), 1*time.Hour)
defer cancel()
// ... SSE逻辑
}// 多个事件类型通过一个连接发送
func multiplexedSSE(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
flusher, _ := w.(http.Flusher)
go sendHeartbeats(w, flusher)
go sendNotifications(w, flusher)
go sendSystemStats(w, flusher)
// 保持主goroutine运行
<-r.Context().Done()
}
func sendHeartbeats(w io.Writer, flusher http.Flusher) {
ticker := time.NewTicker(30 * time.Second)
for range ticker.C {
fmt.Fprintf(w, ": heartbeat\n\n")
flusher.Flush()
}
}// 启用HTTP压缩（文本数据压缩率高）
func compressedSSE(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Content-Encoding", "gzip") // 启用压缩
gz := gzip.NewWriter(w)
defer gz.Close()
fmt.Fprintf(gz, "data: 压缩的消息内容\n\n")
gz.Flush() // 需要同时刷新gzip writer和HTTP flusher
}// 自适应心跳间隔
func adaptiveHeartbeat(w io.Writer, flusher http.Flusher, ctx context.Context) {
lastActivity := time.Now()
heartbeatInterval := 30 * time.Second
for {
select {
case <-ctx.Done():
return
case <-time.After(heartbeatInterval):
if time.Since(lastActivity) > 25*time.Second {
fmt.Fprintf(w, ": heartbeat\n\n")
flusher.Flush()
}
// 动态调整心跳间隔
if time.Since(lastActivity) < 5*time.Second {
heartbeatInterval = 60 * time.Second // 活跃时减少心跳
} else {
heartbeatInterval = 30 * time.Second // 空闲时增加心跳
}
}
}
}// 浏览器关闭时也能接收推送
const registration = await navigator.serviceWorker.ready;
const subscription = await registration.pushManager.subscribe();
// 服务器通过Push服务发送，即使页面关闭# HTTP/3的0-RTT特性可加速SSE连接建立
# 多路复用更高效，无队头阻塞问题// 未来可能的标准扩展
// 1. 二进制数据支持
// 2. 压缩协议标准化
// 3. 服务质量分级SSE不是一个简单的"HTTP长连接hack"，而是一个设计精巧、标准完备、生产就绪的服务器推送协议。它的核心优势在于：
标准合规：W3C正式推荐标准，所有现代浏览器原生支持
简单优雅：基于现有HTTP基础设施，无需额外端口或复杂握手
功能完备：自动重连、事件ID追踪、多事件类型等企业级功能
运维友好：使用标准HTTP端口，防火墙友好，监控工具兼容
在物联网数据推送、实时监控、新闻通知等服务器到客户端的单向数据流场景中，SSE往往是比WebSocket更简单、更合适的选择。它完美体现了"简单即是美"的设计哲学——用最小的协议创新，解决最广泛的实时通信需求。
下次当你需要实现服务器推送时，先别急着上WebSocket。问问自己：我真的需要双向通信吗？如果答案是否定的，那么SSE可能就是那个你一直在寻找的、优雅而高效的解决方案。
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。