Tagged articles
Server-Sent Events
60 articles · Page 1 of 1
This article explains three Spring mechanisms for asynchronous streaming responses—ResponseBodyEmitter for progressive data sending, SseEmitter for server-sent events with auto-reconnect, and StreamingResponseBody for large file streaming—with code examples and use cases for each.
Java backendResponseBodyEmitterSSE
0 likes · 11 min read

Ctrip Flight team replaced polling with Server-Sent Events (SSE) across Web and mobile (Native + React Native), detailing implementation layers, optimizations like pre-connection, pre-request, caching, and Brotli compression, achieving 11.8% faster multi-batch loading and enabling heterogeneous batching for API granularity conflicts.
Brotli CompressionCtripReact Native
0 likes · 15 min read

This comprehensive guide demonstrates why Server-Sent Events (SSE) is the superior choice over WebSocket for unidirectional server push scenarios like AI token streaming, covering Spring Boot integration patterns, production hardening (async thread pools, Nginx buffering, heartbeats, reconnection), and cluster deployment with Redis Pub/Sub.
AI streamingSSEServer-Sent Events
0 likes · 23 min read

This article compares SSE and WebSocket for server push, details SpringBoot integration with SseEmitter, WebFlux, and raw HttpServletResponse, provides a production-ready connection manager with heartbeat and clustering via Redis, and demonstrates AI streaming and real-time dashboard use cases.
AI streamingAsync ServletRedis Pub/Sub
0 likes · 29 min read

This article details implementing Server-Sent Events (SSE) in Spring Boot for real-time server-to-client push, covering SseEmitter endpoints, connection registry with cleanup, heartbeat, Last-Event-ID reconnection, cluster broadcasting via Redis Pub/Sub, Base64 binary transfer, and production tuning for Nginx and thread pools.
EventSourceRedis Pub/SubSSE
0 likes · 17 min read

The article analyzes real‑time communication options, showing that Server‑Sent Events (SSE) offers native reconnection, simple HTTP‑based architecture, and lower operational overhead than WebSocket, making it the cost‑effective choice for one‑way streaming such as LLM token output.
LLM streamingSSEServer-Sent Events
0 likes · 11 min read

The article compares polling, WebSocket, and Server‑Sent Events for server‑to‑client real‑time messaging, explains the advantages and drawbacks of each, and provides a complete Node.js/Express and plain‑HTML demo showing how to implement SSE as a lightweight alternative to WebSocket.
EventSourceExpressNode.js
0 likes · 14 min read

The article compares polling, WebSocket, and Server‑Sent Events for server‑to‑client push, explains why polling is inefficient, outlines the advantages and browser compatibility of WebSocket and SSE, and provides step‑by‑step Node/Express and plain‑HTML demos showing how to implement SSE in practice.
ExpressNode.jsPolling
0 likes · 12 min read

The article compares polling, WebSocket, and Server‑Sent Events (SSE) for server‑to‑client real‑time messaging, outlines each method’s drawbacks and advantages, and provides step‑by‑step demos showing how to implement SSE with a plain HTML page and a Node‑Express backend.
ExpressJavaScriptNode.js
0 likes · 16 min read

This article examines three server‑to‑client push methods—polling, WebSocket, and Server‑Sent Events (SSE)—detailing their mechanisms, browser compatibility, pros and cons, suitable scenarios, and provides step‑by‑step demos with Node.js/Express and plain HTML to help developers choose the most efficient solution for real‑time messaging.
ExpressNode.jsPolling
0 likes · 16 min read

This tutorial walks through creating a custom LocalAI Agent with a simple YAML file, invoking it via the API, and then dives into the Go source code that registers routes, handles asynchronous chat requests, and manages agent state and memory for multi‑turn, tool‑driven interactions.
AI AgentsGoLocalAI
0 likes · 7 min read

This article explains the three common server‑to‑client push techniques—polling, WebSocket and Server‑Sent Events (SSE)—detailing their principles, advantages, drawbacks, browser compatibility, key APIs, and provides a complete Node.js/Express demo with front‑end code to help developers choose the right solution for real‑time data scenarios.
ExpressNode.jsPolling
0 likes · 16 min read

The article explains how traditional Flink monitoring suffers from scattered metrics, manual root‑cause analysis, and lack of actionable advice, and introduces a cloud‑native system built on Strands Agents and Amazon Bedrock that automatically collects metrics, performs LLM‑powered analysis, generates optimization recommendations, and interacts with users via natural‑language dialogue and real‑time streaming output.
AI monitoringAmazon BedrockApache Flink
0 likes · 12 min read

This article explains Server‑Sent Events (SSE), a one‑way HTTP‑based real‑time push technology, and provides detailed server‑side PHP and client‑side JavaScript examples, required headers, message formatting rules, and typical use‑case scenarios for low‑overhead streaming.
JavaScriptReal-timeSSE
0 likes · 10 min read

This article explains the three main server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events—detailing their principles, advantages, drawbacks, browser compatibility, and appropriate use cases, and provides complete Node.js and HTML demos for implementing SSE.
BackendExpressNode.js
0 likes · 13 min read

This article explains server‑to‑client push scenarios, compares polling, WebSocket and Server‑Sent Events (SSE), details SSE APIs and browser compatibility, and provides complete front‑end and back‑end Node.js demos to help you choose the right technology for real‑time data delivery.
Node.jsPollingSSE
0 likes · 11 min read

This article compares Spring Boot 3's StreamingResponseBody and SseEmitter approaches for server‑side streaming, providing complete backend and frontend implementations, code samples, and performance considerations to help developers choose the right solution for real‑time data delivery.
Java backendServer-Sent EventsSseEmitter
0 likes · 8 min read

This article provides a comprehensive interview‑style analysis of Server‑Sent Events (SSE), covering its definition, 20‑year history, core features, data format, Java Spring Boot implementation, client‑side EventSource usage, detailed comparison with WebSocket and other polling techniques, and a decision guide for choosing the right real‑time communication protocol in modern AI‑driven applications.
AIJavaReal-time
0 likes · 47 min read

This article explains SSE streaming for LLM outputs by analyzing DeepSeek's network packets, demonstrates production-grade SSE client and server code using Go's Hertz framework, and evaluates SSE versus gRPC for internal service-to-service streaming RPC.
CloudWeGoDeepSeekGo
0 likes · 13 min read

This article demonstrates how to create a complete real‑time message broadcasting system using Spring Boot 3's reactive Server‑Sent Events (SSE) and WebFlux, covering the core Sink component, backend implementation, and a simple front‑end page to display live updates.
JavaServer-Sent EventsSinks
0 likes · 9 min read

This article explains how backpressure works in Spring WebFlux, outlines the built‑in Reactor strategies, provides practical code examples for handling slow consumers, and offers guidance on choosing and monitoring the right approach to keep reactive applications resilient under load.
JavaReactorServer-Sent Events
0 likes · 14 min read

This article explains how traditional synchronous JSON responses differ from modern streaming responses, introduces reactive programming concepts, and shows step‑by‑step how to implement non‑blocking, high‑throughput APIs using Spring WebFlux, Mono/Flux, SSE, WebSocket, and related protocols.
JavaReactive ProgrammingServer-Sent Events
0 likes · 10 min read

While WebSocket is often the go‑to solution for real‑time web apps, many scenarios only need one‑way data pushes; this article explains how Server‑Sent Events (SSE) provide a lightweight, HTTP‑based alternative with simpler implementation, lower overhead, and built‑in reconnection support.
SSEServer-Sent EventsWebSocket
0 likes · 7 min read

Server‑Sent Events (SSE) offer a lightweight, HTTP‑native solution for real‑time, one‑way streaming, making them ideal for AI chat applications that need a typewriter‑style response, with advantages over WebSockets such as easy implementation, automatic reconnection, broad compatibility, and simple debugging.
JavaScriptPythonSSE
0 likes · 13 min read

Server‑Sent Events (SSE) provide a simple, one‑way server push mechanism over HTTP, ideal for real‑time updates such as dashboards, notifications, and data streams; this guide explains SSE fundamentals, compares alternatives, and walks through integrating SSE into FastAPI using the sse‑starlette library with full code examples.
FastAPIPythonReal-time Updates
0 likes · 9 min read

This article explains the scenarios where servers need to push data to clients, compares three implementation methods—polling, WebSocket, and SSE—highlights their advantages and drawbacks, and provides step‑by‑step frontend and Node.js backend demos for building a real‑time SSE connection.
ExpressJavaScriptNode.js
0 likes · 13 min read

This tutorial walks through creating a weather‑focused MCP server with the Model Context Protocol TypeScript SDK, explaining Server‑Sent Events, setting up the Node.js environment, writing the TypeScript code, building, running, and testing the HTTP SSE service end‑to‑end.
ExpressHTTP SSEMCP
0 likes · 16 min read

This article presents Ctrip's enterprise-grade Server-Sent Events (SSE) solution for its flight booking frontend, detailing the technology overview, use cases, implementation practices, performance considerations, comparison with alternatives, and full‑stack integration across link, framework, and data layers.
EventSourceNode.jsReal-time
0 likes · 16 min read

This article walks through Amap's Model Context Protocol (MCP) service, explaining its purpose, installation steps, configuration in the Cursor client, and practical examples such as travel planning and location‑based queries, while also evaluating its strengths and current limitations.
AI IntegrationAmapCursor
0 likes · 8 min read

Learn how to implement efficient real-time log streaming in Spring Boot using ResponseBodyEmitter, covering its purpose, core methods, usage scenarios, step-by-step controller code, connection lifecycle management, comparison with SSE and Streaming, and important considerations for client support, timeouts, and thread safety.
HTTP Chunked TransferJavaResponseBodyEmitter
0 likes · 11 min read

This article explains the use cases and implementation of Server‑Sent Events (SSE), compares it with polling and WebSocket, details its API and browser compatibility, and provides complete front‑end and Node‑Express back‑end demo code for building a real‑time push service.
ExpressNode.jsPolling
0 likes · 15 min read

This article explains server‑push scenarios such as real‑time dashboards and chat, compares three implementation methods—polling, WebSocket, and SSE—details the advantages and drawbacks of each, and provides step‑by‑step Node.js and frontend demos for using SSE in web applications.
BackendExpressNode.js
0 likes · 14 min read

This article explains Server‑Sent Events (SSE), compares it with polling and WebSocket, outlines its advantages and limitations, provides API usage examples, and offers a complete Node.js/Express demo with front‑end code to illustrate real‑time one‑way data push.
ExpressNode.jsPolling
0 likes · 9 min read

This article explains how to integrate Gitee's Model Control Protocol (MCP) with Java using LangChain4j, covering download, Maven setup, configuration, both stdio and SSE transport modes, sample code, output examples, and a comparison of the two modes to create an AI‑powered repository assistant.
AI assistantGiteeLangChain4j
0 likes · 11 min read

Server-Sent Events (SSE) provide a lightweight, HTTP‑based one‑way real‑time communication method, ideal for scenarios like financial data, social feeds, and log monitoring; the article explains its principles, advantages, message format, compares it with WebSockets, and offers complete Go server and JavaScript client code examples with deployment tips.
GoReal-timeSSE
0 likes · 10 min read

This article compares Server‑Sent Events, WebSocket, and traditional polling, explains why SSE can replace heavyweight WebSocket in one‑way push scenarios, provides configuration and code examples for Spring Boot, and shares practical lessons from real project experiences.
PollingSSEServer-Sent Events
0 likes · 12 min read

This article introduces Spring's SseEmitter for server‑sent events, outlines its key features and use cases, and provides a complete end‑to‑end example—including Vue 3 front‑end setup, JavaScript client, and Spring Boot controller code—to enable real‑time message pushing between server and browser.
Server-Sent EventsSpring BootSseEmitter
0 likes · 8 min read

This article compares Server‑Sent Events, WebSocket, and traditional polling, explains why SSE is often a simpler and more efficient choice for one‑way real‑time communication, and provides a complete Spring Boot example with code snippets for publishing online‑user statistics.
SSEServer-Sent EventsSpringBoot
0 likes · 8 min read


ITPUBDec 6, 2024 · Backend Development
This article explains why ChatGPT adopts Server-Sent Events for streaming responses, compares SSE with WebSocket, outlines SSE's core principles and best‑practice considerations, and provides a complete Spring Boot example—including server‑side Java code and client‑side HTML—to demonstrate real‑time data push.
JavaSSEServer-Sent Events
0 likes · 14 min read

This guide explains the concept of stream output, its advantages and typical scenarios, then provides step‑by‑step implementations of Server‑Sent Events and HTTP chunk streaming using the Webman framework, including PHP process code, configuration, startup commands, and front‑end testing.
HTTP ChunkPHPSSE
0 likes · 9 min read


phodalOct 20, 2024 · Backend Development
The article proposes a Streaming Backend‑for‑Frontend (BFF) layer to unify heterogeneous AI agents, handle Server‑Sent Events streams, and resolve interface inconsistencies, offering a practical architecture for generative‑AI‑native systems across IDEs, DevOps, and team‑AI scenarios.
AI ArchitectureAPI DesignAgent Integration
0 likes · 13 min read

This article explains the three common server‑to‑client push methods—polling, WebSocket, and Server‑Sent Events (SSE)—detailing their principles, advantages, drawbacks, browser compatibility, and provides step‑by‑step demo code for both frontend and Node.js backend implementation.
ExpressNode.jsPolling
0 likes · 14 min read

This article explains how Server‑Sent Events (SSE) and the EventSource API enable real‑time, one‑way data streams in web pages, covering browser support, key features, client‑side usage, server implementation, data formatting rules, and practical tips for reliable deployment.
EventSourceReal-timeSSE
0 likes · 10 min read


JavaEdgeJun 8, 2024 · Frontend Development
This article explains the technical differences between Server‑Sent Events (EventSource) and WebSocket, compares their advantages, disadvantages, and suitable scenarios, and shows why ChatGPT’s streaming API prefers EventSource for server‑push communication.
ChatGPTEventSourceServer-Sent Events
0 likes · 9 min read

This article walks through six practical web‑push techniques—including short polling, long polling, iframe streaming, Server‑Sent Events, MQTT, and WebSocket—explaining their principles, trade‑offs, and providing complete Spring Boot and JavaScript code samples to help developers implement real‑time notification badges.
JavaLong PollingServer-Sent Events
0 likes · 18 min read

This article explains the three common server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events—detailing their principles, advantages, drawbacks, appropriate use‑cases, and provides complete front‑end and Node‑Express back‑end demo code to help developers choose and implement the right solution.
ExpressNode.jsPolling
0 likes · 12 min read

This article explains the Server‑Sent Events (SSE) technology behind ChatGPT's streaming responses, compares SSE with WebSocket, outlines its core implementation steps, and provides a complete Spring Boot example for pushing live stock prices to browsers.
BackendReal-timeSSE
0 likes · 13 min read

This article explains how Server‑Sent Events (SSE) enable real‑time, character‑by‑character responses like those seen in ChatGPT, compares SSE with WebSockets, and provides complete server‑side and client‑side code examples for implementing SSE in web applications.
EventSourceSSEServer-Sent Events
0 likes · 17 min read

This guide explains what Server‑Sent Events (SSE) are, why they are needed for real‑time server‑to‑client communication, presents complete PHP and JavaScript examples, compares three implementation patterns, and contrasts SSE with WebSocket, highlighting strengths and limitations.
JavaScriptPHPReal-time
0 likes · 12 min read

This article compares Server‑Sent Events, WebSocket, and long‑polling for real‑time data push in Spring Boot, explains their communication models, performance trade‑offs, and provides complete server‑side and client‑side code examples for implementing SSE and custom event types.
SSEServer-Sent EventsSpring Boot
0 likes · 10 min read

This tutorial explains the concept of Server‑Sent Events, compares it with WebSocket, and provides a step‑by‑step guide to create an SSE endpoint in a NestJS backend, enable CORS, and consume the stream from a React frontend using the native EventSource API.
NestJSReal-timeSSE
0 likes · 7 min read

This roundup explores cutting‑edge front‑end topics—from using Server‑Sent Events instead of WebSocket and the innovative Rome toolchain, to Git rebase strategies, the status of wangEditor, precise page‑dwell measurement, and the merits of micro‑frontends—while also debunking AI‑related programmer anxiety.
AIGitMicro Frontends
0 likes · 5 min read

The article shows how to automate low‑code visual‑form creation by using AI to parse a one‑sentence requirement, split the task into summarizing components and few‑shot prompting, generate a JSON‑Schema DSL, and ensure smooth real‑time delivery via SSE and proper proxy configuration.
AIDSLJSON Schema
0 likes · 11 min read

This article explains how to use Server‑Sent Events (SSE) and the EventSource API to stream ChatGPT responses in real time, covering both browser‑side JavaScript examples and Node.js backend proxy code, along with configuration tips for Nginx and compatibility notes.
ChatGPTEventSourceNode.js
0 likes · 12 min read

Explore how long polling and Server‑Sent Events enable real‑time data exchange in front‑end development, comparing their principles, advantages, drawbacks, and providing practical JavaScript examples to help you choose the optimal technique for your application.
Frontend DevelopmentJavaScriptLong Polling
0 likes · 5 min read

This article compares three real‑time communication techniques—long/short polling, WebSockets, and Server‑Sent Events—by explaining their mechanisms, presenting client‑ and server‑side code examples, and discussing their advantages, drawbacks, and suitable use‑cases to help developers select the appropriate method for a dashboard application.
BackendPollingReal-time
0 likes · 12 min read

The article explains how Server‑Sent Events (SSE) provide a lightweight, one‑way server‑to‑client push mechanism that avoids the complexity of WebSocket or polling, shows its protocol details, compares it with WebSocket, and demonstrates integration with Spring MVC and the browser EventSource API.
EventSourceSSEServer-Sent Events
0 likes · 6 min read

This article compares common web push techniques—including short polling, long polling, iframe streaming, WebSocket, and Server‑Sent Events—examining their principles, advantages, and drawbacks, and presents a practical selection and implementation case for real‑time order notifications in a client‑server application.
Long PollingServer-Sent EventsWebSocket
0 likes · 10 min read

This article explores five event‑driven API architectures—WebSockets, WebHooks, REST Hooks, Pub‑Sub, and Server‑Sent Events—detailing their core functions, usage patterns, and pros and cons, while highlighting how they enable asynchronous communication and resource efficiency in modern web systems.
APIServer-Sent EventsWebhooks
0 likes · 2 min read

Server-Sent Events (SSE) provide a lightweight, HTTP‑based mechanism for real‑time server push, and this article explains its principles, compatibility, and step‑by‑step implementation—including a simple server that streams timestamps every second and a front‑end page that displays the incoming data.
Frontend DevelopmentHTTPReal-time
0 likes · 3 min read
