在后端给前端推送数据时，选择合适的技术方案至关重要。以下是几种常见的方案及其优雅实现方式，适用于不同的实时性和功能需求：

1. WebSocket

优雅实现方案

使用Spring Boot的注解和配置机制，可以实现清晰且模块化的WebSocket服务。

步骤：

1. 添加依赖：在pom.xml中添加WebSocket依赖：

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

2. 配置WebSocket：创建配置类来注册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;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    private final WebSocketHandler webSocketHandler;
    public WebSocketConfig(WebSocketHandler webSocketHandler) {
        this.webSocketHandler = webSocketHandler;
    }

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(webSocketHandler, "/ws").setAllowedOrigins("*");
    }
}

3. 创建处理器：使用Spring的TextWebSocketHandler来定义消息处理逻辑。

import org.springframework.stereotype.Component;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

@Component
public class WebSocketHandler extends TextWebSocketHandler {

    @Override
    public void afterConnectionEstablished(WebSocketSession session) {
        System.out.println("Connected: " + session.getId());
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        System.out.println("Received: " + message.getPayload());
        session.sendMessage(new TextMessage("Server response: " + message.getPayload()));
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
        System.out.println("Disconnected: " + session.getId());
    }
}

4. 前端实现：前端使用JavaScript连接WebSocket。

const socket = new WebSocket('ws://localhost:8080/ws');
socket.onopen = () => {
    console.log('WebSocket connection established.');
    socket.send('Hello, server!');
};

socket.onmessage = (event) => {
    console.log('Received from server:', event.data);
};

socket.onclose = () => {
    console.log('WebSocket connection closed.');
};

2. Server-Sent Events (SSE)

优雅实现方案

利用Spring Boot的SseEmitter来实现SSE，适用于单向数据流。

步骤：

1. 创建控制器：实现一个简单的SSE控制器。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

@RestController
public class SseController {
    @GetMapping("/sse")
    public SseEmitter stream() {
        SseEmitter emitter = new SseEmitter();
        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    emitter.send("Message " + i);
                    Thread.sleep(1000);
                }
                emitter.complete();
            } catch (Exception e) {
                emitter.completeWithError(e);
            }
        }).start();
        return emitter;
    }
}

2. 前端实现：使用JavaScript的EventSource对象来接收SSE。

const eventSource = new EventSource('/sse');
eventSource.onmessage = (event) => {
    console.log('Received:', event.data);
};

3. HTTP 长轮询

优雅实现方案

虽然不如WebSocket和SSE高效，但通过Spring Boot可以实现简单的长轮询。

步骤：

1. 创建控制器：实现一个简单的HTTP长轮询。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PollingController {
    @GetMapping("/poll")
    public String poll() throws InterruptedException {
        Thread.sleep(1000);  // 模拟等待
        return "Data from server";
    }
}

2. 前端实现：使用JavaScript的fetch API循环请求数据。

function poll() {
    fetch('/poll')
        .then(response => response.text())
        .then(data => {
            console.log('Received:', data);
            setTimeout(poll, 1000);
        })
        .catch(error => console.error('Error:', error));

}
poll();  // 开始轮询

总结

• WebSocket 是最适合双向实时通信的方案，适用于高频更新的应用。

• SSE 适合单向、频率较低的实时更新场景，且实现相对简单。

• HTTP长轮询 是一种在不支持WebSocket或SSE的环境下的替代方案，但效率不如前两者。

选择合适的技术方案应根据应用的具体需求和环境进行权衡。