当前位置：首页 > news >正文

后端开发必看！6种服务端主动推送方案的实战对比

news 2026/6/23 18:49:55

写在前面的话

你有没有遇到过这样的场景：正在开发一个在线客服系统，用户发送消息后，客服端需要实时收到通知；或者开发一个电商后台，订单状态变化时管理员要立即知晓。这些需求的本质都指向一个问题：如何让服务器主动把数据推送给浏览器？

传统的HTTP请求都是"客户端问，服务器答"的模式，但现在我们需要反过来——服务器要主动开口说话。今天就来聊聊后端开发中常见的6种消息推送方案，从最原始的轮询到现代化的WebSocket，看看它们各自的优劣势和适用场景。

方案一：短轮询——简单粗暴的定时查询

短轮询可以说是最朴素的解决方案，实现思路极其简单：前端每隔几秒就问一次服务器"有新消息吗？"

实现思路

服务端提供一个查询接口，客户端通过定时器反复调用。我们来看一个实际的例子：

Java后端实现（Spring Boot）：

@RestController @RequestMapping("/api/notification") public class NotificationController {

@Autowired private NotificationService notificationService;  /** * 查询用户未读通知数量 */ @GetMapping("/unread-count") public ResponseEntity<NotificationDTO> getUnreadCount(@RequestParam Long userId) { int unreadCount = notificationService.countUnreadByUserId(userId); List<String> latestMessages = notificationService.getLatestMessages(userId, 5);  NotificationDTO dto = new NotificationDTO(); dto.setUserId(userId); dto.setUnreadCount(unreadCount); dto.setMessages(latestMessages); dto.setTimestamp(System.currentTimeMillis());  return ResponseEntity.ok(dto); }

}

前端JavaScript实现：

// 每3秒轮询一次 const userId = localStorage.getItem('userId'); setInterval(async () => { try { const response = await fetch(/api/notification/unread-count?userId=${userId}); const data = await response.json();

if (data.unreadCount > 0) { updateBadge(data.unreadCount); showNotificationPreview(data.messages); } } catch (error) { console.error('轮询失败:', error); }

}, 3000);

方案评价

这种方案最大的优点是实现零门槛，后端就是一个普通的查询接口，前端加个定时器就搞定。但缺点也很明显：

资源浪费严重：即使没有新消息，请求也要发
实时性差：3秒的轮询间隔意味着消息可能延迟3秒才被看到
服务器压力大：1000个在线用户每3秒请求一次，QPS就是333

适用场景：开发环境快速验证、对实时性要求不高的内部系统。

方案二：长轮询——优雅的等待艺术

长轮询是对短轮询的改进，核心思想是：客户端发起请求后，如果服务端暂时没有新数据，不要立即返回，而是挂起请求等待，直到有新数据或超时才响应。

深入实现

这里使用Spring的DeferredResult来实现异步响应：

@RestController @RequestMapping("/api/long-polling") public class LongPollingController {

// 存储每个用户的等待请求 private final Map<Long, DeferredResult<ResponseEntity<?>>> userRequests = new ConcurrentHashMap<>();  // 超时时间：30秒 private static final long TIMEOUT = 30000L;  /** * 长轮询接口 */ @GetMapping("/wait-message") public DeferredResult<ResponseEntity<?>> waitForMessage(@RequestParam Long userId) {  DeferredResult<ResponseEntity<?>> deferredResult = new DeferredResult<>(TIMEOUT);  // 超时处理：返回304状态码，告诉前端继续轮询 deferredResult.onTimeout(() -> { userRequests.remove(userId); deferredResult.setResult(ResponseEntity.status(HttpStatus.NOT_MODIFIED).build()); });  // 请求完成时清理 deferredResult.onCompletion(() -> { userRequests.remove(userId); });  // 先检查是否有待推送的消息 Message pendingMessage = messageService.getPendingMessage(userId); if (pendingMessage != null) { deferredResult.setResult(ResponseEntity.ok(pendingMessage)); } else { // 没有消息，挂起请求 userRequests.put(userId, deferredResult); }  return deferredResult; }  /** * 当有新消息时，主动唤醒等待的请求 */ public void pushMessage(Long userId, Message message) { DeferredResult<ResponseEntity<?>> deferredResult = userRequests.get(userId); if (deferredResult != null) { deferredResult.setResult(ResponseEntity.ok(message)); userRequests.remove(userId); } else { // 用户没有在等待，消息存入待推送队列 messageService.savePendingMessage(userId, message); } }

}

配置异步支持：

@Configuration @EnableAsync public class AsyncConfig implements WebMvcConfigurer {

@Override public void configureAsyncSupport(AsyncSupportConfigurer configurer) { // 配置异步请求超时时间 configurer.setDefaultTimeout(30000);  // 配置异步请求线程池 ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); executor.setMaxPoolSize(50); executor.setQueueCapacity(100); executor.setThreadNamePrefix("long-polling-"); executor.initialize(); configurer.setTaskExecutor(executor); }

}

前端实现（递归调用）：

方案评价

长轮询在中间件领域应用广泛，比如Nacos配置中心、Apollo配置中心都采用这种方案。

优点：

减少了无效请求
相比短轮询更省资源
实时性有所提升

缺点：

仍然需要反复建立HTTP连接
服务端需要维护大量挂起的请求
对Web容器的并发能力有要求

适用场景：配置中心、消息队列消费者、对实时性要求适中的场景。

方案三：Server-Sent Events（SSE）——单向数据流的优雅方案

SSE是HTML5提供的服务器推送技术，它允许服务器通过HTTP连接向客户端发送事件流。ChatGPT的打字机效果就是用SSE实现的。

核心特性

SSE基于HTTP协议，但响应的Content-Type是text/event-stream，这是一个持久化的连接，服务器可以持续向客户端推送数据。

Java后端实现（Spring Boot）：

@RestController @RequestMapping("/api/sse") @Slf4j public class SseController {

// 存储所有活跃的SSE连接 private final Map<Long, SseEmitter> sseEmitters = new ConcurrentHashMap<>();  /** * 客户端建立SSE连接 */ @GetMapping("/connect") public SseEmitter connect(@RequestParam Long userId) { // 设置超时时间为0，表示永不超时 SseEmitter emitter = new SseEmitter(0L);  // 连接建立成功的回调 emitter.onCompletion(() -> { log.info("用户{}的SSE连接已关闭", userId); sseEmitters.remove(userId); });  // 连接超时的回调 emitter.onTimeout(() -> { log.warn("用户{}的SSE连接超时", userId); sseEmitters.remove(userId); });  // 连接异常的回调 emitter.onError(throwable -> { log.error("用户{}的SSE连接异常", userId, throwable); sseEmitters.remove(userId); });  // 保存连接 sseEmitters.put(userId, emitter);  // 发送连接成功消息 try { emitter.send(SseEmitter.event() .name("connect") .data("连接建立成功，用户ID: " + userId) .build()); } catch (IOException e) { log.error("发送连接消息失败", e); }  return emitter; }  /** * 向指定用户推送消息 */ public void pushToUser(Long userId, String eventName, Object data) { SseEmitter emitter = sseEmitters.get(userId); if (emitter != null) { try { emitter.send(SseEmitter.event() .name(eventName) .data(data) .id(String.valueOf(System.currentTimeMillis())) .build()); } catch (IOException e) { log.error("向用户{}推送消息失败", userId, e); sseEmitters.remove(userId); } } }  /** * 广播消息给所有在线用户 */ public void broadcast(String eventName, Object data) { List<Long> failedUsers = new ArrayList<>();  sseEmitters.forEach((userId, emitter) -> { try { emitter.send(SseEmitter.event() .name(eventName) .data(data) .build()); } catch (IOException e) { failedUsers.add(userId); } });  // 清理发送失败的连接 failedUsers.forEach(sseEmitters::remove); }  /** * 获取当前在线用户数 */ @GetMapping("/online-count") public int getOnlineCount() { return sseEmitters.size(); }

}

业务层使用示例：

@Service public class OrderService {

@Autowired private SseController sseController;  /** * 订单状态变更时推送通知 */ public void updateOrderStatus(Long orderId, Long userId, String newStatus) { // 更新订单状态 orderRepository.updateStatus(orderId, newStatus);  // 通过SSE推送给用户 Map<String, Object> notification = new HashMap<>(); notification.put("orderId", orderId); notification.put("status", newStatus); notification.put("message", "您的订单状态已更新为：" + newStatus); notification.put("timestamp", LocalDateTime.now());  sseController.pushToUser(userId, "order-update", notification); }

}

前端实现：

let eventSource = null;

function connectSSE(userId) { // 创建SSE连接 eventSource = new EventSource(/api/sse/connect?userId=${userId});

// 监听连接建立事件 eventSource.addEventListener('connect', (e) => { console.log('SSE连接建立:', e.data); });  // 监听订单更新事件 eventSource.addEventListener('order-update', (e) => { const data = JSON.parse(e.data); showOrderNotification(data); updateOrderList(); });  // 监听通用消息事件 eventSource.addEventListener('message', (e) => { console.log('收到服务器消息:', e.data); });  // 连接错误处理 eventSource.onerror = (error) => { console.error('SSE连接错误:', error); // SSE会自动重连，不需要手动处理 };

}

// 页面卸载时关闭连接 window.addEventListener('beforeunload', () => { if (eventSource) { eventSource.close(); } });

方案评价

SSE是一个被低估的技术，ChatGPT的成功让更多人认识到它的价值。

优点：

基于HTTP，无需额外协议支持
自动重连机制
服务端实现简单
支持自定义事件类型
比WebSocket更轻量

缺点：

只支持单向推送（服务器到客户端）
IE浏览器不支持
连接数受浏览器限制（通常每个域名6个）

适用场景：股票行情推送、直播弹幕、AI对话流式输出、系统通知推送。

方案四：WebSocket——全双工通信的王者

WebSocket是目前最成熟的双向通信方案，它在HTTP握手后升级为独立的TCP连接，可以实现客户端和服务器之间的真正双向实时通信。

完整实现

引入依赖：

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency>

WebSocket配置类：

@Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer {

@Autowired private ChatWebSocketHandler chatWebSocketHandler;  @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(chatWebSocketHandler, "/ws/chat") .setAllowedOrigins("*") // 生产环境需要配置具体域名 .addInterceptors(new HandshakeInterceptor() { @Override public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) { // 从请求中获取用户ID String query = request.getURI().getQuery(); String userId = extractUserId(query); attributes.put("userId", userId); return true; }  @Override public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) { } }); }  private String extractUserId(String query) { if (query != null && query.contains("userId=")) { return query.split("userId=")[1].split("&")[0]; } return null; }

}

WebSocket处理器：

@Component @Slf4j public class ChatWebSocketHandler extends TextWebSocketHandler {

// 存储用户ID和WebSocket会话的映射 private final Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>(); // 存储在线用户列表 private final Set<String> onlineUsers = ConcurrentHashMap.newKeySet(); /** * 连接建立后 */ @Override public void afterConnectionEstablished(WebSocketSession session) throws Exception { String userId = (String) session.getAttributes().get("userId"); sessions.put(userId, session); onlineUsers.add(userId); log.info("用户{}建立WebSocket连接", userId); // 发送欢迎消息 sendMessage(session, createMessage("system", "连接成功，欢迎来到聊天室")); // 广播用户上线通知 broadcastUserStatus(userId, "online"); // 发送当前在线用户列表 sendOnlineUserList(session); } /** * 收到客户端消息 */ @Override protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { String userId = (String) session.getAttributes().get("userId"); String payload = message.getPayload(); log.info("收到用户{}的消息: {}", userId, payload); // 解析消息 ChatMessage chatMessage = JSON.parseObject(payload, ChatMessage.class); chatMessage.setSenderId(userId); chatMessage.setTimestamp(LocalDateTime.now()); // 根据消息类型处理 switch (chatMessage.getType()) { case "private": // 私聊消息 sendToUser(chatMessage.getReceiverId(), chatMessage); break; case "group": // 群聊消息 broadcastMessage(chatMessage); break; case "heartbeat": // 心跳消息 sendMessage(session, createMessage("heartbeat", "pong")); break; default: log.warn("未知的消息类型: {}", chatMessage.getType()); } } /** * 连接关闭后 */ @Override public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception { String userId = (String) session.getAttributes().get("userId"); sessions.remove(userId); onlineUsers.remove(userId); log.info("用户{}断开WebSocket连接, 原因: {}", userId, status); // 广播用户下线通知 broadcastUserStatus(userId, "offline"); } /** * 传输错误处理 */ @Override public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception { String userId = (String) session.getAttributes().get("userId"); log.error("用户{}的连接发生错误", userId, exception); if (session.isOpen()) { session.close(); } } /** * 向指定用户发送消息 */ public void sendToUser(String userId, Object message) { WebSocketSession session = sessions.get(userId); if (session != null && session.isOpen()) { try { String json = JSON.toJSONString(message); session.sendMessage(new TextMessage(json)); } catch (IOException e) { log.error("向用户{}发送消息失败", userId, e); } } } /** * 广播消息给所有在线用户 */ public void broadcastMessage(Object message) { String json = JSON.toJSONString(message); sessions.values().forEach(session -> { if (session.isOpen()) { try { session.sendMessage(new TextMessage(json)); } catch (IOException e) { log.error("广播消息失败", e); } } }); } /** * 广播用户状态变更 */ private void broadcastUserStatus(String userId, String status) { Map<String, Object> statusMessage = new HashMap<>(); statusMessage.put("type", "user-status"); statusMessage.put("userId", userId); statusMessage.put("status", status); statusMessage.put("onlineCount", onlineUsers.size()); broadcastMessage(statusMessage); } /** * 发送在线用户列表 */ private void sendOnlineUserList(WebSocketSession session) { Map<String, Object> message = new HashMap<>(); message.put("type", "online-users"); message.put("users", new ArrayList<>(onlineUsers)); sendMessage(session, message); } private void sendMessage(WebSocketSession session, Object message) { try { session.sendMessage(new TextMessage(JSON.toJSONString(message))); } catch (IOException e) { log.error("发送消息失败", e); } } private Map<String, Object> createMessage(String type, String content) { Map<String, Object> message = new HashMap<>(); message.put("type", type); message.put("content", content); message.put("timestamp", System.currentTimeMillis()); return message; }

}

前端实现：

class WebSocketClient { constructor(userId) { this.userId = userId; this.ws = null; this.heartbeatTimer = null; this.reconnectTimer = null; this.reconnectAttempts = 0; this.maxReconnectAttempts = 5; }

connect() { const wsUrl = `ws://localhost:8080/ws/chat?userId=${this.userId}`; this.ws = new WebSocket(wsUrl); this.ws.onopen = () => { console.log('WebSocket连接已建立'); this.reconnectAttempts = 0; this.startHeartbeat(); }; this.ws.onmessage = (event) => { const message = JSON.parse(event.data); this.handleMessage(message); }; this.ws.onerror = (error) => { console.error('WebSocket错误:', error); }; this.ws.onclose = () => { console.log('WebSocket连接已关闭'); this.stopHeartbeat(); this.attemptReconnect(); }; } handleMessage(message) { switch (message.type) { case 'private': showPrivateMessage(message); break; case 'group': showGroupMessage(message); break; case 'user-status': updateUserStatus(message); break; case 'online-users': updateOnlineUserList(message.users); break; case 'system': showSystemMessage(message.content); break; } } sendMessage(type, content, receiverId = null) { if (this.ws && this.ws.readyState === WebSocket.OPEN) { const message = { type: type, content: content, receiverId: receiverId }; this.ws.send(JSON.stringify(message)); } else { console.error('WebSocket未连接'); } } startHeartbeat() { this.heartbeatTimer = setInterval(() => { this.sendMessage('heartbeat', 'ping'); }, 30000); // 每30秒发送一次心跳 } stopHeartbeat() { if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); } } attemptReconnect() { if (this.reconnectAttempts < this.maxReconnectAttempts) { this.reconnectAttempts++; console.log(`尝试重连... (${this.reconnectAttempts}/${this.maxReconnectAttempts})`); this.reconnectTimer = setTimeout(() => { this.connect(); }, 3000 * this.reconnectAttempts); } else { console.error('重连失败，已达到最大重连次数'); } } disconnect() { if (this.ws) { this.ws.close(); } this.stopHeartbeat(); if (this.reconnectTimer) { clearTimeout(this.reconnectTimer); } }

}

// 使用示例 const wsClient = new WebSocketClient('user123'); wsClient.connect();

// 发送私聊消息 wsClient.sendMessage('private', 'Hello!', 'user456');

// 发送群聊消息 wsClient.sendMessage('group', '大家好！');

方案评价

WebSocket是目前最强大的实时通信方案，在即时通讯、在线游戏、协同编辑等场景中应用广泛。

优点：

真正的全双工通信
性能极高，延迟极低
支持二进制数据传输
协议开销小

缺点：

实现复杂度较高
需要考虑断线重连、心跳保活
部分代理服务器可能不支持

适用场景：即时通讯、在线游戏、实时协作、金融交易系统。

方案五：MQTT——物联网场景的首选

MQTT是专为物联网设计的轻量级消息协议，采用发布/订阅模式，非常适合网络不稳定、带宽受限的环境。

核心概念

MQTT有三个核心角色：

发布者（Publisher）：发送消息的客户端
订阅者（Subscriber）：接收消息的客户端
代理（Broker）：消息中转服务器，如Eclipse Mosquitto、EMQX

实现方案

引入依赖（使用Eclipse Paho）：

<dependency> <groupId>org.eclipse.paho</groupId> <artifactId>org.eclipse.paho.client.mqttv3</artifactId> <version>1.2.5</version> </dependency>

MQTT配置类：

@Configuration @ConfigurationProperties(prefix = "mqtt") @Data public class MqttConfig { private String broker = "tcp://localhost:1883"; private String clientId = "spring-boot-server"; private String username = "admin"; private String password = "admin"; private int qos = 1; private boolean retained = false; }

MQTT服务类：

@Service @Slf4j public class MqttService {

@Autowired private MqttConfig mqttConfig; private MqttClient mqttClient; @PostConstruct public void init() { try { mqttClient = new MqttClient( mqttConfig.getBroker(), mqttConfig.getClientId(), new MemoryPersistence() ); MqttConnectOptions options = new MqttConnectOptions(); options.setUserName(mqttConfig.getUsername()); options.setPassword(mqttConfig.getPassword().toCharArray()); options.setCleanSession(true); options.setAutomaticReconnect(true); options.setConnectionTimeout(10); options.setKeepAliveInterval(20); mqttClient.setCallback(new MqttCallback() { @Override public void connectionLost(Throwable cause) { log.error("MQTT连接丢失", cause); } @Override public void messageArrived(String topic, MqttMessage message) { log.info("收到MQTT消息 - 主题: {}, 内容: {}", topic, new String(message.getPayload())); } @Override public void deliveryComplete(IMqttDeliveryToken token) { log.debug("消息发送完成"); } }); mqttClient.connect(options); log.info("MQTT客户端连接成功"); } catch (MqttException e) { log.error("MQTT客户端初始化失败", e); } } /** * 发布消息到指定主题 */ public void publish(String topic, String payload) { try { if (mqttClient != null && mqttClient.isConnected()) { MqttMessage message = new MqttMessage(payload.getBytes(StandardCharsets.UTF_8)); message.setQos(mqttConfig.getQos()); message.setRetained(mqttConfig.isRetained()); mqttClient.publish(topic, message); log.info("发布消息到主题 {} - 内容: {}", topic, payload); } } catch (MqttException e) { log.error("发布消息失败", e); } } /** * 订阅主题 */ public void subscribe(String topic, IMqttMessageListener listener) { try { if (mqttClient != null && mqttClient.isConnected()) { mqttClient.subscribe(topic, mqttConfig.getQos(), listener); log.info("订阅主题: {}", topic); } } catch (MqttException e) { log.error("订阅主题失败", e); } /** * 取消订阅 */ public void unsubscribe(String topic) { try { if (mqttClient != null && mqttClient.isConnected()) { mqttClient.unsubscribe(topic); log.info("取消订阅主题: {}", topic); } } catch (MqttException e) { log.error("取消订阅失败", e); } } @PreDestroy public void destroy() { try { if (mqttClient != null && mqttClient.isConnected()) { mqttClient.disconnect(); mqttClient.close(); log.info("MQTT客户端已关闭"); } } catch (MqttException e) { log.error("关闭MQTT客户端失败", e); } } }

业务应用示例（智能家居场景）：

@Service public class SmartHomeService {

@Autowired private MqttService mqttService; // 主题定义 private static final String TOPIC_TEMPERATURE = "home/sensor/temperature"; private static final String TOPIC_LIGHT = "home/control/light"; private static final String TOPIC_ALARM = "home/alarm"; @PostConstruct public void init() { // 订阅温度传感器数据 mqttService.subscribe(TOPIC_TEMPERATURE, (topic, message) -> { String payload = new String(message.getPayload()); double temperature = Double.parseDouble(payload); handleTemperatureData(temperature); }); // 订阅报警信息 mqttService.subscribe(TOPIC_ALARM, (topic, message) -> { String alarmMessage = new String(message.getPayload()); handleAlarmMessage(alarmMessage); }); } /** * 处理温度数据 */ private void handleTemperatureData(double temperature) { log.info("当前温度: {}℃", temperature); // 温度过高，自动开启空调 if (temperature > 28) { controlAirConditioner("on", 26); } // 保存到数据库 saveSensorData("temperature", temperature); } /** * 处理报警消息 */ private void handleAlarmMessage(String message) { log.warn("收到报警: {}", message); // 推送给所有管理员 notifyAdmins("安全警报", message); // 记录日志 saveAlarmLog(message); } /** * 控制灯光 */ public void controlLight(String room, String action) { String topic = TOPIC_LIGHT + "/" + room; mqttService.publish(topic, action); } /** * 控制空调 */ public void controlAirConditioner(String action, int temperature) { Map<String, Object> command = new HashMap<>(); command.put("action", action); command.put("temperature", temperature); mqttService.publish("home/control/air-conditioner", JSON.toJSONString(command)); }

}

方案评价

MQTT在物联网领域是事实标准，适合设备数量巨大、网络环境复杂的场景。

优点：

协议极其轻量，开销小
支持QoS（消息质量保证）
支持离线消息
适合低带宽、高延迟网络

缺点：

需要额外的Broker服务器
学习成本相对较高
Web端支持需要额外配置

适用场景：物联网设备通信、智能家居、车联网、工业监控。

方案六：iframe流——古老但仍有用的技术

iframe流是一种比较古老的技术，通过在页面中嵌入隐藏的iframe，服务器持续向iframe推送数据。

简单实现

Java后端：

@Controller @RequestMapping("/iframe") public class IframeStreamController {

private final AtomicInteger counter = new AtomicInteger(0); @GetMapping("/stream") public void stream(HttpServletResponse response) throws IOException { response.setContentType("text/html;charset=UTF-8"); response.setHeader("Cache-Control", "no-cache"); PrintWriter writer = response.getWriter(); // 持续推送数据 while (true) { try { int count = counter.incrementAndGet(); String script = String.format( "<script>parent.updateCount(%d);</script>", count); writer.print(script); writer.flush(); Thread.sleep(2000); } catch (InterruptedException e) { break; } } }

}

前端HTML：

消息数量: 0

<!-- 隐藏的iframe --> <iframe src="/iframe/stream" style="display:none;"></iframe> <script> function updateCount(count) { document.getElementById('count').innerText = count; } </script>

</body> </html>

方案评价

iframe流是一种过时的技术，但在某些特定场景下仍可作为降级方案。

优点：

实现极其简单
兼容性好

缺点：

浏览器会一直显示加载状态
体验极差
资源占用高

适用场景：几乎不推荐使用，仅作为极端降级方案。

技术选型建议

面对这么多方案，该如何选择？我根据实际项目经验给出以下建议：

按场景选择

┌────────────────────┬──────────────────┬─────────────────────────────┐ │ 场景 │ 推荐方案 │ 理由 │ ├────────────────────┼──────────────────┼─────────────────────────────┤ │ 即时通讯、在线客服 │ WebSocket │ 需要双向实时通信 │ ├────────────────────┼──────────────────┼─────────────────────────────┤ │ AI对话、流式输出 │ SSE │ 单向推送，实现简单 │ ├────────────────────┼──────────────────┼─────────────────────────────┤ │ 后台系统通知 │ SSE 或长轮询 │ 实时性要求不高，SSE更优雅 │ ├────────────────────┼──────────────────┼─────────────────────────────┤ │ 股票行情、监控大屏 │ SSE 或 WebSocket │ 取决于是否需要双向通信 │ ├────────────────────┼──────────────────┼─────────────────────────────┤ │ 物联网设备通信 │ MQTT │ 专为物联网设计 │ ├────────────────────┼──────────────────┼─────────────────────────────┤ │ 配置中心 │ 长轮询 │ 成熟方案，Nacos、Apollo都用 │ ├────────────────────┼──────────────────┼─────────────────────────────┤ │ 快速原型验证 │ 短轮询 │ 实现最简单 │ └────────────────────┴──────────────────┴─────────────────────────────┘

按团队能力选择

前端主导团队：优先SSE，前端EventSourceAPI很友好
全栈均衡团队：WebSocket，功能最强大
后端主导团队：长轮询，后端掌控力强
物联网团队：MQTT，行业标准

按技术栈选择

Spring Boot：WebSocket和SSE都有很好的支持
Node.js：Socket.io（WebSocket封装）生态成熟
微服务架构：考虑消息队列+WebSocket的组合方案
Serverless：SSE，无状态特性更匹配

性能优化建议

无论选择哪种方案，都要注意以下性能要点：

连接管理

// 使用ConcurrentHashMap管理连接 private final Map<String, Session> sessions = new ConcurrentHashMap<>();

// 定期清理无效连接 @Scheduled(fixedRate = 60000) public void cleanInactiveSessions() { sessions.entrySet().removeIf(entry -> !entry.getValue().isOpen()); }

消息队列缓冲

// 使用阻塞队列缓冲消息 private final BlockingQueue<Message> messageQueue = new LinkedBlockingQueue<>(1000);

// 异步消费 @Async public void consumeMessages() { while (true) { try { Message message = messageQueue.take(); processMessage(message); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } }

限流保护

// 使用Guava的RateLimiter限流 private final RateLimiter rateLimiter = RateLimiter.create(100.0); // 每秒100个请求

public void sendMessage(String userId, String message) { if (rateLimiter.tryAcquire()) { doSendMessage(userId, message); } else { log.warn("发送频率过高，消息被丢弃"); } }

写在最后

消息推送看似简单，实则涉及网络协议、并发控制、资源管理等多个技术点。没有完美的方案，只有最适合的方案。

从我的实践经验来看：