WebSocket 实时系统三平面:连接、推送、状态

WebSocket 实时系统三平面:连接、推送、状态

Hello,我是小兔大白糖。 读完能按连接面、推送面、状态面拆实时系统,并与推送优先通道文对齐。

WebSocket 实时系统拆成连接面、推送面、状态面;连接在线不等于状态权威。

估计阅读时间:26 分钟

连接面、推送面、状态面
连接面、推送面、状态面 · 点击查看 SVG 原图

一句话结论是什么?

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 对比

维度WebSocketSSE
通信方向全双工单向(服务端推送)
协议基础TCP + WebSocket 帧HTTP/1.1 长连接
二进制支持原生支持需 Base64 编码
自动重连需自行实现浏览器原生支持
穿透代理部分代理不支持 Upgrade兼容所有 HTTP 代理
连接数限制浏览器约 6-30/域名同 HTTP 连接数
适用场景实时双向交互(聊天、游戏)服务端推送(行情、通知)

1.5 类比

  • HTTP 轮询 = 不断打电话问"到了吗"——浪费话费,信息还滞后
  • WebSocket = 对讲机——一旦接通,双方随时说话,不用拨号
  • SSE = 电台广播——你只能听,不能回,但电台坏了会自动重新搜台
  • 心跳机制 = 对讲机定时报"收到请回复"——如果对方不回了,说明出事了

2. 核心原理是什么?

2.1 WebSocket 握手时序图

websocket realtime basics · 图 2
websocket realtime basics · 图 2 · 点击查看 SVG 原图

2.2 风控实时推送分布式架构

websocket realtime basics · 图 3
websocket realtime basics · 图 3 · 点击查看 SVG 原图

2.3 心跳保活机制

websocket realtime basics · 图 4
websocket realtime basics · 图 4 · 点击查看 SVG 原图

2.4 单用户多设备推送策略

websocket realtime basics · 图 5
websocket realtime basics · 图 5 · 点击查看 SVG 原图

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 1sWebSocket + Redis Pub/SubSMS/邮件兜底
账户异常登录通知单用户多设备\u003c 3sWebSocket 广播推送通知(APNs/FCM)
交易状态更新单用户推送\u003c 500msWebSocket轮询接口
全局系统公告广播\u003c 5sWebSocket 广播 + CDN站内信
风控大屏实时监控服务端推送\u003c 1sSSE / 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: 分布式环境下,怎么保证消息不丢失、不重复推送?

答: 三层保障:

  1. 消息确认:客户端收到消息后发送 ACK,服务端未收到 ACK 则在下次心跳时重推
  2. 消息去重:每条消息带全局唯一 msgId,客户端缓存最近 100 条 msgId,重复丢弃
  3. 离线补偿:用户断线期间消息写入 Redis Stream,重连后按 Last-Message-ID 拉取 missed messages

Q3: 百万级 WebSocket 连接,单机扛不住怎么扩容?

答: 水平扩展三板斧:

  1. 无状态化:节点不保存业务状态,用户连接映射写入 Redis,任意节点可处理任意用户的消息
  2. 负载均衡策略:WebSocket 用 IP Hash 或一致性哈希,确保同一用户长连接始终落到同一节点(减少跨节点同步)
  3. 分层架构: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 转,单用户多设备管。> 网关层做负载衡,无状态才能水平扩。 风控告警要实时,断线补偿不能少。