长轮询、短轮询、WebSocket 和 SSE 四种实时通信技术 详解

长轮询、短轮询、WebSocket 和 SSE 四种实时通信技术 详解

一、概念

1. 短轮询（Short Polling）

• 定义：客户端定期向服务器发送请求，以获取最新数据。
• 工作流程：
  1. 客户端设置一个定时器，定期（如每秒）向服务器发送 HTTP 请求。
  2. 服务器收到请求后，立即返回当前数据（无论是否有更新）。
• 特点：实现简单，但实时性差，资源消耗大。
• 适用场景：对实时性要求不高的场景，如简单状态更新、天气查询等。

2. 长轮询（Long Polling）

• 定义：客户端向服务器发送请求，服务器保持连接打开，直到有新数据可返回或超时。
• 工作流程：
  1. 客户端发送请求后，服务器不会立即返回响应，而是等待直到有新数据或达到超时时间。
  2. 一旦有数据，服务器立即返回响应，客户端收到响应后立即发送新的请求。
• 特点：提高了实时性，减少了请求次数，但实现复杂度稍高。
• 适用场景：需要较高实时性但不想引入复杂技术的场景，如聊天室、在线客服等。

3. WebSocket

• 定义：一种在单个 TCP 连接上进行全双工通信的协议，允许服务器主动向客户端推送数据。
• 工作流程：
  1. 客户端和服务器通过 HTTP 握手建立连接后，升级为 WebSocket 协议。
  2. 此后，双方可以随时发送数据，无需等待对方请求。
• 特点：提供高实时性和低资源消耗，但实现复杂度较高，需要服务器和客户端的支持。
• 适用场景：需要高实时性和双向通信的场景，如在线游戏、实时协作工具、股票交易平台等。

4. SSE（Server-Sent Events）

• 定义：一种服务器向客户端推送事件的机制，基于 HTTP 协议，支持单向通信（服务器到客户端）。
• 工作流程：
  1. 客户端通过 HTTP 请求连接到服务器，并指定接收事件的 URL。
  2. 服务器可以随时向客户端发送数据，客户端通过 EventSource 接口接收事件。
• 特点：实现简单，资源消耗低，但只支持服务器到客户端的单向通信。
• 适用场景：服务器向客户端推送单向事件的场景，如股票行情、新闻更新、系统通知等。

二、流程图对比

1. 短轮询流程图

2. 长轮询流程图

3. WebSocket 流程图

4. SSE 流程图

三、 Java 详细实现示例

以下是长轮询、短轮询、WebSocket 和 SSE 在 Java 中的详细实现示例，包含必要的代码和解释：

3.1 短轮询（Short Polling）实现

客户端实现（使用 ScheduledExecutorService 定期发送 HTTP 请求）

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ShortPollingClient {

    private static final String URL = "http://localhost:8080/api/data";
    private static final HttpClient httpClient = HttpClient.newHttpClient();

    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        executor.scheduleAtFixedRate(() -> fetchData(), 0, 1, TimeUnit.SECONDS);
    }

    private static void fetchData() {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .build();

        httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenAccept(response -> System.out.println("Received data: " + response.body()))
                .exceptionally(ex -> {
                    System.err.println("Error fetching data: " + ex.getMessage());
                    return null;
                });
    }
}

服务端实现（使用 Spring Boot 创建 REST 端点）

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Random;

@RestController
public class DataController {

    private final Random random = new Random();

    @GetMapping("/api/data")
    public String getData() {
        // 模拟数据更新
        return "Data: " + random.nextInt(100);
    }
}

3.2 长轮询（Long Polling）实现

客户端实现（发送 HTTP 请求，并在收到响应后立即发送新请求）

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class LongPollingClient {

    private static final String URL = "http://localhost:8080/api/long-polling-data";
    private static final HttpClient httpClient = HttpClient.newHttpClient();

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        while (true) {
            CompletableFuture<String> future = fetchData();
            System.out.println("Received data: " + future.get());
        }
    }

    private static CompletableFuture<String> fetchData() {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .build();

        return httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body);
    }
}

服务端实现（使用 Spring Boot，在接收到请求后等待数据更新或超时，然后返回响应）

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

@RestController
public class LongPollingController {

    private final Random random = new Random();
    private String latestData = "Initial Data";

    @GetMapping("/api/long-polling-data")
    public CompletableFuture<ResponseEntity<String>> getLongPollingData() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                // 模拟等待数据更新或超时（这里设置为最多等待5秒）
                long startTime = System.currentTimeMillis();
                while (System.currentTimeMillis() - startTime < 5000) {
                    if (!latestData.equals("Initial Data")) { // 假设数据已更新
                        String dataToReturn = latestData;
                        latestData = "Initial Data"; // 重置数据
                        return ResponseEntity.ok(dataToReturn);
                    }
                    Thread.sleep(100); // 短暂休眠以减少CPU使用
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return ResponseEntity.ok(latestData); // 返回最新数据或超时后的数据
        });
    }

    // 模拟数据更新（例如，通过另一个端点）
    @GetMapping("/api/update-data")
    public String updateData() {
        latestData = "Updated Data: " + random.nextInt(100);
        return "Data updated";
    }
}

3.3 WebSocket 实现

客户端实现（使用 Java WebSocket 客户端库，如 Tyrus）

import org.glassfish.tyrus.client.ClientManager;
import javax.websocket.*;
import java.net.URI;

@ClientEndpoint
public class WebSocketClient {

    @OnOpen
    public void onOpen(Session session) {
        System.out.println("Connected to server");
    }

    @OnMessage
    public void onMessage(String message) {
        System.out.println("Received message: " + message);
    }

    @OnClose
    public void onClose(CloseReason reason) {
        System.out.println("Connection closed: " + reason);
    }

    public static void main(String[] args) {
        ClientManager client = ClientManager.createClient();
        try {
            client.connectToServer(WebSocketClient.class, new URI("ws://localhost:8080/ws"));
            Thread.sleep(Long.MAX_VALUE); // 保持连接打开
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端实现（使用 Spring Boot 的 WebSocket 支持）

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import org.springframework.web.socket.TextMessage;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyWebSocketHandler(), "/ws");
    }

    public static class MyWebSocketHandler extends TextWebSocketHandler {

        @Override
        protected void handleTextMessage(WebSocketSession session, TextMessage message) {
            // 处理客户端发送的消息（可选）
        }

        // 模拟定时向客户端发送消息
        @Override
        public void afterConnectionEstablished(WebSocketSession session) throws Exception {
            while (true) {
                Thread.sleep(1000); // 每隔1秒发送一次消息
                session.sendMessage(new TextMessage("Server message: " + System.currentTimeMillis()));
            }
        }
    }
}

3.4 SSE（Server-Sent Events）实现

客户端实现（使用 EventSource 接口接收服务器推送的事件）

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.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@RestController
public class SseController {

    private final Random random = new Random();
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    @GetMapping("/api/sse")
    public SseEmitter streamData() {
        SseEmitter emitter = new SseEmitter();
        executor.execute(() -> {
            try {
                for (int i = 0; i < 10; i++) { // 发送10条消息后关闭连接
                    String data = "Event: " + i + ", Data: " + random.nextInt(100);
                    emitter.send(SseEmitter.event().data(data));
                    Thread.sleep(1000); // 每隔1秒发送一次消息
                }
                emitter.complete();
            } catch (IOException | InterruptedException e) {
                emitter.completeWithError(e);
            }
        });
        return emitter;
    }
}

客户端实现（使用 EventSource 接口）

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.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 注意：此处的SseController同时作为服务端实现，客户端实现应使用JavaScript或其他支持SSE的客户端库。
// 以下是使用JavaScript客户端的示例：

// <script>
//     const eventSource = new EventSource('http://localhost:8080/api/sse');
//     eventSource.onmessage = function(event) {
//         console.log('Received event:', event.data);
//     };
//     eventSource.onerror = function(error) {
//         console.error('EventSource error:', error);
//     };
// </script>

四、表格对比

特性	短轮询	长轮询	WebSocket	SSE
实时性	低（依赖轮询频率）	中（等待服务器响应）	高（全双工通信）	高（服务器主动推送）
资源消耗	高（频繁请求）	中（较少的请求，但连接可能长时间保持）	低（单个持久连接）	低（基于 HTTP，连接可复用）
实现复杂度	低（简单 HTTP 请求）	中（需处理连接保持和超时）	高（需支持 WebSocket 协议）	中（需实现服务器推送逻辑）
浏览器兼容性	良好（所有浏览器支持 HTTP）	良好（现代浏览器支持）	良好（现代浏览器支持，部分需 Polyfill）	良好（现代浏览器支持，IE 需 Polyfill）
数据格式	灵活（任意格式）	灵活（任意格式）	灵活（任意格式，通常为文本或二进制）	文本（基于 EventStream 格式）
适用场景	对实时性要求不高的场景（如简单状态更新）	需要较高实时性但不想引入复杂技术的场景（如聊天室）	需要高实时性和双向通信的场景（如在线游戏、实时协作）	服务器向客户端推送单向事件的场景（如股票行情、新闻更新）

五、应用场景建议

• 短轮询：适用于对实时性要求不高的场景，如简单状态更新、天气查询等。
• 长轮询：适用于需要较高实时性但不想引入复杂技术的场景，如聊天室、在线客服等。
• WebSocket：适用于需要高实时性和双向通信的场景，如在线游戏、实时协作工具、股票交易平台等。
• SSE：适用于服务器向客户端推送单向事件的场景，如股票行情、新闻更新、系统通知等。

通过以上文字描述、mermaid 流程图和表格对比，您可以更全面地了解长轮询、短轮询、WebSocket 和 SSE 这四种实时通信技术的特点和应用场景。根据实际需求选择合适的技术，可以显著提升应用的实时性和用户体验。