This guide explains how to use NGINX to load‑balance and proxy WebSocket connections, covering protocol basics, required header settings, and a complete Node.js example with installation, server code, and NGINX configuration.
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.
This article explains VSCode's debugging architecture, introduces the Debug Adapter Protocol (DAP), and walks through a web‑based demo that implements a Node.js debug session using Monaco, WebSocket communication, and a custom debug adapter to illustrate the full debugging workflow.
In an interview, Tencent senior engineer Zhou Zijie explains how the new real‑time data push service for Mini Program Cloud Development monitors cloud‑database changes and reliably streams updates to mini‑apps via a three‑layer SDK‑middleware‑backend architecture that uses sequential numbering, TARS RPC, and extensive optimizations to achieve low latency, high concurrency, and will launch publicly in August.
This article details the Mobile Service “秒开” project’s three‑step performance optimization, covering data‑driven monitoring, HTTP/2 features like header compression and multiplexing, long‑connection architecture with WebSocket, and an asynchronous caching component that together dramatically improve response times and reliability for mobile clients.
This article explains how to use ThinkJS, a Koa‑based Node.js framework, together with WebSocket and Socket.io to build a multi‑device real‑time chat system, covering protocol basics, server and client configuration, a simple chat demo, and scaling across multiple nodes using Redis.
This article explains the principles, models, and implementations of Comet (including stream‑based and long‑polling approaches) and WebSocket as server‑push techniques for real‑time web applications, comparing their advantages, limitations, and practical deployment considerations.
This article describes the research, design, and implementation of an iOS remote‑control system—including technology selection, architecture with WebSocket and WebDriverAgent, performance optimizations for screenshot and event handling, and future improvement plans—aimed at providing smooth, low‑latency device access through a browser.
This article reviews the evolution of web real‑time push techniques—polling, long‑polling, iframe streaming—and explains why WebSocket offers superior bidirectional communication, lower latency, and reduced bandwidth, while providing practical code examples for each method.
This article describes how Zhaozhuan replaced third‑party IM solutions with a custom WebSocket‑based instant‑messaging system, covering background, WebSocket fundamentals, implementation choices, detailed client code, multi‑stage testing (pre‑test, functional, online monitoring), automation with Puppeteer, performance testing using JMeter, and monitoring platform integration.
The article explains how to use a custom URL schema together with a WebSocket channel to let a web page detect whether a mobile app is installed, attempt to launch it, and fall back to downloading the app when the launch fails, including practical blur‑event tricks.
When a WebSocket‑based service built on Netty started returning massive 5xx errors, we used log analysis, CAT monitoring, reflective access to Netty's internal memory counter, and step‑by‑step debugging to locate and fix an off‑heap memory leak caused by a null subType field in the encoder.
This article explains what APIs are, outlines various API types—including web service, source code, hardware, and WebSocket APIs—and discusses their browser compatibility challenges, such as deprecated SDK methods, REST method support, and cross‑origin issues, offering practical tips for developers to ensure reliable API integration.
This article explains the WebSocket protocol, compares it with traditional Ajax polling, shows client‑side JavaScript and server‑side Python implementations, details the handshake, frame parsing, and message framing, and highlights its suitability for real‑time applications.
This article explains how a unified, cross‑platform long‑connection component built on libuv, mbedTLS and WebSocket was refactored into a plug‑in architecture that decouples layers, uses double‑linked structures and function pointers, and dramatically improves flexibility and maintainability.
This article describes the motivation, layered architecture, protocol implementation details, and a plug‑in refactoring approach for a cross‑platform long‑connection component that unifies iOS, Android, and WebSocket communication using libuv, mbedTLS, and C interfaces.
This technical article discusses implementing an automatic printing solution for e-commerce merchants using WebSocket and Netty frameworks to enable real-time order push notifications and reduce manual intervention in the order processing workflow.
This article explains how React Native handles network requests differently from web browsers, describes the built‑in fetch, XMLHttpRequest, and WebSocket APIs, outlines debugging methods using proxies, Reactotron, and Chrome DevTools, and discusses strategies for sending binary data such as Base64 encoding and WebSocket support.
This article provides a comprehensive guide to WebSocket, covering its purpose, connection establishment, handshake process, data frame structure, masking algorithm, security considerations, and includes practical Node.js server and client code examples to illustrate real‑time bidirectional communication.
This article explains Envoy's HTTP filter architecture, routing capabilities, gRPC integration, WebSocket handling, and cluster manager functions, detailing how each component operates without needing knowledge of underlying protocols and how they enable advanced traffic management, observability, and service mesh features.
Facing massive memory usage and latency in a PHP‑based live‑stream bullet chat, we iteratively re‑engineered the system—splitting Redis, limiting broadcasts, sharding rooms, then rebuilding it in Go with distributed room management, concurrent broadcasting, and extensive testing, achieving stable operation for tens of thousands of concurrent connections.
This article reviews the main web push techniques—short polling, long polling, iframe streaming, WebSocket, and Server‑Sent Events—explaining their principles, advantages, disadvantages, and suitability, and presents a practical implementation case with a detailed comparison and troubleshooting guide.
The article explains how to build a browser‑based container web console with GoTTY by wrapping docker exec in a WebSocket‑driven backend, detailing static asset handling, dual‑goroutine I/O, deployment options for distributed or centralized agents, security logging, and automatic cleanup of orphaned shell processes.
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.
This article explains the background, protocol basics, handshake process, and practical implementation of WebSocket using Netty and netty‑socketio on the server side and socket.io on the client side, providing full code examples and deployment tips for high‑concurrency real‑time applications.
This article demonstrates how to build a Netty‑based server and client that support long‑living WebSocket connections, high concurrency, heartbeat monitoring, and automatic reconnection, providing complete code examples and detailed explanations of each component.
This article introduces Netty, an asynchronous event‑driven network framework, covering its design goals, performance benefits, core components such as zero‑copy and unified APIs, advanced features like SSL/TLS and WebSocket support, and explains its single‑thread, multi‑thread, and master‑slave thread models for high‑concurrency backend development.
This article presents a comprehensive Mini Program tutorial covering the full course syllabus—from introductory setup and appID registration to intermediate project structure, utility extraction, network handling, list and detail page implementation—along with a detailed step‑by‑step guide for obtaining and configuring an appID.
This article explains the purpose of WebSocket subprotocols, details the WebSocket frame structure, clarifies cross‑origin capabilities, and walks through CORS mechanics including simple requests, preflight checks, and credential handling.
This article explains the evolution of real-time message delivery—from short polling to long polling, streaming, and WebSocket—introduces Socket.io, and details a multi‑node cluster architecture using Redis, Nginx, and Node.js for scalable chat applications.
This article walks through the evolution of front‑end communication techniques—from classic AJAX to JSONP, Server‑Sent Events, and WebSocket—explaining their principles, differences, and providing concise code demos for each method.
This article reviews various front‑end data exchange techniques—including HTTP methods, form encodings, AJAX, fetch, Server‑Sent Events, WebSocket, postMessage, and Web Workers—explaining when to use each, providing practical examples and code snippets for real‑world scenarios.
This article explains why flv.js is essential for modern browser live streaming, compares common streaming protocols and their latency/performance, outlines flv.js advantages and limitations, and provides a step‑by‑step guide to building a low‑latency live streaming solution with livego and React.
This article demonstrates several cross‑origin communication methods—including JSONP, window.name, document.domain, CORS, postMessage, and WebSocket—by providing step‑by‑step code examples, host file configuration, and instructions for testing each technique in a local environment development.
This article explores TCP/IP fundamentals—including three‑way handshake, receive windows, congestion control mechanisms, and HTTP header limits—while demonstrating practical packet captures with tcpdump and building a simple WebSocket chat demo to illustrate protocol behavior and differences from WebRTC.
This article reports a benchmark of seven WebSocket server frameworks (Netty, Undertow, Jetty, Vert.x, Grizzly, spray-websocket, Node.js) plus a Go implementation, describing the test setup on AWS C3.4xlarge instances, detailed per‑framework results, and an analysis of latency, CPU and memory usage.
This tutorial walks through setting up a Node.js WebSocket server, creating a PC client and a WeChat Mini Program client, and enabling bidirectional communication so the mini program can remotely control a projector screen.
This article provides a comprehensive overview of WebSocket, covering its origins as a full‑duplex HTML5 protocol, core JavaScript API usage, sub‑protocol negotiation, framing rules, security considerations, performance comparisons with XHR and SSE, deployment challenges, and related extensions such as Socket.IO.
This article explains WebSocket fundamentals, the HTTP‑based handshake process, client‑side JavaScript API usage with code examples, and a complete Node.js server implementation including connection handling, data‑frame parsing, message broadcasting, heartbeat maintenance, and browser compatibility considerations.
This article introduces Socket.IO, explains its features and transport fallback mechanisms, showcases a real‑world example (tty.js Linux terminal), and provides a step‑by‑step guide to create a simple web page that displays the server’s current time using Node.js and client‑side JavaScript.
The article outlines the end‑to‑end workflow of H5 live streaming, discusses state control, WebSocket‑based comment handling, heartbeat reconnection, video compatibility issues, and practical code techniques for detecting and recovering from stream stalls.
This article surveys popular WebSocket and real‑time communication libraries across languages, highlighting their core features such as heartbeat, reconnection, fallback mechanisms, publish‑subscribe patterns, and data‑sync capabilities, while providing direct links for quick reference.
SockJS provides a mature, cross‑browser real‑time communication library that mimics WebSocket while offering fallback transports, load‑balancing options, and easy client‑server integration, making it ideal for building robust web applications in complex network environments.
The article compares the mature, innovation‑focused US HTML5 ecosystem with China’s still‑hype‑driven market, highlighting differences in developer attitudes toward WebGL, WebSocket, React JS/Native, cross‑platform packaging, and the shift from buzzwords to practical, deep‑tech solutions.
This article explains the origins and standards of WebSocket, compares its full‑duplex communication model with traditional HTTP, details server‑side and client‑side APIs with Java and JavaScript code examples, and presents a practical case study of real‑time device tracking using Tomcat.
