This article details a step‑by‑step investigation of a Netty off‑heap memory leak that caused Nginx 5xx errors, covering background, alert analysis, multiple debugging stages, reflective monitoring, the root‑cause NPE fix, and verification in both local and production environments.
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.
This article explains Socket.IO’s low‑latency, bi‑directional, event‑driven communication model, outlines version differences, lists server and client language implementations, clarifies common misconceptions, details core features such as fallback, reconnection and broadcasting, and provides a complete PHP server‑client example with custom events and workerStart handling.
This article outlines the design and implementation of a unified WebSocket communication service, covering background motivations, project goals, core architecture, message reliability mechanisms using RabbitMQ, message classification, API specifications, and unified message formats to enable efficient, decoupled real‑time messaging across backend applications.
This article analyzes the challenges of real-time, reliability, and message ordering in a customer service instant messaging system and presents solutions such as WebSocket adoption, ACK-based reliability, heartbeat mechanisms, and a structured message protocol to ensure efficient and stable communication.
This article explains the three common server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events—detailing their advantages, drawbacks, suitable business scenarios, and provides step‑by‑step demo code for both frontend and Node.js backend implementations.
This article outlines the design of an internal WebSocket communication service that abstracts real‑time messaging, reduces code coupling, supports various business scenarios, ensures reliable delivery with RabbitMQ, defines unified APIs and message formats, and demonstrates a DDD‑based project structure for easy integration.
This article details the design, architecture, and Java implementation of a WebSocket‑based backend that enables real‑time, multi‑player quiz battles, covering entity definitions, message handling, matchmaking logic, error handling, game flow, and supporting utilities such as Redis‑based state management.
This article walks through the author's practical research on integrating WebSocket in Spring Boot, detailing step‑by‑step configurations for Javax, WebMVC, and WebFlux, comparing their APIs, highlighting pitfalls, and providing concrete code snippets and cold‑knowledge tips for both server and client implementations.
This article describes the background, objectives, core design, reliability mechanisms, message classification, API design, and unified calling approach of a company‑wide WebSocket abstraction layer that replaces polling, supports asynchronous communication, and ensures reliable message delivery using RabbitMQ and confirm mechanisms.
This tutorial explains the STOMP protocol, its frame structure, and how Spring Boot 3 integrates STOMP over WebSocket, providing step‑by‑step code examples for enabling STOMP, sending and receiving messages, handling headers, asynchronous processing, exception handling, and simple publish‑subscribe without a controller.
This article presents a comprehensive design of a unified WebSocket communication service that abstracts messaging, improves reliability with RabbitMQ, replaces polling with push, and provides standardized APIs and message formats for backend developers to quickly integrate real‑time features.
This article walks through creating a distributed instant‑messaging system in Go, covering the full tech stack, Docker‑based and local startup methods, configuration files, the end‑to‑end request flow, and detailed code examples for RPC, Redis queues, WebSocket delivery and the internal bucket architecture.
This tutorial walks through installing FastAPI and related packages, creating a basic FastAPI app, adding chat, PDF, and text endpoints, integrating LangChain tools for AI responses, implementing a WebSocket echo service, and running the server with uvicorn, all illustrated with code snippets and screenshots.
This article explains how WebSocket upgrades work over HTTP, shows the ws/wss URI formats, details the handshake process, and provides step‑by‑step Nginx configurations—including proxy settings and troubleshooting tips—to reliably run secure WebSocket connections behind a reverse proxy.
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.
This article explains the three main server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events—detailing their advantages, drawbacks, browser compatibility, and provides step‑by‑step Node.js and front‑end demos for implementing SSE in real‑time applications.
This guide explains how to enable MQTT support in RabbitMQ, use MQTTBox and MQTT.js for instant messaging, and integrate MQTT into a SpringBoot application, providing step‑by‑step commands, code snippets, and configuration details for both front‑end and back‑end developers.
By migrating the CatEar FM live‑streaming app’s WebSocket layer to Chromium’s Cronet network stack, the team unified cross‑platform code, added customizable DNS and proxy support, and cut handshake latency by roughly 150 ms on Android and 250 ms on iOS, paving the way for future HTTP/2 and HTTP/3‑based WebSocket transports.
This article explains how to build a WebSocket client that supports automatic reconnection after network loss and periodic heartbeat messages, provides a drop‑in API compatible with the native WebSocket interface, and includes complete TypeScript and JavaScript implementations with detailed code examples.
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.
This article explains what Nginx, WebSocket, and noVNC are, describes how to set up Nginx as a WebSocket reverse proxy, and provides a step‑by‑step Linux configuration example—including firewall disabling, Nginx installation, configuration editing, and client testing—to enable remote VNC access through a browser.
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.
This tutorial explains what Nginx, WebSocket, and noVNC are, then shows how to configure Nginx as a reverse proxy for WebSocket traffic, including detailed code snippets and a complete example of proxying a noVNC service across multiple virtual machines.
This article reviews common real‑time message push techniques—including short and long polling, Server‑Sent Events, WebSocket, Netty, and MQTT—explaining their implementation ideas, core code snippets, advantages, and drawbacks so you can choose the most suitable solution for your business scenario.
This article explains the three common server‑to‑client data push methods—polling, WebSocket, and SSE—detailing their principles, advantages, disadvantages, suitable business scenarios, and provides step‑by‑step Node.js/Express and plain JavaScript demos for implementing SSE.
WebSocket enables true full‑duplex communication between browsers and servers, overcoming the limitations of HTTP’s request‑response model; the article explains why simple HTTP polling and long polling are insufficient, details the WebSocket handshake, frame format, and ideal scenarios such as web games and real‑time chat.
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, appropriate use‑cases, and provides a complete Node.js/Express demo with front‑end code.
This article explains the challenges of using WebSocket in a microservice environment, introduces a load‑balancing library that forwards messages between service instances, shows how to enable it with Spring annotations, and details the underlying connection, subscription, and selector mechanisms for reliable message routing.
This article demonstrates how to create a reusable WebSocket manager in JavaScript that handles connection creation, automatic heartbeat, message sending, reconnection attempts, and graceful closure, providing a complete front‑end solution for real‑time communication without relying on polling.
This article provides an in‑depth overview of WebSocket, covering its definition, advantages and disadvantages, protocol details, connection lifecycle, message format, JavaScript and Java APIs, Spring Boot integration, performance considerations, and future development directions.
This article details the design and implementation of a road‑testing platform that improves navigation accuracy by integrating data collection, real‑time video streaming, WebSocket communication, and automated reporting, resulting in faster issue detection, reduced manual effort, and measurable efficiency gains across multiple cities.
This article explains why the browser‑based ChatGPT conversation system prefers the lightweight EventSource API over WebSocket, detailing protocol differences, system characteristics, advantages, code implementations, performance considerations, and future extension possibilities.
This tutorial explains how to build a real‑time video chat application using PHP with the Swoole WebSocket extension and WebRTC, covering environment setup, server and client code, and steps to run the system.
This article explains how Ctrip's security R&D team built a web‑based LLM chatbot with version‑2.0 features such as plugin support, function calling, synchronous and asynchronous execution, WebSocket/Socket.IO communication, and provides full Python code examples for defining and invoking plugins.
This article walks through the full design of a billion‑user group chat system, covering functional and non‑functional requirements, core components such as WebSocket and Redis, face‑to‑face group creation, message flow, database schema, and performance‑oriented scaling techniques.
Learn what Pusher is, compare it with raw WebSocket, and follow a detailed walkthrough that shows how to set up a Pusher account, configure a channel, and implement both client‑side JavaScript and server‑side PHP code to publish and receive real‑time events.
This article walks through the design of a billion‑user group chat platform, covering functional and non‑functional requirements, core components, database schema, face‑to‑face group creation, message flow, storage strategies, and performance‑optimizing techniques such as clustering, message queues, multithreading, and Redis caching.
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.
This guide explains how to install the websocketd daemon, configure it to run shell scripts as WebSocket back‑ends, create simple HTML clients, monitor system memory in real time, and fine‑tune parameters such as static file serving, developer console, SSL, and Nginx proxying.
This article explains how to set up WebSocket communication in Spring Boot 2.7.12, covering the protocol basics, handshake process, custom HandlerMapping, annotation-driven routing, and a reactive WebFlux handler with code examples, plus deployment considerations behind reverse proxies.
This article explains why heartbeat detection is crucial for WebSocket connections, describes the underlying Ping/Pong mechanism, details server and client configuration parameters, and provides complete code examples for implementing reliable heartbeat and reconnection logic.
This guide explains how to implement server‑side WebSocket message persistence using MySQL, covering requirement analysis, database schema design, Think‑ORM integration, event handling code, testing scripts, and performance considerations for high‑concurrency scenarios.
This article explains various web message‑push techniques—including short and long polling, iframe streaming, Server‑Sent Events, MQTT, and WebSocket—provides detailed Java and JavaScript code samples, compares their trade‑offs, and shows how to integrate them in a Spring Boot application.
This guide explains how to design group and private chat messages, define a unified JSON protocol, validate payloads with a custom validator, and implement WebSocket callbacks (onWorkerStart, onWebSocketConnect, onMessage, onClose) using PHP and JavaScript client examples for both one‑to‑one and group conversations.
This tutorial explains how to set up a real‑time chat application by installing the Ratchet library with Composer, creating a PHP WebSocket server, launching it, and building a simple HTML/JavaScript client that connects to ws://localhost:8080 to exchange messages instantly.
This article demonstrates how to build a real-time equipment monitoring solution by using WebSocket for server‑client communication, a Vue.js front‑end to display device status on a map, and a SpringBoot back‑end that broadcasts abnormal alerts to connected browsers.
This article explains why WebSocket security matters, outlines authentication and authorization gaps, describes the Cross‑Site WebSocket Hijacking (CSWSH) attack, and provides practical PHP code for origin validation and signature‑based authentication to protect high‑concurrency WebSocket services.
This guide outlines a unified JSON response structure, defines standard HTTP status codes, presents common data payload formats, provides reusable PHP functions for broadcasting messages, and demonstrates custom error handling within a WebSocket gateway to improve backend consistency and robustness.
This guide explains WebSocket fundamentals, shows the HTTP handshake process, provides JavaScript client examples, and walks through a full server‑side implementation using the high‑performance PHP Webman framework with the GatewayWorker plugin, including installation, configuration, and advanced message handling.
This article demonstrates how to build a real‑time equipment monitoring application by using WebSocket for server‑client communication, a Vue.js front‑end to display device status, and a SpringBoot back‑end that broadcasts alerts when abnormal devices are reported.
This article describes how an enterprise leveraged GPT‑3.5 and other large language models to create a private knowledge base, design prompt engineering, implement plugin extensions, and build a secure, scalable backend and front‑end integration platform that enables AI‑driven customer‑service assistants across multiple business lines.
This tutorial explains the Ratchet PHP library for asynchronous WebSocket services, describes the WebSocket protocol and handshake process, and provides complete server‑side and client‑side code examples with installation steps to create a functional real‑time communication demo.
This article presents advanced Next.js techniques—including dynamic imports, CDN asset publishing, server‑side caching, Incremental Static Regeneration, and custom server integration for WebSockets—to help developers build faster, more scalable, and performance‑optimized web applications.
This article demonstrates how to build a real‑time device monitoring system by using WebSocket for server‑client communication, Vue for the front‑end display, and SpringBoot for the back‑end service, covering code examples, configuration, and testing steps.
This article demonstrates how to build a real‑time equipment‑monitoring solution by using WebSocket for server‑to‑client push, with a SpringBoot backend that handles WebSocket connections and a Vue.js front‑end that visualizes device status and updates instantly when an abnormal event is reported.
This tutorial explains how to build a real‑time fire‑equipment monitoring application where a Vue.js front‑end receives abnormal event notifications via WebSocket from a SpringBoot back‑end that broadcasts device status changes instantly.
This article explains how to construct and send Ethereum JSON‑RPC calls such as net_version through a WebSocket connection using the Web3j Java library, including source code analysis, request construction, and a practical example with console output.
This article reviews common API service implementation models—gRPC, GraphQL, REST, WebSocket—and introduces WebHook as a passive real‑time communication mechanism, explaining their key characteristics and typical use cases in modern distributed systems.
This article walks through multiple ways to add real‑time in‑site notifications—such as the familiar red‑dot badge—to a web application, covering short and long polling, iframe streaming, Server‑Sent Events, MQTT and WebSocket, with complete Spring Boot code examples and client‑side snippets.
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.
This article provides a concise visual guide to eight popular network protocols—including HTTP, HTTP/3, HTTPS, WebSocket, TCP, UDP, SMTP, and FTP—explaining their core functions, typical use cases, and how they enable reliable data exchange across the Internet.
This article compares Java-WebSocket and Netty-WebSocket implementations by examining their thread models, running single‑connection and high‑connection benchmarks (including a Go WebSocket server), and summarizing the performance and resource‑usage differences observed.
This article provides a comprehensive guide on implementing WebSocket in Spring Boot, covering three native approaches (Javax, WebMVC, WebFlux) with server‑ and client‑side configurations, and briefly introducing four third‑party libraries (Java‑WebSocket, SocketIO, Netty) for advanced use cases.
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.
This article presents a concise animated overview of six widely used API patterns—gRPC, SOAP, GraphQL, WebHook, REST, and WebSocket—explaining their core concepts, typical use cases, and relevance in modern software development, and points to short video tutorials for deeper understanding.
This article explains WebSocket fundamentals, including its definition, handshake process, data frame structure, binary handling, stream usage, networking details like MTU/MSS, and practical Node.js examples, providing a comprehensive guide for real‑time web communication.
This article explains how to solve the WebSocket message delivery problem in microservice architectures by using a lightweight library that provides an @EnableWebSocketLoadBalanceConcept annotation, detailing its design, connection management, message routing, and customizable selectors for targeted delivery.
This article introduces a Spring‑Boot library that solves WebSocket message loss in microservice architectures by enabling automatic inter‑instance load balancing, configurable annotations, connection management, custom selectors for targeted messaging, and includes code examples, design diagrams, and promotional information for related community resources.
This article provides a comprehensive guide to implementing WebSocket in Spring Boot, covering server and client configurations for Javax, WebMVC, and WebFlux, along with code examples, deployment tips, and insights into alternative libraries such as Java-WebSocket, SocketIO, and Netty.
This article provides a comprehensive guide on implementing WebSocket in Spring Boot, covering the Javax API, Spring WebMVC and WebFlux configurations, client and server setups, message handling, handshake interceptors, and a brief overview of popular third‑party libraries such as Java‑WebSocket, SocketIO and Netty.
This article introduces a Spring‑Boot library that uses a single annotation to enable WebSocket (and other long‑connection) load balancing across multiple microservice instances, explains its abstract connection model, shows how to configure and use it with code examples, and describes the underlying connection management, selector, and message routing mechanisms.
This article explains how to replace thread‑heavy WebSocket or Socket.IO clients with a Netty‑based Java WebSocket client, covering Maven dependencies, connection setup, event‑loop management, message sending, and a custom channel handler for high‑concurrency scenarios.
This tutorial demonstrates how to bypass complex, layered encryption on a target website by using Sekiro RPC to invoke browser methods directly, covering analysis of the encrypted sign parameter, setting conditional breakpoints, overriding JavaScript files, defining a Sekiro client, and retrieving the signature via Python.
Learn how to build a QR‑code login system using Spring Boot and WebSocket, covering database design, role analysis, API creation, front‑end integration, and full Java code examples for generating QR images, handling socket communication, and validating tokens with expiration logic.
This article explains various web message‑push techniques—including short polling, long polling, iframe streaming, Server‑Sent Events, MQTT, and WebSocket—detailing their principles, advantages, and step‑by‑step Spring Boot and JavaScript implementations with complete code examples.
This guide demonstrates how to set up a Spring Boot 2.4.12 WebSocket server with custom message types, encoders, decoders, endpoint configuration, and a minimal HTML client, including complete Java code snippets and testing screenshots.
An in‑depth Spring Boot 3 tutorial explains WebSocket fundamentals, the HTTP upgrade handshake, core Spring APIs, configuration options, origin handling, and testing steps, enabling developers to build real‑time, bidirectional communication services for web applications.
This article explains how to enable cross‑node WebSocket communication in a distributed Spring application by publishing messages to a Redis or Kafka topic, tracking user connections, and routing messages to the appropriate server instance, complete with full code examples and configuration details.
This guide walks through designing a User_Token table, defining roles and APIs, implementing QR‑code generation and validation endpoints, and wiring a Spring Boot WebSocket server with front‑end AJAX to achieve secure, real‑time QR‑code login for Android, web and PC clients.
This tutorial explains how to build a real-time data visualization feature by setting up a PHP WebSocket server with Ratchet and displaying live data on the client side using Highcharts, covering environment setup, server and client code, and deployment considerations.
The article compares EventSource and WebSocket, outlining their respective advantages, disadvantages, and appropriate use cases for server‑push versus bidirectional real‑time communication in web applications such as the ChatGPT interface.
This tutorial explains how to create a basic real-time chat application by combining PHP backend logic, MySQL storage, AJAX polling, and WebSocket communication to enable instant message exchange in web browsers.
The guide walks through building a real‑time instant‑messaging system—using a multiplayer monster‑battle demo—to compare polling, long‑polling, SSE and WebSocket, explains the WebSocket handshake and frame format, shows a custom Node.js server implementation, and advises adopting mature IM SDKs for production.
This article introduces a Spring Boot library that uses a configuration annotation to enable WebSocket load balancing across microservice instances, explains its abstract design, connection management, message routing, and provides usage examples with code snippets while also mentioning related promotional content.
This article introduces a Spring‑Boot library that uses a configuration annotation to enable WebSocket load‑balancing across microservice instances, detailing its usage, abstract design, connection management, message routing, and extensibility for various long‑connection protocols.
This article explains how to solve the problem of message loss in WebSocket communication within a micro‑service architecture by introducing a library that uses a single configuration annotation to automatically establish inter‑instance connections, manage message routing, and support custom selectors for targeted delivery.
This guide introduces Swoole, a high‑performance asynchronous PHP framework for IoT, and walks through installing the extension, building TCP and WebSocket servers, performing asynchronous file I/O, and leveraging coroutines with complete code examples.
This article shares the team’s practical experience and solutions for embedding H5 pages in mini‑program WebViews, covering platform differences, communication mechanisms, onShow handling, common pitfalls, login‑state synchronization, payment integration, and the use of WebSocket to achieve real‑time cross‑page updates.
This article explains how to solve the WebSocket message‑delivery problem in a micro‑service environment by introducing a lightweight library that uses a custom annotation to automatically forward messages between service instances, with detailed design, configuration, and code examples.
This article explains the challenges of using WebSocket in a micro‑service environment, introduces a load‑balancing library with annotation‑based configuration, and details its abstract design, connection management, message routing, and selector mechanisms for targeted and broadcast communication.
This guide explains how a web front‑end can communicate with IC cards and RFID tags by launching a local WebSocket service, using a desktop plug‑in to handle hardware read/write operations, and integrating the data with the server for vehicle and driver management.
This article introduces Javalin, a lightweight Java web framework that supports HTTP/2, WebSocket, and asynchronous requests, demonstrates a practical code example with routing, request validation, handlers, and deployment steps, and even solves a common port‑conflict issue on macOS.
Javalin is a lightweight Java web framework that supports WebSocket, HTTP/2, and asynchronous requests, offering simple configuration, route definitions, parameter validation, handlers, access management, and easy deployment via an embedded Jetty server, with examples and troubleshooting tips for common issues like port conflicts.
This article introduces the open‑source chatGPT-service backend and chatGPT-stream frontend, explains their WebSocket integration, provides Gitee mirrors, and offers step‑by‑step commands for cloning, configuring, Docker deployment, compilation, and testing the real‑time ChatGPT application.
This article compares short polling, long polling, WebSocket, and Server‑Sent Events, explaining their mechanisms, advantages, drawbacks, and appropriate use cases, and provides practical code examples for implementing each method in modern frontend development.
This article details the design, bandwidth optimization, and reliability strategies of a custom bullet‑chat system for Southeast Asian live streaming, covering background challenges, problem analysis, compression, request throttling, long‑polling versus WebSocket trade‑offs, and a short‑polling solution that successfully supported 700 k concurrent users.
This article describes the design, challenges, and optimization strategies of a custom live‑streaming danmaku system for Southeast Asian markets, covering bandwidth constraints, latency issues, long‑polling versus WebSocket approaches, service splitting, caching, and a ring‑buffer implementation that supported 700 k concurrent users during a major sales event.
This guide demonstrates how to use Java 11’s HttpClient to build a WebSocket client, implement a listener for various message events, and send both text and binary data, including a complete runnable example that showcases connection setup, message handling, and periodic sending.
This article presents a detailed case study of designing a high‑throughput danmu (bullet‑screen) system for Southeast Asian live streaming, analyzing bandwidth constraints, latency issues, and evaluating long‑polling, WebSocket, and short‑polling approaches, ultimately describing the chosen short‑polling solution, service partitioning, caching, and ring‑buffer techniques to achieve stable performance for millions of concurrent users.
