
Hello,我是小兔大白糖。 读完能按连接面、推送面、状态面拆实时系统,并与推送优先通道文对齐。
WebSocket 实时系统拆成连接面、推送面、状态面;连接在线不等于状态权威。
估计阅读时间:26 分钟
一句话结论是什么?
WebSocket 是 HTTP 的"升级形态",通过一次 TCP 连接上的握手协议(HTTP Upgrade)建立全双工长连接,解决了 HTTP 轮询的实时性差和资源浪费问题;风控场景下用于实时告警推送、交易状态通知,核心挑战是分布式环境下的跨节点广播、海量连接管理和心跳保活。
1. 这是什么?概念怎么定义
1.1 WebSocket 协议
WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议。它与 HTTP 的关系是:
- 建立阶段:使用 HTTP 协议发送 Upgrade 请求,协商升级为 WebSocket
- 通信阶段:握手完成后,双方使用 WebSocket 帧格式独立收发数据,不再依赖 HTTP
- 关闭阶段:任意一方发送 Close 帧,双方优雅关闭 TCP 连接
1.2 WebSocket 帧格式(核心结构)
WebSocket 数据以**帧(Frame)**为单位传输,每帧包含:
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| |Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - -+
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
关键字段:
- FIN:1 bit,是否为消息的最后一帧
- Opcode:4 bit,帧类型(0x1=Text, 0x2=Binary, 0x8=Close, 0x9=Ping, 0xA=Pong)
- MASK:1 bit,客户端发送必须置 1(掩码),服务端发送必须置 0
- Payload length:7 bit + 可选扩展(126/127),最大支持 2^64 字节
- Masking-key:32 bit,客户端掩码密钥(防止缓存投毒攻击)
1.3 SSE(Server-Sent Events)
SSE 是 HTTP/1.1 之上的轻量级单向推送协议,特点:
- 单向:仅服务端 → 客户端推送
- 基于 HTTP:无需升级协议,天然兼容 HTTP 基础设施(负载均衡、CDN)
- 自动重连:浏览器内置 EventSource API,断线后自动重连并携带 Last-Event-ID
- 文本 only:仅支持 UTF-8 文本,二进制需 Base64 编码
1.4 WebSocket vs SSE 对比
| 维度 | WebSocket | SSE |
|---|---|---|
| 通信方向 | 全双工 | 单向(服务端推送) |
| 协议基础 | TCP + WebSocket 帧 | HTTP/1.1 长连接 |
| 二进制支持 | 原生支持 | 需 Base64 编码 |
| 自动重连 | 需自行实现 | 浏览器原生支持 |
| 穿透代理 | 部分代理不支持 Upgrade | 兼容所有 HTTP 代理 |
| 连接数限制 | 浏览器约 6-30/域名 | 同 HTTP 连接数 |
| 适用场景 | 实时双向交互(聊天、游戏) | 服务端推送(行情、通知) |
1.5 类比
- HTTP 轮询 = 不断打电话问"到了吗"——浪费话费,信息还滞后
- WebSocket = 对讲机——一旦接通,双方随时说话,不用拨号
- SSE = 电台广播——你只能听,不能回,但电台坏了会自动重新搜台
- 心跳机制 = 对讲机定时报"收到请回复"——如果对方不回了,说明出事了
2. 核心原理是什么?
2.1 WebSocket 握手时序图
2.2 风控实时推送分布式架构
2.3 心跳保活机制
2.4 单用户多设备推送策略
3. 怎么用?关键代码与配置
3.1 Spring WebSocket + STOMP 风控告警推送
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
// 启用简单的内存消息代理,前缀为 /topic
config.enableSimpleBroker("/topic", "/queue");
// 客户端发送消息的前缀
config.setApplicationDestinationPrefixes("/app");
// 点对点消息前缀
config.setUserDestinationPrefix("/user");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws/risk-alerts")
.setAllowedOriginPatterns("*")
.withSockJS(); // 降级支持
}
}
/**
* 风控告警 WebSocket 控制器
*/
@Controller
public class RiskAlertController {
private final SimpMessagingTemplate messagingTemplate;
private final UserSessionRegistry sessionRegistry;
public RiskAlertController(SimpMessagingTemplate messagingTemplate,
UserSessionRegistry sessionRegistry) {
this.messagingTemplate = messagingTemplate;
this.sessionRegistry = sessionRegistry;
}
/**
* 向指定用户推送风控告警(跨节点兼容)
*/
public void sendRiskAlertToUser(String userId, RiskAlert alert) {
// STOMP 协议的点对点推送:/user/{userId}/topic/risk-alerts
messagingTemplate.convertAndSendToUser(
userId,
"/topic/risk-alerts",
alert
);
}
/**
* 广播推送(全量在线用户)
*/
public void broadcastAlert(RiskAlert alert) {
messagingTemplate.convertAndSend("/topic/global-alerts", alert);
}
/**
* 处理客户端订阅请求
*/
@SubscribeMapping("/topic/risk-alerts")
public RiskAlertSubscription handleSubscription(Principal principal) {
String userId = principal.getName();
sessionRegistry.registerUserSession(userId, getCurrentSessionId());
return RiskAlertSubscription.builder()
.userId(userId)
.subscribedTopics(List.of("risk-alerts", "account-status"))
.timestamp(Instant.now())
.build();
}
}3.2 Netty 原生 WebSocket 实现(高性能场景)
@Component
public class RiskAlertWebSocketServer {
private final EventLoopGroup bossGroup = new NioEventLoopGroup(1);
private final EventLoopGroup workerGroup = new NioEventLoopGroup();
private final RiskAlertHandler alertHandler;
@PostConstruct
public void start() throws InterruptedException {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ChannelPipeline pipeline = ch.pipeline();
// HTTP 编解码器(用于握手阶段)
pipeline.addLast(new HttpServerCodec());
pipeline.addLast(new HttpObjectAggregator(65536));
// WebSocket 握手处理器
pipeline.addLast(new WebSocketServerProtocolHandler(
"/ws/risk-alerts",
null,
true,
65536,
false,
true
));
// 自定义业务处理器
pipeline.addLast(alertHandler);
}
});
b.bind(8081).sync();
log.info("WebSocket server started on port 8081");
}
@PreDestroy
public void stop() {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
/**
* Netty WebSocket 业务处理器
*/
@ChannelHandler.Sharable
@Component
public class RiskAlertHandler extends SimpleChannelInboundHandler<WebSocketFrame> {
private static final ConcurrentHashMap<String, Channel> userChannelMap = new ConcurrentHashMap<>();
private static final ConcurrentHashMap<Channel, String> channelUserMap = new ConcurrentHashMap<>();
@Override
protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) {
if (frame instanceof TextWebSocketFrame) {
String text = ((TextWebSocketFrame) frame).text();
handleMessage(ctx.channel(), text);
} else if (frame instanceof PingWebSocketFrame) {
// 自动回复 Pong
ctx.writeAndFlush(new PongWebSocketFrame(frame.content().retain()));
} else if (frame instanceof CloseWebSocketFrame) {
ctx.close();
}
}
/**
* 处理客户端消息
*/
private void handleMessage(Channel channel, String message) {
try {
ClientMessage clientMsg = JsonUtils.fromJson(message, ClientMessage.class);
switch (clientMsg.getType()) {
case "AUTH":
handleAuth(channel, clientMsg);
break;
case "SUBSCRIBE":
handleSubscribe(channel, clientMsg);
break;
case "PONG":
// 更新心跳时间
channel.attr(AttributeKey.<Long>valueOf("lastPong")).set(System.currentTimeMillis());
break;
default:
log.warn("Unknown message type: {}", clientMsg.getType());
}
} catch (Exception e) {
log.error("Failed to handle message: {}", message, e);
channel.writeAndFlush(new TextWebSocketFrame(
"{\"error\":\"INVALID_MESSAGE\"}"
));
}
}
private void handleAuth(Channel channel, ClientMessage msg) {
String token = msg.getToken();
// JWT 验证
Claims claims = JwtUtils.parseToken(token);
String userId = claims.getSubject();
// 绑定用户与 Channel
// 断开旧连接(单设备登录策略)
Channel oldChannel = userChannelMap.put(userId, channel);
if (oldChannel != null && oldChannel != channel) {
oldChannel.writeAndFlush(new TextWebSocketFrame(
"{\"type\":\"KICKED\",\"reason\":\"NEW_LOGIN\"}"
));
oldChannel.close();
}
channelUserMap.put(channel, userId);
channel.attr(AttributeKey.<String>valueOf("userId")).set(userId);
// 发送确认
channel.writeAndFlush(new TextWebSocketFrame(
String.format("{\"type\":\"AUTH_OK\",\"userId\":\"%s\"}", userId)
));
}
/**
* 服务端主动推送告警
*/
public void pushAlert(String userId, RiskAlert alert) {
Channel channel = userChannelMap.get(userId);
if (channel != null && channel.isActive()) {
String json = JsonUtils.toJson(alert);
channel.writeAndFlush(new TextWebSocketFrame(json));
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) {
Channel channel = ctx.channel();
String userId = channelUserMap.remove(channel);
if (userId != null) {
userChannelMap.remove(userId, channel); // 仅移除当前 channel,避免误删新连接
}
log.info("Channel closed for user: {}", userId);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
log.error("WebSocket error", cause);
ctx.close();
}
}3.3 分布式跨节点推送(Redis Pub/Sub)
@Service
public class DistributedAlertPublisher {
private final StringRedisTemplate redisTemplate;
private final RiskAlertHandler localAlertHandler;
@Value("${risk.websocket.redis-channel:ws:risk-alerts}")
private String redisChannel;
/**
* 发布告警到 Redis,所有 WS 节点订阅消费
*/
public void publishAlert(RiskAlert alert) {
String message = JsonUtils.toJson(alert);
redisTemplate.convertAndSend(redisChannel, message);
}
/**
* Redis 消息监听器:接收其他节点转发的告警,本地推送
*/
@Component
public class AlertRedisListener implements MessageListener {
@Override
public void onMessage(Message message, byte[] pattern) {
String body = new String(message.getBody());
RiskAlert alert = JsonUtils.fromJson(body, RiskAlert.class);
// 只推送本节点持有的连接
String targetUserId = alert.getTargetUserId();
if (targetUserId != null) {
localAlertHandler.pushAlert(targetUserId, alert);
} else {
// 广播:遍历本节点所有连接
localAlertHandler.broadcast(alert);
}
}
}
}
@Configuration
public class RedisPubSubConfig {
@Bean
public RedisMessageListenerContainer redisContainer(
RedisConnectionFactory connectionFactory,
AlertRedisListener listener) {
RedisMessageListenerContainer container = new RedisMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
container.addMessageListener(listener, new PatternTopic("ws:risk-alerts"));
container.setTaskExecutor(Executors.newFixedThreadPool(10));
return container;
}
}3.4 心跳检测与连接清理调度器
@Component
public class HeartbeatMonitor {
private final RiskAlertHandler alertHandler;
private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
@Value("${risk.websocket.heartbeat-interval-sec:30}")
private int heartbeatInterval;
@Value("${risk.websocket.heartbeat-miss-threshold:3}")
private int missThreshold;
@PostConstruct
public void start() {
// 每 30 秒执行一次心跳检测
scheduler.scheduleAtFixedRate(
this::checkHeartbeats,
heartbeatInterval,
heartbeatInterval,
TimeUnit.SECONDS
);
// 每 10 秒发送一次 Ping
scheduler.scheduleAtFixedRate(
this::sendPingToAll,
heartbeatInterval,
heartbeatInterval,
TimeUnit.SECONDS
);
}
/**
* 向所有活跃连接发送 Ping
*/
private void sendPingToAll() {
alertHandler.getAllChannels().forEach(channel -> {
if (channel.isActive()) {
// Netty 的 PingWebSocketFrame
channel.writeAndFlush(new PingWebSocketFrame());
}
});
}
/**
* 检测超时连接并清理
*/
private void checkHeartbeats() {
long now = System.currentTimeMillis();
long timeoutMs = heartbeatInterval * missThreshold * 1000L;
alertHandler.getAllChannels().forEach(channel -> {
Long lastPong = channel.attr(AttributeKey.<Long>valueOf("lastPong")).get();
if (lastPong == null) {
// 从未收到过 Pong,可能是刚连接
lastPong = channel.attr(AttributeKey.<Long>valueOf("connectTime")).get();
}
if (lastPong != null && (now - lastPong) > timeoutMs) {
String userId = channel.attr(AttributeKey.<String>valueOf("userId")).get();
log.warn("Heartbeat timeout for user: {}, closing channel", userId);
channel.close();
}
});
}
@PreDestroy
public void stop() {
scheduler.shutdownNow();
}
}4. 业界怎么做?
4.1 大型加密货币交易所:全球行情与风控实时推送
大型加密货币交易所 的 WebSocket 服务处理全球数千万并发连接,提供行情、交易、账户通知等实时数据推送:
技术特点:
- 协议分层:公共数据(行情)用无状态 WebSocket,私有数据(账户、风控告警)需鉴权后订阅
- 流控机制:单连接限速(如 10 msg/s),超限断开或降速,防止恶意客户端拖垮服务
- 多地域部署:WebSocket 集群按地域分布,用户就近连接,跨地域通过内部专线同步关键状态
- 心跳策略:服务端每 3 分钟发送 Ping,客户端必须在 10 分钟内响应 Pong,否则断开
踩过的坑:
- 连接泄露:早期未正确清理断开的 Channel,导致 Netty 内存泄漏。解决:强制 channelInactive 中移除所有引用,并启用 Netty 的内存泄漏检测(
-Dio.netty.leakDetectionLevel=advanced)。 - 消息堆积:某节点因 GC 暂停导致消息队列堆积,恢复后瞬间 burst 压垮客户端。解决:引入发送缓冲区上限,超过则丢弃非关键消息。
4.2 Slack:亿级连接的 WebSocket 网关
Slack 的 WebSocket 网关(Edge/Flannel)支撑全球每日亿级消息:
架构设计:
- 长连接网关(Flannel):基于 Erlang/Elixir 实现,单节点可维持数百万连接,网关只做消息路由,无业务逻辑
- 多设备同步:同一用户的所有设备通过 Gateway 同步消息状态(已读/未读),WebSocket 推送确保状态实时一致
- 优雅降级:网络质量差时,自动降级为长轮询(Long Polling),保证消息可达性
风控相关启示:
- Slack 的"安全告警机器人"通过 WebSocket 实时推送异常登录通知,用户可立即点击"这不是我"撤销会话
- 多设备状态同步机制确保了风控操作(如踢掉所有设备)的实时生效
4.3 腾讯:微信 WebSocket 长连接与心跳优化
微信的消息推送基于自研长连接协议(类似 WebSocket),支撑 10亿+ 用户的实时消息:
核心优化:
- 智能心跳:根据网络质量动态调整心跳间隔(WiFi 下 300s,4G 下 180s,弱网 60s),平衡保活与耗电
- 心跳合并:心跳包与业务 ACK 合并发送,减少空包数量
- 断线重连:多层重连策略(快速重连 → 慢速重连 → 全量重新登录),并携带上次同步 ID 防止消息丢失
5. 业务场景怎么对照?
场景对照:先分清连接面、推送面、状态面职责,再谈网关扩容与多端策略。
5.1 风控场景映射
| 业务场景 | 推送类型 | 实时性要求 | 技术方案 | 降级策略 |
|---|---|---|---|---|
| 实时风控告警 | 单用户推送 | \u003c 1s | WebSocket + Redis Pub/Sub | SMS/邮件兜底 |
| 账户异常登录通知 | 单用户多设备 | \u003c 3s | WebSocket 广播 | 推送通知(APNs/FCM) |
| 交易状态更新 | 单用户推送 | \u003c 500ms | WebSocket | 轮询接口 |
| 全局系统公告 | 广播 | \u003c 5s | WebSocket 广播 + CDN | 站内信 |
| 风控大屏实时监控 | 服务端推送 | \u003c 1s | SSE / WebSocket | 静态刷新页 |
5.2 常见误区 vs 正确做法
| ❌ 常见误区 | ✅ 正确做法 |
|---|---|
| 心跳间隔固定(如 30s 一刀切) | 根据网络质量动态调整,移动端适当放宽 |
| 单用户多设备共用同一 Channel | 每个设备独立 Channel,支持设备级推送控制 |
| 消息不分类,全部广播 | 按用户/角色/主题分级订阅,减少无效推送 |
| 断开后无限重连 | 指数退避重连,最大重试上限,防止 DDoS 自己 |
| 无连接数上限 | 单机/单用户设置最大连接数,超限拒绝或踢旧 |
| WebSocket 直连后端,无网关 | 前置 Nginx/HAProxy 做负载均衡和 SSL 卸载 |
| 忽略内存泄漏 | 启用 Netty 内存泄漏检测,定期 Dump 分析 |
5.3 选型建议
When to use WebSocket:
- 需要双向实时通信(客户端也要发消息)
- 低延迟要求高(\u003c 500ms)
- 连接数可控(内部系统、管理后台)
When to use SSE:
- 仅需服务端单向推送(行情、新闻、通知)
- 需要穿透复杂 HTTP 代理/CDN
- 快速接入,不想处理 WebSocket 协议细节
When NOT to use WebSocket:
- 消息频率极低(如每天 1 条),HTTP 轮询更简单
- 需要广播给百万级用户(用 Kafka + 客户端轮询更合适)
- 网络环境极差(如某些企业防火墙阻断 WebSocket Upgrade)
6. 高频问题怎么答?
Q1: WebSocket 与 HTTP/2 Server Push 有什么区别?
答: 本质不同:
- WebSocket:全双工独立协议,握手后脱离 HTTP,服务端和客户端可随时主动发送消息
- HTTP/2 Server Push:服务端在响应 HTML 时主动推送 CSS/JS 等资源,但仍然是请求-响应模式,不能实现服务端到客户端的独立消息推送
- 一句话:HTTP/2 Push 是"服务端塞额外资源到响应里",WebSocket 是"建立一条独立通道随时聊天"
Q2: 分布式环境下,怎么保证消息不丢失、不重复推送?
答: 三层保障:
- 消息确认:客户端收到消息后发送 ACK,服务端未收到 ACK 则在下次心跳时重推
- 消息去重:每条消息带全局唯一 msgId,客户端缓存最近 100 条 msgId,重复丢弃
- 离线补偿:用户断线期间消息写入 Redis Stream,重连后按 Last-Message-ID 拉取 missed messages
Q3: 百万级 WebSocket 连接,单机扛不住怎么扩容?
答: 水平扩展三板斧:
- 无状态化:节点不保存业务状态,用户连接映射写入 Redis,任意节点可处理任意用户的消息
- 负载均衡策略:WebSocket 用 IP Hash 或一致性哈希,确保同一用户长连接始终落到同一节点(减少跨节点同步)
- 分层架构:L4 负载均衡(HAProxy)→ WebSocket 网关集群 → 业务服务,网关只做连接管理和消息路由
Q4: Nginx 反向代理 WebSocket 有什么坑?
答: 常见配置陷阱:
- proxy_read_timeout:默认 60s,WebSocket 长连接会被 Nginx 断开。需设为较长值(如 86400s)或根据心跳间隔调整
- proxy_buffering:必须关闭(
proxy_buffering off;),否则 Nginx 会缓冲响应导致实时性丧失 - Upgrade 头丢失:必须显式配置
proxy_set_header Upgrade $http_upgrade;和proxy_set_header Connection "upgrade"; - 连接数上限:Nginx worker_connections 默认 512,需调大到 65535+
Q5: 移动端 WebSocket 频繁断连怎么优化?
答: 移动端特有的网络切换问题:
- App 前后台切换:iOS/Android 后台会冻结 socket,需在 App 回到前台时主动重连
- 网络切换(WiFi ↔ 4G):TCP 连接会断开,需监听网络变化事件,切换后 0 延迟重连
- 心跳自适应:WiFi 下 5 分钟心跳,4G 下 3 分钟,弱网 1 分钟
- 连接预热:App 启动时立即建立 WebSocket,不等用户操作,减少首次消息延迟
Q6: WebSocket 安全性怎么保证?
答: 多层防护:
- 传输层:强制 wss://(TLS),禁止明文 ws://
- 鉴权层:连接建立后第一条消息发送 JWT Token 鉴权,拒绝匿名连接;Token 过期时主动断开
- 频率限制:单连接消息频率限制(如 100 msg/min),超限断开
- Payload 校验:限制单帧大小(如 64KB),防止超大帧攻击;JSON 解析异常直接断开
- CORS 控制:严格校验 Origin 头,防止恶意网页连接
Q7: 单用户多设备场景下,如何控制推送策略?
答: 精细化设备管理:
- 设备注册:每个设备连接时上报设备类型(Web/iOS/Android)、设备 ID
- 推送策略配置:用户可设置"仅主设备接收告警"或"所有设备接收"
- 优先级推送:紧急告警先推主设备,3s 无 ACK 再推其他设备
- 设备踢出:用户修改密码后,向所有旧设备推送 KICKED 消息并断开连接
记忆口诀: HTTP Upgrade 建通道,全双工是对讲机。 心跳保活像报平安,三次不应就断线。 分布式靠 Redis 转,单用户多设备管。> 网关层做负载衡,无状态才能水平扩。 风控告警要实时,断线补偿不能少。