This article presents a complete Gomoku web application built with Vue 3 on the front end and NestJS on the back end, featuring customizable pieces, stylish UI, AI opponents of varying difficulty, and real‑time LAN multiplayer using Socket.io, along with detailed code examples and architectural explanations.
Learn how WebSocket enables low‑latency, full‑duplex communication for real‑time applications, and follow a detailed PHP tutorial using the Ratchet library to set up, run, and enhance a WebSocket server with authentication, scaling, and secure WSS support.
This article explains the three common server‑to‑client push techniques—polling, WebSocket, and SSE—detailing their principles, advantages, and drawbacks, then provides a step‑by‑step Node/Express and plain‑HTML demo showing how to create and use an SSE connection.
This guide explains how to implement reliable scheduled tasks in Chrome extensions under Manifest V3, covering the shift from persistent background scripts to service workers, three practical approaches—including chrome.alarms, content script timers, and event‑driven simulations—plus best‑practice tips for idempotency, logging, and state persistence.
This article explains the three common server‑to‑client push techniques—polling, WebSocket, and SSE—detailing their principles, pros and cons, browser compatibility, and provides step‑by‑step Node.js/Express and plain JavaScript demos to illustrate how to implement SSE in real‑time applications.
This article explains the principles and use cases of Server‑Sent Events (SSE), compares it with traditional polling and WebSocket solutions, outlines their advantages and drawbacks, and provides complete front‑end and Node.js/Express demo code to build a real‑time push system.
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.
This article compares six WebSocket integration approaches—Javax, WebMVC, WebFlux, Java-WebSocket, SocketIO, and Netty—showing how to configure both server and client sides in Spring Boot, with step‑by‑step code examples, key annotations, and practical tips for each method.
This article provides a comprehensive guide to integrating WebSocket in Spring Boot, covering the native Javax API, Spring WebMVC and WebFlux approaches, as well as popular third‑party libraries such as Java‑WebSocket, SocketIO and Netty, with detailed configuration steps, code examples, and practical tips.
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.
This tutorial compares server‑push techniques—polling, WebSocket, and Server‑Sent Events—detailing their mechanisms, advantages, and drawbacks, then walks through setting up a simple SSE demo with Node.js and plain HTML, helping developers pick the right solution for real‑time data scenarios.
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.
This article explains how to solve real‑time data synchronization challenges by integrating the Ably PHP library via Composer, covering installation, basic usage examples such as publishing messages, retrieving history, and checking channel status, all with clear code snippets.
This article explains how to integrate the Ably real‑time messaging platform into a PHP project using Composer, covering installation, basic usage such as publishing messages, retrieving history, and checking channel status, and demonstrates how it simplifies global real‑time data synchronization.
This tutorial explains how to create a Python-based speech synthesis tool by installing required packages, configuring Xunfei Open Platform credentials, implementing a Tkinter GUI, and using WebSocket communication to convert text into audio with selectable voice profiles.
This article introduces Workerman, an open‑source pure‑PHP high‑performance application container, outlines its key features and typical use cases, and provides step‑by‑step installation, server‑side and client‑side code examples, as well as Nginx reverse‑proxy configuration for secure WebSocket deployment.
The article details how to engineer a Web‑based group chat that supports one million members by selecting WebSocket for real‑time communication, using read‑diffusion storage, a three‑layer architecture with Redis routing and Kafka queues, ensuring ordered, reliable delivery via TCP, ACKs and UUID deduplication, calculating unread counts with Redis ZSETs, and handling massive traffic through rate‑limiting, protobuf compression and message chunking.
This article provides a comprehensive guide on implementing WebSocket clusters in Spring Boot, covering three main integration methods—Javax, WebMVC, and WebFlux—including server‑side and client‑side configurations, code examples, and practical tips for each approach.
The article explains how to enforce single‑device login in web apps by contrasting token‑version control—incrementing a version field in the database and embedding it in JWTs to invalidate older tokens—with a WebSocket‑based method that pushes real‑time logout messages, comparing their trade‑offs and suggesting a hybrid solution.
This guide explains how to integrate multiple custom clients in Locust, covering the definition of client classes for HTTP and WebSocket, their use within a user class, configuration of run parameters, and important considerations such as resource management and exception handling.
This article explains why users may still see outdated pages after a Vue SPA deployment, analyzes the caching issues caused by static asset headers, and provides both back‑end coordinated and pure front‑end solutions—including WebSocket, SSE, ETag polling, custom Vite plugins, and example code—to automatically detect and prompt updates.
This guide demonstrates how to add WebSocket support to Locust by installing the websockets library, creating a custom WebSocket client class, defining user tasks, handling connection events, and running the load test against a WebSocket server.
This article explains how Server‑Sent Events (SSE) and WebSocket provide the low‑latency, bidirectional communication required by large language model applications, compares them with traditional HTTP/HTTPS protocols, outlines technical challenges such as gateway stability, bandwidth and security, and offers practical implementation steps and mitigation strategies.
This guide shows how to use PHP's popen with Workerman 5.0 and a WebSocket worker to run command‑line tasks asynchronously, manage a process pool, and stream output to a web client, enabling a functional web‑based SSH interface.
This article explains how to build real-time monitoring applications using PHP and the WebSocket protocol, covering the fundamentals of WebSocket, setting up a Ratchet server, creating client-side JavaScript connections, and providing complete code examples for a stock price monitoring demo.
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.
The article shows how AI accelerated a chatroom project's development—cutting cycle time, lowering developer skill demands, and delivering over 8% efficiency gains—by auto‑generating boilerplate code, debugging suggestions, and routine components such as API, Redis, MySQL, and WebSocket snippets, while outlining future improvements and a potential additional 10% R&D boost through integrated AI tools.
This article compares three real-time data update techniques—short and long polling, WebSocket, and Server‑Sent Events—explaining their principles, advantages, drawbacks, and providing practical Vue and Node.js code examples to help developers choose the optimal solution for their specific use case.
This article compares three real‑time data update methods—short and long polling, WebSocket, and Server‑Sent Events—explaining their principles, advantages, drawbacks, and providing practical code examples so developers can choose the most suitable solution for their web applications.
This article explores the role of WebSocket in IoT, detailing its advantages over HTTP, comparing Java implementations, presenting a Netty‑based architecture for smart devices, and providing complete code examples for connection handling, authentication, and message processing to achieve real‑time communication.
This article explains how to wrap WebSocket in a reusable JavaScript/TypeScript class that provides automatic reconnection, heartbeat monitoring, event callbacks, connection state management, and graceful destruction, while also comparing WebSocket advantages over traditional HTTP polling for real‑time H5 applications.
This article presents a step‑by‑step guide to building a Netty‑based WebSocket server in Java, covering server initialization, channel configuration, custom handlers, push‑message services, testing procedures, and includes complete source code, while also containing promotional material for unrelated AI services.
This article explains the lightweight Server‑Sent Events (SSE) approach for one‑way server push, compares its features, connection model, performance and use cases against WebSocket and traditional polling, and provides a SpringBoot example with code snippets for building an online‑user SSE endpoint.
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.
This article explains why traditional HTTP cannot let servers initiate messages, compares periodic HTTP polling and long polling as workarounds, and introduces the full‑duplex WebSocket protocol—including its handshake, frame format, and typical use cases such as web games and real‑time chat.
This article compares Server‑Sent Events, traditional polling, and WebSocket for server‑to‑client real‑time messaging, explains why WebSocket may be overkill for one‑way push scenarios, and provides a Spring Boot example of an SSE endpoint with code and configuration details.
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.
This article explains how to design a QR‑code login flow, create the necessary database table, define the required APIs, and integrate front‑end JavaScript with a Spring Boot back‑end using WebSocket to notify the client of successful authentication.
This article compares HTTP polling, WebSocket, and Server‑Sent Events (SSE) for large‑screen data fetching, explains their advantages and drawbacks, outlines suitable business scenarios, and provides complete front‑end and back‑end code examples for implementing SSE and WebSocket connections.
This article demonstrates how to build a web‑based voice chatbot by integrating Whisper speech‑to‑text, llama.cpp LLM inference, and WebSocket communication, detailing both the frontend JavaScript implementation and the Python FastAPI backend, along with Docker deployment and example code.
This article explains the WebSocket protocol, its advantages over traditional Ajax polling, typical use cases, the standard WebSocket API, and provides complete JavaScript implementations of a heartbeat base class and an extensible Socket wrapper with reconnection logic.
This tutorial explains how to use Netty to create a Java backend server with WebSocket support, covering server initialization, channel configuration, pipeline setup, custom handlers, and message‑push services, and includes complete code examples for each component.
This article explains WebTransport, an HTTP/3‑based API that offers multiplexing, flow control, and end‑to‑end encryption, compares it with WebSocket, and provides real‑world use cases such as cloud gaming and low‑latency live streaming with code examples.
This guide explains how to use Alibaba Cloud Service Mesh (ASM) loose‑mode traffic lanes to isolate WebSocket‑based services, configure context propagation via OpenTelemetry Baggage, and achieve full‑chain gray releases with step‑by‑step deployment, gateway routing, and testing procedures.
This article explains how to enable cross‑node WebSocket communication in a distributed Spring application by using a message queue (Redis or Kafka) to broadcast messages, tracking user connections with Redis, and providing a complete step‑by‑step implementation with code samples and configuration details.
This article demonstrates how to build a Netty‑based WebSocket server for message pushing in Java, provides complete source code for the server, configuration, pipeline, custom handler, and push service, and also contains promotional material for AI services and a community group.
This article explains the concepts of cross‑origin and same‑origin policies, and demonstrates multiple solutions—including JSONP, CORS headers, proxy servers, Nginx configuration, WebSocket communication, postMessage, and document.domain—providing both front‑end and back‑end code examples for each method.
This article explains how to design a live‑streaming danmaku (bullet‑screen) feature by using Redis Zset as the underlying data structure, limiting the list to the latest ten messages, and handling retrieval via polling APIs or WebSocket, with Kafka for message buffering and a distributed lock to avoid ordering issues.
This article walks through creating a WebSSH solution using SpringBoot, WebSocket, the Java jsch library, and the xterm.js front‑end, covering technology choices, core backend logic, demo screenshots, command examples, and future extension ideas.
This article details the design and implementation of a video‑claim system for insurance using Agora video‑call technology, covering background, core features, system architecture, adapter‑pattern code, Web and mini‑program SDK integration, exception handling, and future AI‑driven enhancements.
This article explains how to build a PHP WebSocket server using the Ratchet library, provides step‑by‑step code examples for server setup and a simple real‑time chat client, and demonstrates how to enable multi‑user online collaboration with WebSocket technology.
This article explains how to integrate Spring Boot with WebSocket to create a lightweight instant‑messaging system, covering dependency setup, configuration classes, core server code, front‑end integration, essential IM modules, common deployment challenges, and provides complete example code and demos.
This article analyzes the reasons for preferring EventSource instead of WebSocket in a browser‑based ChatGPT chat system, covering protocol basics, system characteristics, advantages, code examples, performance trade‑offs, and future extensibility.
This article reviews several ways to integrate WebSocket with Spring Boot, focusing on the three mainstream approaches—Javax, WebMVC, and WebFlux—by providing server and client configurations, code examples, and practical tips such as handling ping/pong, handshake interceptors, and reactive streams.
This article explains how the kubectl command interacts with the Kubernetes control plane, detailing one‑way HTTPS requests and two‑way WebSocket communications, and walks through the full execution flow of a kubectl exec command across kube‑api‑server, kubelet, and the CRI runtime.
This guide introduces JsRpc, a lightweight WebSocket‑based bridge that lets a Go server communicate with injected JavaScript in the browser, enabling reverse‑engineering of encrypted functions and data extraction through easy API calls.
This article explains how to enable cross‑server WebSocket communication in a distributed Spring application by using a message queue such as Redis or Kafka, detailing two architectural approaches, concrete code examples, configuration files, and a sample client page.
This tutorial explains how to use the Ratchet library to create a PHP WebSocket server, covering environment setup, Composer installation, server-side code, a simple HTML/JavaScript client, and steps to run and test real‑time data transmission.
This article outlines a comprehensive backend design that abstracts WebSocket into a reusable communication service, details project structure, business processes, reliability mechanisms for RabbitMQ, message classification, API design, and a unified message format to enable plug‑and‑play real‑time messaging across various Java applications.
This article explains WebRTC fundamentals, the PeerConnection API, signaling, ICE, STUN/TURN servers, the full P2P call flow, and provides a Node.js WebSocket signaling server example for front‑end developers building real‑time communication.
This article provides an in‑depth overview of the WebSocket protocol, covering its fundamentals, advantages, lifecycle, message formats, Java API usage, Spring Boot integration, performance considerations, and future development directions, complete with practical code examples for both server and client sides.
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 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.
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.
