【后端】Java后端主动推送消息到前端的技术方案

前言

在现代Web应用中，前端与后端之间的实时或准实时通信变得越来越重要。例如，在线聊天、实时数据更新、股票行情、消息通知、系统监控等场景，都需要后端能够在数据发生变化或特定事件触发时，主动将信息推送给前端，而不是等待前端下一次请求。本文将详细介绍几种Java后端主动向前端推送消息的常用技术方案，分析它们的原理、优缺点及适用场景。

一、常见的后端推送技术

后端主动推送消息给前端的技术选择多样，开发者应根据应用的具体需求（如实时性要求、消息频率、数据量大小、浏览器兼容性、实现复杂度等）来选择最合适的技术。

（一）WebSockets

WebSockets (RFC 6455) 提供了一个在单个TCP连接上进行全双工通信的协议。一旦建立连接，服务器和客户端都可以随时主动向对方发送数据。

工作原理：
- 客户端通过HTTP/HTTPS发起一个特殊的握手请求（包含Upgrade: websocket头部）。
- 服务器响应握手，如果同意，连接就从HTTP升级到WebSocket协议。
- 之后，双方可以通过这个持久连接自由地双向发送文本或二进制数据帧。
优点：
- 真双工通信：服务器和客户端可以同时发送和接收数据。
- 低延迟：连接建立后，数据交换不需要HTTP请求/响应的开销。
- 高效：头部开销小，数据传输效率高。
- 广泛支持：现代主流浏览器和服务器端框架都支持WebSocket。
缺点：
- 实现略复杂：相比HTTP，状态管理和连接维护更复杂。
- 代理服务器兼容性：一些旧的代理服务器可能不支持WebSocket连接的升级。
- 连接数限制：服务器需要为每个客户端维持一个持久连接，大量客户端可能导致服务器资源消耗较大。

Java实现：

**JSR 356 (Java API for WebSocket)**：Java EE 7开始引入的标准API。应用服务器如Tomcat、Jetty、WildFly等都提供了实现。

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

@ServerEndpoint("/mywebsocket")
public class MyWebSocketEndpoint {

    private static Set<Session> clients = Collections.synchronizedSet(new HashSet<>());

    @OnOpen
    public void onOpen(Session session) {
        clients.add(session);
        System.out.println("Client connected: " + session.getId());
    }

    @OnMessage
    public String onMessage(String message, Session session) {
        System.out.println("Message from " + session.getId() + ": " + message);
        // 广播消息给所有客户端
        broadcast("User " + session.getId() + " says: " + message);
        return "Message received by server: " + message; // 可以选择性地回复给发送者
    }

    @OnClose
    public void onClose(Session session, CloseReason closeReason) {
        clients.remove(session);
        System.out.println("Client disconnected: " + session.getId() + " Reason: " + closeReason.getReasonPhrase());
    }

    @OnError
    public void onError(Session session, Throwable throwable) {
        System.err.println("Error for client " + session.getId() + ": " + throwable.getMessage());
        try {
            session.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void broadcast(String message) {
        synchronized (clients) {
            for (Session client : clients) {
                if (client.isOpen()) {
                    try {
                        client.getBasicRemote().sendText(message);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

Spring Framework：提供了对WebSocket的强大支持，包括SockJS回退选项（用于不支持WebSocket的浏览器）。

// 使用Spring 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 {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MySpringWebSocketHandler(), "/springws").setAllowedOrigins("*");
    }
}

// Handler
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class MySpringWebSocketHandler extends TextWebSocketHandler {
    private static final List<WebSocketSession> sessions = new CopyOnWriteArrayList<>();

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        sessions.add(session);
        System.out.println("Spring WS Connection established: " + session.getId());
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        System.out.println("Spring WS Received message: " + message.getPayload());
        for (WebSocketSession webSocketSession : sessions) {
            if (webSocketSession.isOpen() && !session.getId().equals(webSocketSession.getId())) {
                webSocketSession.sendMessage(message);
            }
        }
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, org.springframework.web.socket.CloseStatus status) throws Exception {
        sessions.remove(session);
        System.out.println("Spring WS Connection closed: " + session.getId());
    }

    // 对外提供发送消息的静态方法或服务方法
    public static void sendMessageToAll(String message) {
        TextMessage textMessage = new TextMessage(message);
        for (WebSocketSession session : sessions) {
            if (session.isOpen()) {
                try {
                    session.sendMessage(textMessage);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Netty：高性能网络应用框架，也可以用来构建WebSocket服务器。

前端实现：

const socket = new WebSocket('ws://localhost:8080/mywebsocket'); // 或 /springws

socket.onopen = function(event) {
    console.log('WebSocket connection opened:', event);
    socket.send('Hello Server!');
};

socket.onmessage = function(event) {
    console.log('Message from server:', event.data);
    // 在页面上显示消息
    const messagesDiv = document.getElementById('messages');
    const newMessage = document.createElement('p');
    newMessage.textContent = event.data;
    messagesDiv.appendChild(newMessage);
};

socket.onclose = function(event) {
    if (event.wasClean) {
        console.log(`WebSocket connection closed cleanly, code=${event.code} reason=${event.reason}`);
    } else {
        console.error('WebSocket connection died');
    }
};

socket.onerror = function(error) {
    console.error('WebSocket Error:', error);
};

// 主动发送消息
function sendMessageToServer(message) {
    if (socket.readyState === WebSocket.OPEN) {
        socket.send(message);
    } else {
        console.log('WebSocket is not open. ReadyState: ' + socket.readyState);
    }
}

（二）Server-Sent Events (SSE)

Server-Sent Events (SSE) 是一种允许服务器单向向客户端推送更新的技术，基于HTTP持久连接。客户端通过EventSource API订阅事件。

工作原理：
- 客户端向服务器发起一个HTTP GET请求，请求头包含Accept: text/event-stream。
- 服务器保持此连接打开，并以特定格式（`data: message

）持续发送事件数据。 * 客户端的EventSource`对象会自动处理重连和消息解析。

优点：
- 简单：基于HTTP，比WebSocket简单，服务器端实现和客户端API都更轻量。
- 自动重连：EventSource API内置了断线重连机制。
- 事件类型：可以发送带有事件类型的消息，方便客户端区分处理。
- 浏览器兼容性好：（除IE/Edge旧版外）现代浏览器普遍支持。
缺点：
- 单向通信：只能服务器向客户端发送，客户端不能通过同一连接向服务器发送消息（需要发起新的HTTP请求）。
- 数据格式限制：通常是文本数据，二进制数据支持不佳。
- 连接数限制：浏览器对同一域名下的并发SSE连接数有限制（通常是6个）。

Java实现：

**Servlet 3.0+ (Asynchronous Support)**：可以利用Servlet的异步特性实现SSE。

Spring MVC：提供了SseEmitter类来方便地实现SSE。

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import java.io.IOException;
import java.time.LocalTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.List;

@Controller
public class SseController {

    // 使用线程安全的列表来存储Emitter
    private static final List<SseEmitter> emitters = new CopyOnWriteArrayList<>();
    private final ExecutorService nonBlockingService = Executors.newCachedThreadPool();

    @GetMapping("/sse-stream")
    public SseEmitter handleSse() {
        SseEmitter emitter = new SseEmitter(Long.MAX_VALUE); // 设置超时时间为无限
        emitters.add(emitter);

        // emitter完成或超时或错误时，从列表中移除
        emitter.onCompletion(() -> emitters.remove(emitter));
        emitter.onTimeout(() -> emitters.remove(emitter));
        emitter.onError(e -> emitters.remove(emitter));
        
        // 可以立即发送一条消息
        try {
            emitter.send(SseEmitter.event().name("initial").data("SSE Connection Established"));
        } catch (IOException e) {
            emitter.completeWithError(e); // 出错时主动完成并移除
        }

        return emitter;
    }

    // 外部服务调用此方法来推送消息给所有客户端
    public static void sendEventToAllClients(String eventName, Object data) {
        List<SseEmitter> deadEmitters = new ArrayList<>();
        emitters.forEach(emitter -> {
            try {
                emitter.send(SseEmitter.event().name(eventName).data(data));
            } catch (IOException e) {
                // 记录错误，并将无法发送的emitter标记为待移除
                System.err.println("Error sending SSE to client: " + e.getMessage());
                deadEmitters.add(emitter);
            }
        });
        emitters.removeAll(deadEmitters); // 移除发送失败的
    }

    // 示例：定时推送服务器时间
    // @Scheduled(fixedRate = 1000) // 需要开启Spring的调度@EnableScheduling
    public void sendPeriodicMessages() {
        sendEventToAllClients("server-time", "Server time: " + LocalTime.now().toString());
    }
}

在实际应用中，sendEventToAllClients方法会被业务逻辑中的事件触发器调用。

前端实现：

if (!!window.EventSource) {
    const eventSource = new EventSource('/sse-stream'); // SSE端点URL

    eventSource.onopen = function() {
        console.log('SSE Connection opened.');
    };

    // 监听默认消息（没有event字段的）
    eventSource.onmessage = function(event) {
        console.log('SSE Default message:', event.data);
        displayMessage(event.data);
    };

    // 监听特定事件类型的消息
    eventSource.addEventListener('server-time', function(event) {
        console.log('SSE server-time event:', event.data);
        displayMessage(`[Server Time]: ${event.data}`);
    });
    
    eventSource.addEventListener('initial', function(event) {
        console.log('SSE initial event:', event.data);
        displayMessage(`[Initial]: ${event.data}`);
    });


    eventSource.onerror = function(error) {
        console.error('SSE Error:', error);
        if (eventSource.readyState === EventSource.CLOSED) {
            console.log('SSE connection was closed.');
        }
    };

    function displayMessage(data) {
        const messagesDiv = document.getElementById('messages');
        const newMessage = document.createElement('p');
        newMessage.textContent = data;
        messagesDiv.appendChild(newMessage);
    }
} else {
    console.log("Your browser doesn't support Server-Sent Events.");
}

（三）长轮询 (Long Polling)

长轮询是传统轮询的一种改进。客户端发送一个请求到服务器，服务器会保持这个连接打开，直到有新的数据返回给客户端，或者达到一个预设的超时时间。客户端收到响应后，会立即再次发起一个新的长轮询请求。

工作原理：
- 客户端向服务器发起一个HTTP请求。
- 服务器检查是否有新数据。
  - 如果有，立即响应给客户端。
  - 如果没有，服务器挂起请求，直到有新数据或超时。
- 客户端收到响应后（数据或超时空响应），立即发起下一个长轮询请求。
优点：
- 兼容性好：基于标准HTTP，几乎所有浏览器和网络环境都支持。
- 实现相对简单：相比WebSocket，服务器端逻辑稍简单。
缺点：
- 延迟较高：消息的实时性取决于服务器处理新数据和客户端发起新请求的速度。
- 服务器资源消耗：服务器需要为每个挂起的请求维持连接和状态，虽不如WebSocket密集，但仍有开销。
- 可能产生空轮询：如果超时时间内没有新数据，会产生一次无意义的请求-响应周期。
- 消息积压问题：如果短时间内有大量消息，服务器在处理完一个请求后，下一个请求到来前可能又有新消息，导致消息传递不是严格实时的。

Java实现：

**Servlet 3.0+ (Asynchronous Support)**：利用AsyncContext可以有效地实现长轮询，避免阻塞Servlet线程。

import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@WebServlet(urlPatterns = "/long-polling", asyncSupported = true)
public class LongPollingServlet extends HttpServlet {
    private static final Queue<AsyncContext> contexts = new ConcurrentLinkedQueue<>();
    // 模拟消息队列
    private static final Queue<String> messageQueue = new ConcurrentLinkedQueue<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    @Override
    public void init() throws ServletException {
        // 模拟外部服务产生消息
        scheduler.scheduleAtFixedRate(() -> {
            String message = "New data at " + System.currentTimeMillis();
            System.out.println("Adding message to queue: " + message);
            messageQueue.offer(message);
            processWaitingClients();
        }, 5, 5, TimeUnit.SECONDS); // 每5秒产生一条消息
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        final AsyncContext asyncContext = req.startAsync(req, resp);
        asyncContext.setTimeout(30000); // 设置超时时间 30 秒
        contexts.add(asyncContext);

        asyncContext.addListener(new javax.servlet.AsyncListener() {
            @Override
            public void onComplete(javax.servlet.AsyncEvent event) throws IOException { contexts.remove(asyncContext); }
            @Override
            public void onTimeout(javax.servlet.AsyncEvent event) throws IOException {
                contexts.remove(asyncContext);
                HttpServletResponse response = (HttpServletResponse) asyncContext.getResponse();
                response.setStatus(HttpServletResponse.SC_NO_CONTENT); // 或返回特定超时信息
                asyncContext.complete();
            }
            @Override
            public void onError(javax.servlet.AsyncEvent event) throws IOException { contexts.remove(asyncContext); }
            @Override
            public void onStartAsync(javax.servlet.AsyncEvent event) throws IOException { }
        });
        
        // 尝试立即处理一次
        processWaitingClients();
    }

    private void processWaitingClients() {
        while (!messageQueue.isEmpty() && !contexts.isEmpty()) {
            String message = messageQueue.poll();
            if (message != null) {
                AsyncContext asyncContext = contexts.poll();
                if (asyncContext != null) {
                    try {
                        HttpServletResponse peerResponse = (HttpServletResponse) asyncContext.getResponse();
                        peerResponse.setContentType("application/json");
                        PrintWriter writer = peerResponse.getWriter();
                        writer.write("{"data": "" + message + ""}");
                        writer.flush();
                    } catch (IOException e) {
                        System.err.println("Error writing to client: " + e.getMessage());
                    } finally {
                        asyncContext.complete();
                    }
                }
            }
        }
    }

    @Override
    public void destroy() {
        scheduler.shutdown();
    }
}

Spring MVC：也可以使用DeferredResult或Callable来实现长轮询。

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.request.async.DeferredResult;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Controller
public class LongPollingController {
    private final Queue<DeferredResult<String>> deferredResults = new ConcurrentLinkedQueue<>();
    private final ScheduledExecutorService messageProducer = Executors.newSingleThreadScheduledExecutor();

    public LongPollingController() {
        // 模拟每5秒产生一条消息
        messageProducer.scheduleAtFixedRate(() -> {
            if (!deferredResults.isEmpty()) {
                String message = "New data from Spring: " + System.currentTimeMillis();
                DeferredResult<String> deferredResult = deferredResults.poll();
                if (deferredResult != null && !deferredResult.isSetOrExpired()) {
                    deferredResult.setResult("{"data": "" + message + ""}");
                }
            }
        }, 5, 5, TimeUnit.SECONDS);
    }

    @GetMapping("/spring-long-polling")
    @ResponseBody
    public DeferredResult<String> handleLongPolling() {
        final DeferredResult<String> deferredResult = new DeferredResult<>(30000L, "{"data": "timeout"}"); // 30秒超时
        
        deferredResults.add(deferredResult);

        deferredResult.onCompletion(() -> deferredResults.remove(deferredResult));
        deferredResult.onTimeout(() -> deferredResults.remove(deferredResult));
        
        // 如果有积压消息，可以尝试立即处理
        // processQueue();
        
        return deferredResult;
    }
}

前端实现：

function longPoll() {
    fetch('/long-polling') // 或 /spring-long-polling
        .then(response => {
            if (response.status === 200) {
                return response.json();
            } else if (response.status === 204) { // SC_NO_CONTENT for timeout
                console.log('Long polling timeout, re-polling...');
                return null;
            } else {
                throw new Error('Server error: ' + response.status);
            }
        })
        .then(data => {
            if (data && data.data) {
                console.log('Data from server:', data.data);
                displayMessage(data.data);
            }
        })
        .catch(error => {
            console.error('Long polling error:', error);
            // 等待一段时间后重试，避免服务器故障时频繁请求
            setTimeout(longPoll, 5000); 
        })
        .finally(() => {
            // 无论成功、失败还是超时，都立即发起下一次轮询 (除非是计划性延迟)
             if (document.visibilityState === 'visible') { // 仅在页面可见时轮询
                longPoll();
             } else {
                // 页面不可见时，可以增加轮询间隔或暂停
                setTimeout(longPoll, 15000); 
             }
        });
}

function displayMessage(data) {
    const messagesDiv = document.getElementById('messages');
    const newMessage = document.createElement('p');
    newMessage.textContent = data;
    messagesDiv.appendChild(newMessage);
}

// 监听页面可见性变化，以便在页面切回来时立即轮询
document.addEventListener('visibilitychange', () => {
    if (document.visibilityState === 'visible') {
        longPoll();
    }
});

// 初始启动
longPoll();

（四）Web Push Notifications

Web Push Notifications 是一种允许Web应用向用户发送通知的技术，即使用户当前没有打开该应用的标签页，甚至浏览器没有在前台运行（依赖Service Worker和浏览器/操作系统支持）。这主要用于离线通知场景。

工作原理：
- 前端应用请求用户授权接收通知。
- 如果用户授权，浏览器会向相应的推送服务（如Google的FCM、Mozilla的Push Service）注册，并获取一个唯一的PushSubscription对象。
- 前端将此PushSubscription对象发送给后端服务器保存。
- 当后端需要发送通知时，它会使用VAPID密钥对消息签名，然后通过HTTP请求将消息和PushSubscription中的端点URL发送给相应的推送服务。
- 推送服务负责将消息传递给对应的浏览器。
- 浏览器中的Service Worker在后台接收到推送事件，并使用Notification API显示通知。
优点：
- 离线通知：即使用户未激活应用，也能收到通知，非常适合重要提醒。
- 标准化：基于W3C的Push API和Notification API标准。
- 节省资源：应用不需要保持与后端的长连接。
缺点：
- 实现复杂：涉及Service Worker、VAPID密钥、与第三方推送服务交互等。
- 依赖第三方服务：消息传递依赖浏览器厂商的推送服务。
- 用户授权：必须明确获得用户授权。
- 主要用于通知，非实时数据流：更适合低频、重要的通知，而非高频数据更新。
Java实现：
- 通常需要使用第三方库来处理VAPID签名和与推送服务的交互，例如 webpush-java (nl.martijndwars)。
- 后端需要存储每个用户的PushSubscription信息。
- 后端需要一个API接口接收前端发送的PushSubscription对象。
- 后端在需要推送时，加载用户的PushSubscription，构造消息，使用VAPID私钥签名，然后向订阅中的endpoint URL发送POST请求。
- 具体的代码示例较为复杂，可以参考 vaadin.com 或 golb.hplar.ch 提供的教程（见参考资料）。

**前端实现 (Service Worker 关键部分)**：

// 在 service-worker.js 中
self.addEventListener('push', function(event) {
    console.log('[Service Worker] Push Received.');
    console.log(`[Service Worker] Push had this data: "${event.data ? event.data.text() : 'no payload'}"`);

    let title = 'Web Push Notification';
    let options = {
        body: 'Yay it works!',
        icon: 'images/icon.png', // Path to an icon image
        badge: 'images/badge.png' // Path to a badge image
    };
    if (event.data) {
        try {
            const data = event.data.json();
            title = data.title || title;
            options.body = data.body || options.body;
            if(data.icon) options.icon = data.icon;
            // 可以添加更多自定义选项，如 actions, image, vibrate 等
        } catch(e) {
            options.body = event.data.text();
        }
    }

    event.waitUntil(self.registration.showNotification(title, options));
});

self.addEventListener('notificationclick', function(event) {
    console.log('[Service Worker] Notification click Received.');
    event.notification.close();
    // 根据通知内容或标签决定点击后打开哪个URL
    event.waitUntil(
        clients.openWindow('https://example.com') // 打开特定页面
    );
});

前端页面JS需要负责注册Service Worker、请求通知权限、获取PushSubscription并发送给后端。

（五）消息队列 (Message Queues) 结合前端技术

对于更复杂的系统，后端可以将需要推送的消息发送到消息队列（如RabbitMQ, Kafka, Redis Pub/Sub）。然后，可以有多种方式将这些消息传递给前端：

MQ + WebSocket/SSE Gateway：
- 后端业务服务将消息发布到MQ。
- 一个专门的网关服务订阅MQ，并通过WebSocket或SSE将消息实时推送给已连接的前端客户端。
- 这种方式解耦了业务服务和推送服务。
MQ + 前端轮询/长轮询：
- 后端将消息写入MQ。
- 前端通过轮询或长轮询一个API接口，该接口从MQ中拉取属于该用户的消息。
- 这种方式相对简单，但实时性不如前者。
优点：
- 解耦和削峰填谷：MQ可以很好地处理高并发消息，解耦生产者和消费者。
- 可靠性：许多MQ提供消息持久化和重试机制。
- 可扩展性：业务服务和推送网关可以独立扩展。
缺点：
- 架构复杂度增加：引入了MQ作为中间件。
- 需要额外的推送机制：MQ本身不直接与前端通信，仍需WebSocket、SSE或轮询等作为桥梁。

二、如何选择？

实时聊天、多人协作、在线游戏：优先考虑 WebSockets，因其低延迟和双向通信能力。
股票行情、新闻资讯、状态更新（服务器到客户端单向）：优先考虑 **Server-Sent Events (SSE)**，实现简单，资源消耗相对较低。
需要极致兼容性、简单通知：可以考虑 长轮询，但要注意其延迟和服务器资源问题。
离线通知、重要提醒（即使用户不在线也要收到）：选择 Web Push Notifications。
复杂系统、高并发消息、需要解耦和可靠性：考虑使用 消息队列 配合WebSocket/SSE网关。

在实际项目中，也可能组合使用多种技术。例如，主要数据流用SSE，而需要用户输入的交互则通过普通的AJAX或WebSocket。

三、总结

Java后端主动推送消息给前端是构建现代交互式Web应用的关键能力。从传统的长轮询到现代的WebSocket和SSE，再到强大的Web Push和消息队列，开发者有多种选择。理解每种技术的原理、优缺点和适用场景，是做出正确技术选型的基础。在选择时，务必结合项目需求、团队熟悉度、以及对实时性、可靠性、资源消耗和开发维护成本的综合考量。

四、参考资料

MDN Web Docs: WebSocket API
MDN Web Docs: Server-Sent Events
MDN Web Docs: Push API
MDN Web Docs: Notifications API
Spring Framework Documentation: WebSocket Support
Spring Framework Documentation: Server-Sent Events with SseEmitter
Vaadin Blog: Sending web push notifications from Spring Boot
Golb.hplar.ch: Sending Web Push Notifications with Java
Baeldung: Guide to Server-Sent Events in Spring
Baeldung: Introduction to WebSockets in Java

后端

#Java #WebSocket #Server-Sent Events #SSE #Long Polling #Web Push #实时通信 #前后端交互

【后端】Java后端导出PDF文件指南上一篇

【前端】浏览器窗口中的历史导航：History对象详解下一篇