This article explains how a large-scale customer service instant messaging platform uses clustered WebSocket services, Redis, Nginx load balancing, and message‑queue broadcasting to achieve real‑time, reliable message delivery and robust reconnection handling across multiple servers.
This guide walks through setting up a Spring Boot 2.3.9 WebSocket server, defining message types and enums, implementing encoder/decoder, configuring the endpoint and bean, and creating a simple HTML/JavaScript client to test real‑time messaging between multiple users.
This article explains the Chrome DevTools Protocol (CDP), its architecture of frontend, backend, protocol and channels, and provides step‑by‑step instructions with code examples for launching a CDP server, connecting a client, and performing remote debugging of JavaScript, CSS and DOM through WebSocket or other transports.
This tutorial walks you through creating a real‑time group chat using Spring Boot and Java WebSocket, covering Maven dependencies, core server classes, annotation explanations, configuration, and testing with an online client, all backed by complete source code on GitHub.
This article explains what sockets are, how they relate to TCP/IP and HTTP, introduces the origin and purpose of WebSocket, compares it with traditional sockets, and details the WebSocket handshake, data framing, and differences from HTTP for real‑time bidirectional communication.
This article explores practical approaches for building a distributed WebSocket cluster in a Spring Cloud environment, covering session handling, Netty versus Spring WebSocket implementations, session broadcasting, consistent‑hash routing, gateway configuration, Ribbon limitations, and provides code examples for each solution.
This tutorial explains how to create a lightweight speech synthesis tool using iFlytek's WebAPI, covering required environment setup, API credential acquisition, GUI design with Tkinter, and detailed Python code for WebSocket communication, audio handling, and WAV file generation.
This article explains how to use Spring Boot to add WebSocket support, covering the protocol basics, Maven dependencies, configuration classes, a test controller, a simple HTML client page, and troubleshooting tips, all illustrated with complete Java and JavaScript code examples.
This article explains the limitations of HTTP for real‑time communication, compares WebSocket with polling, long‑polling, streaming and SSE, outlines WebSocket's benefits and typical use cases, and then details how STOMP complements WebSocket within Spring's messaging framework, including configuration and message flow.
This article explains the fundamentals of cross‑origin restrictions, cookies, and same‑origin policy for frontend developers, demonstrates common CORS errors with sample code, and presents practical solutions—including iframe/postMessage, JSONP, WebSocket, and CORS configurations on servers such as Node.js and Nginx—to enable secure and reliable cross‑domain communication.
This guide explains WebSocket fundamentals, compares it with HTTP, and provides step‑by‑step Nginx configuration—including map directives, upstream blocks, TLS settings, and timeout tweaks—to reliably proxy WebSocket connections and maintain long‑living connections.
This article explains the WebSocket protocol, its full‑duplex persistent connection, key features, why it outperforms HTTP for real‑time scenarios, and provides detailed handshake examples for both client and server implementations.
This article reviews eight popular Node.js WebSocket libraries—SockJS, ws, Socket.IO, Faye WebSocket, SocketCluster, Sockette, and Feathers—detailing their features, popularity, installation commands, and typical use cases for building real‑time backend applications.
Learn how to resolve WebSocket session sharing issues in load‑balanced Java applications by leveraging Redis’s publish/subscribe mechanism and Spring Session, with step‑by‑step configuration, code examples, and deployment instructions for multiple distributed environments.
This article explains the relationships among WebSocket, Engine.IO, and Socket.IO, details Engine.IO’s features, handshake, upgrade and disconnect mechanisms, and provides practical code examples for building real‑time communication in Node.js applications, including packet encoding, transport options, and debugging techniques.
This article explains the concept of Remote Procedure Call (RPC), demonstrates how to apply RPC for web reverse engineering by injecting JavaScript through WebSocket communication, and introduces the Sekiro framework and related tools for automating encryption parameter retrieval in browser environments.
This article details the design and implementation of an online customer service instant messaging system, covering requirements analysis, client‑server network model, HTTP and WebSocket protocols, distributed architecture choices such as routing rules, Redis shared memory, server‑master sync, and message‑queue broadcasting, and explains why Netty was selected as the development framework.
This tutorial explains the advantages of WebSocket over HTTP and provides a step‑by‑step guide, including Maven dependency, Spring Boot configuration, a ServerEndpoint class, a simple HTML/JavaScript front‑end, and a controller method, to build a real‑time chat system with online/offline notifications and private or broadcast messaging.
This article explains how to solve the problem of non‑serializable WebSocket sessions in a load‑balanced Spring application by using Redis publish/subscribe and spring‑session‑redis to share session data across multiple server instances, providing complete configuration and code examples.
This article introduces JsRpc, a WebSocket‑based bridge between a browser and a Go server that lets you execute custom JavaScript from HTTP‑style calls, enabling reverse‑engineering, encrypted function calls, and data extraction.
This guide shows how to create a full‑duplex bullet‑screen (barrage) application on Alibaba Cloud using Serverless architecture, API Gateway, Function Compute, OSS and Tablestore, covering the overall design, data model, step‑by‑step deployment, and essential code snippets.
This article explains the WebSocket handshake protocol, compares short‑polling, long‑polling, and WebSocket connections, and shares practical implementations in WeChat mini‑programs—including authentication, heartbeat, RTT simulation, compression, reconnection strategies, caching, and TCP_NODELAY tuning, complete with code examples.
This tutorial shows how to install and use ttyd, a C‑based tool that shares a local terminal over the web via WebSocket, covering basic commands, port binding, authentication, Docker deployment, SSH support, SSL configuration, and public exposure with ngrok.
This tutorial explains WebRTC fundamentals, signaling via WebSocket, NAT traversal with STUN/TURN, peer‑to‑peer connection flow, media capture, screen sharing, recording, and deployment tips, providing complete Vue and Node.js code examples for building robust 1‑to‑1 and multi‑user video applications.
Learn how to achieve real‑time data synchronization between separate front‑end applications by leveraging WebSocket and Socket.io, covering the protocol basics, connection setup, event handling, server implementation, alternative communication methods, and practical code examples for both client and server sides.
This guide demonstrates how to create a Go-based WebSocket server and client using the gobwas library, enabling two services to exchange random numbers, handle connections, and gracefully manage disconnections, with complete code examples and testing instructions.
This article details the evolution from a Node.js‑based WebSocket gateway to a Go‑implemented, gRPC‑driven architecture, describing the redesign of connection handling, TLS off‑loading, socket ID generation, session management, custom Kafka headers, code‑level optimizations, and extensive performance testing that validates the new gateway’s scalability and resource efficiency.
This article describes the architectural evolution from Gateway 1.0 to Gateway 2.0 for a high‑traffic document collaboration platform, detailing the redesign of the WebSocket layer, resource‑usage optimizations, heartbeat mechanisms, custom Kafka headers, message serialization, load‑testing results, and the operational lessons learned to support millions of concurrent connections.
This article details the redesign of Shimo Docs' WebSocket gateway—from a Node.js/Socket.IO 1.0 version to a Go‑based 2.0 architecture—covering handshake degradation, TLS memory savings, SnowFlake SocketID generation, Redis‑based session broadcasting, heartbeat tuning, custom Kafka headers, object pooling, MessagePack compression, extensive performance testing, and the resulting stability and scalability improvements for handling half‑a‑million concurrent connections.
This article describes the evolution from a Node.js‑based WebSocket gateway to a Go‑powered, gRPC‑enabled architecture, detailing the redesign of the gateway, resource‑saving techniques, heartbeat and TLS optimizations, message‑broker choices, extensive performance testing, and the resulting improvements in CPU, memory, and scalability for millions of concurrent connections.
This article details the design, refactoring, and performance testing of a high‑traffic WebSocket gateway for Shimo Docs, covering the evolution from a Node.js Socket.IO version to a Go‑based microservice architecture, TLS memory tuning, socket ID generation, heartbeat handling, custom Kafka headers, and resource‑efficient scaling to half‑a‑million concurrent connections.
This article details the evolution from a Node.js Socket.IO gateway to a Go‑based, gRPC‑enabled WebSocket gateway that supports millions of concurrent connections, covering architecture redesign, TLS handling, socket ID generation, session management, heartbeat optimization, custom Kafka headers, code‑level refinements, and extensive performance testing results.
This article explains how to build a QR‑code based login system by designing a token table, defining roles, creating two REST APIs (generate QR code and confirm identity), and integrating front‑end JavaScript with a Spring Boot WebSocket server, complete with full code examples and step‑by‑step instructions.
This guide walks through using the Gorilla WebSocket library in Go, covering dependency setup, server implementation with an Upgrader, Java and Go client examples, testing procedures, and performance observations that highlight Go's advantages for WebSocket workloads.
This guide walks through creating a WebShell that lets a React front‑end control a remote virtual machine via Django‑based WebSocket services, covering ASGI setup, custom WebSocket handling, integration with Paramiko for SSH, and a lightweight xterm.js terminal client.
The article explains the typical live‑streaming architecture, its core modules, the impact of CDN integration, and three major challenges—video‑stream pressure, low‑latency interactive protocols, and high‑concurrency pulse traffic—while showing how Alibaba Cloud PTS can be used for realistic performance testing.
This article walks through developing a simple Go WebSocket server that echoes the current time, shows a minimal client, compares startup speed with Java, and provides full source code and test logs for practical performance testing.
This article walks through the challenges of multi‑user WebSocket communication in a clustered environment and presents two practical solutions—session broadcasting and a consistent‑hashing based routing—using Spring Boot, Spring Cloud Gateway, Redis, Netty, and Ribbon to achieve scalable, reliable real‑time messaging.
This article analyzes the challenges of multi‑user WebSocket communication in a clustered environment, compares Netty and Spring WebSocket implementations, and presents two practical solutions—session broadcast and a consistent‑hashing based routing scheme—complete with code samples, gateway configuration, and load‑balancing considerations.
This article explores practical approaches for enabling multi‑user communication in a distributed WebSocket cluster, covering session handling challenges, architecture design, technology stack choices, Netty versus Spring WebSocket implementations, consistent‑hashing load balancing, and detailed code examples for Spring Cloud Gateway and Ribbon integration.
This article explains how to design a QR‑code login flow using a MySQL table, defines the involved roles, outlines required REST and WebSocket interfaces, and provides complete Spring Boot backend and JavaScript frontend code examples for generating QR codes, validating tokens, and notifying the client in real time.
This article explains how to build a QR‑code based login system using Spring Boot, WebSocket, and JavaScript, covering database design, role analysis, API definitions, step‑by‑step implementation, and complete code examples for both backend and frontend components.
This article demonstrates a real-time device monitoring solution that uses a WebSocket connection to push abnormal equipment alerts from a mobile client to a Vue-based monitoring page, with a SpringBoot backend handling the WebSocket server and broadcast logic.
Learn how to build a pure Go instant messaging platform with a three‑layer, distributed architecture—comet, logic, and job—featuring RPC communication, Redis‑based message pushing, and cluster support, plus step‑by‑step deployment instructions, required packages, and future enhancement plans.
This article explains WebRTC fundamentals, compares it with WebSocket, describes SDP, ICE, STUN/TURN NAT traversal, and provides full server‑side and client‑side JavaScript code to build a peer‑to‑peer video conferencing demo.
This guide walks through setting up a full‑stack web chatroom demo built with Spring Boot, Vue, WebSocket, MySQL, Redis, RabbitMQ and FastDFS, covering the technology stack, core features, database schema, configuration files, and step‑by‑step deployment instructions.
This article walks through creating a real‑time video bullet‑chat system using Netty as the backend server and WebSocket for bidirectional communication, covering technology selection, architecture design, data flow, and detailed Java and HTML/JavaScript code to implement the interactive feature.
This article explains how to build a WebShell by creating a Django ASGI WebSocket service using gunicorn, uvicorn, and Paramiko, and integrates it with a React front‑end component that leverages xterm.js for terminal interaction, providing full code examples and implementation details.
This tutorial walks through designing a QR‑code login flow using Spring Boot, detailing the required database schema, roles, API endpoints, server‑side WebSocket setup, and front‑end JavaScript to fetch the QR image, extract the UUID, and establish a real‑time connection for authentication.
This tutorial walks you through creating a real‑time online chatroom using Django 3, Channels, Redis (or Memurai on Windows), and a Vue front‑end, covering environment setup, dependency installation, project configuration, WebSocket consumer implementation, and front‑end integration.
This article introduces the open‑source CIM instant‑messaging system, explains its Netty/WebSocket‑based backend architecture, outlines the available client SDKs and server modules, and showcases functional previews for console, Android, and web clients, guiding developers on how to adopt or adapt the solution.
This article demonstrates how to build a real‑time video bullet‑chat system by selecting Netty and WebSocket, designing a bidirectional service architecture, implementing a Java server with Netty handlers, and creating a browser client with HTML5 video and JavaScript to send and display scrolling comments.
This article explains how to implement efficient real-time WebSocket message pushing in a distributed system by using Redis as a coordination layer, defining Go-based Client and ClientManager components, and detailing the end‑to‑end flow from message production to client delivery.
This guide explains how WebSockets enable full‑duplex communication over a single TCP connection, compares popular Go WebSocket libraries, and provides complete client‑server code examples for TCP, UDP, and HTTP‑based WebSocket implementations, helping developers build real‑time applications such as chat, games, and monitoring tools.
This article provides a comprehensive tutorial on using Node.js Inspector for local and remote debugging, automatic detection, data collection (heap snapshots and CPU profiles), dynamic activation, and a detailed walkthrough of its internal architecture and communication flow between the client, WebSocket, and V8 Inspector.
This article walks through converting a Go‑based TCP private‑protocol server to support WebSocket on the same port, covering library selection, client and server implementation, request upgrading, and a complete usage example with code snippets.
The article explains why traditional polling methods fall short for real‑time data, introduces the WebSocket protocol’s full‑duplex handshake and heartbeat mechanisms, and demonstrates how a Java‑based WebSocket service efficiently streams audio to an ASR engine for low‑latency speech recognition.
This guide explains why heartbeat detection is essential for long‑living TCP connections, describes the GatewayWorker architecture, and provides step‑by‑step server and client configurations—including PHP and JavaScript code—to reliably detect client disconnections in WebSocket applications.
This article is based on the 2021 GMTC Global Frontend Technology Conference's 'New Trends in Mobile Technology' sub-topic, sharing the theme 'VR and 3D Technology Architecture Design and Practice on the Web', and is organized from the original presentation.
This article introduces WebSocket, explains why it is preferred over HTTP for real‑time communication, and provides a complete Spring Boot integration tutorial with Maven dependencies, configuration, server endpoint code, controller, and a simple HTML client, all illustrated with runnable examples.
This tutorial walks you through preparing, installing JMeter and its WebSocket plugin, configuring a WebSocket sampler, and executing a full end‑to‑end test case, including JSON payload handling, result verification, and common pitfalls for reliable backend service testing.
This article explains the concepts and practical implementations of real-time push techniques—including short polling, long polling, WebSocket, and Server‑Sent Events—detailing their principles, advantages, drawbacks, and providing complete JavaScript code examples for both client and server sides.
This article walks through building a real‑time push system with Spring Boot by integrating WebSocket and MQTT, covering the protocol basics, Maven setup, configuration classes, server implementation, controller endpoints, front‑end testing page, common pitfalls, and deployment tips.
Tomcat 10.0.x targets Jakarta EE 9, requiring developers to replace the javax package with jakarta, and version 10.0.5 introduces proper JNDIRealm escaping, updated HandlesTypes handling, and a refactored, IoC‑friendly WebSocket creation process to ease migration from earlier Tomcat releases.
This tutorial demonstrates how to integrate Spring Boot with WebSocket to achieve server‑initiated real‑time message pushing, covering dependency setup, configuration, server implementation, controller and client page code, and troubleshooting initialization order issues.
This article introduces Google Protocol Buffers, explains its binary encoding principles such as Tag‑Length‑Value, Varint and ZigZag, compares its efficiency with JSON/XML, and provides a step‑by‑step demo of building a Protobuf‑based WebSocket communication system using Node.js, protobufjs and a simple HTTP server.
This article introduces the open‑source CIM instant messaging system, detailing its server‑side architecture based on Netty or Mina, multi‑platform client support (WebSocket, Android, iOS, desktop), core modules, directory structure, and a preview of its console and client interfaces.
This article presents the design, implementation, and performance evaluation of a Netty‑based WebSocket long‑connection gateway that centralizes session management, decouples business logic, supports horizontal scaling, and provides monitoring and alerting for high‑throughput real‑time data push in iQIYI’s platform.
This guide walks through adding the WebSocket starter to a Spring Boot service, configuring a WebSocketConfig class, implementing client and service components, adjusting Nacos gateway rules, testing with a WebSocket client tool, and exposing a REST endpoint to push messages to Vue front‑ends.
This article explains the concept and role of signaling in real‑time audio/video, describes the single‑PeerConnection architecture using WebSocket, details the handshake, keep‑alive and reconnection mechanisms, and outlines NERTC’s modular network library design for robust communication under weak network conditions.
This article walks through building a WebSSH solution from scratch using Spring Boot for the backend, WebSocket for real‑time communication, JSch for SSH handling, and xterm.js on the frontend to render a terminal‑like interface, complete with code examples and deployment tips.
This article explains the challenges of server‑push in HTTP, reviews WebSocket as the mainstream solution, and details the design, implementation, session management, monitoring, and performance testing of a Netty‑based distributed WebSocket long‑connection gateway used at iQIYI.
This article walks through creating a WebSSH solution from scratch using Spring Boot, WebSocket, JSch and the xterm.js front‑end library, covering dependency setup, backend WebSocket configuration, message handling, SSH session management, and a minimal HTML/JS client to display a browser‑based terminal.
iQIYI built a Netty‑based WebSocket long‑connection gateway that centralizes session management, uses RocketMQ for cluster‑wide broadcast, provides a simple HTTP push API, scales horizontally to millions of connections, integrates Prometheus/Grafana monitoring, and dramatically cuts development effort for real‑time features such as comments and authentication.
This article presents the background, research, design choices, core features, extensions, challenges, and outcomes of Mars, a proxy‑based lightweight frontend mock platform developed by Ctrip's IBU ticket team to improve development efficiency and testing flexibility across devices and environments.
The article recounts how Postman's Service Foundation team identified the limitations of the monolithic Sync service, designed and built the Bifrost WebSocket gateway using Fastify, AWS ElastiCache for Redis, and a private API, and scaled it through horizontal expansion and custom load‑factor metrics while sharing practical engineering insights.
This guide explains how to use WebSocket in a WeChat Mini‑Program to implement real‑time features such as live‑room comments, user join/leave events, likes, follows, and product shelf updates, covering protocol basics, handshake details, API usage, example code, heartbeat monitoring, and automatic reconnection strategies.
This article explains the design and testing of a virtual‑classroom whiteboard feature, covering the socket‑based transmission protocol, data encoding, message structures, coordinate system, supporting Java classes (Point, BoardBase, BoardUser), shape‑drawing utilities, and a runnable demo that generates base64‑encoded MessagePack payloads.
This article explains how to integrate WebSocket into a Spring Boot application, covering the protocol basics, Maven dependencies, configuration classes, server endpoint implementation, controller and front‑end code, and troubleshooting tips for full‑duplex real‑time communication.
San DevTools implements a four‑module remote‑debugging architecture where the Message Channel uses WebSocket to multiplex bidirectional frontend‑backend communication, Chrome extensions exchange messages via ports and postMessage, and both a custom San DevTools Protocol and the standard Chrome DevTools Protocol are supported through hook‑based agents and client examples.
This article demonstrates how to build a WebSSH terminal from scratch using SpringBoot for the backend, WebSocket for real‑time communication, JSch for SSH connections, and xterm.js for the front‑end terminal UI, including dependency setup, server‑side logic, and client‑side integration.
The first part of the San DevTools Technical Analysis series explains its dual usage (Chrome extension or npm‑based standalone), outlines the overall architecture—including frontend UI panels, backend injection, a JSON‑based remote debugging protocol, and message‑channel transport—plus core modules such as Bridge, Hook, and Agent, and demonstrates initialization and remote‑debugging flows, setting the stage for deeper protocol exploration.
This article details a step‑by‑step method for extracting live chat bullet comments from Taobao live streams by analyzing page sources, intercepting the token‑providing API with Puppeteer, establishing a WebSocket connection, and decoding the received base64‑ and GZIP‑compressed messages to retrieve clean usernames and comment texts.
This article walks through building and executing a Groovy‑based test script that registers two users, joins a room, exchanges chat messages over a Socket (WebSocket) connection, and cleanly closes the sockets, illustrating the full workflow and code structure for backend socket API testing.
This article walks through the design and implementation of a Java Socket.IO client library, covering dependency setup, core class architecture, event handling, connection management, performance testing utilities, and a complete usage demo with console output.
This article introduces a reusable Java WebSocket client wrapper that adds convenient date handling, message logging, configurable constants, and performance‑testing utilities, explains its implementation details with full source code, and provides a simple demo showing connection, messaging, and graceful shutdown.
This article explains how crawler engineers can fetch real‑time data such as sports scores, stock quotes, or cryptocurrency prices by comparing polling and WebSocket approaches, introducing the aiowebsocket library, and providing complete Python code to perform handshake, subscription, and continuous data streaming.
This guide walks through creating a Java WebSocket chat application, covering a SpringBoot server implementation, client setup using java‑websocket, configuration pitfalls, a bean‑based scheduler, and a test script that simulates multiple users joining, messaging, and leaving the chat room.
This tutorial demonstrates how to create a lightweight chatroom by combining WebSocket on the front end with Swoole's WebSocket server in PHP, covering project setup, required environment, client‑side HTML/JS, server‑side PHP code, and steps to run and test the application.
This article introduces Swoole as a high‑performance asynchronous PHP engine, explains its differences from traditional PHP execution, and provides step‑by‑step guidance on integrating Swoole with ThinkPHP5, including a complete code example and key implementation notes.
This practical guide explains WebSocket fundamentals, demonstrates how to integrate and debug them in a project with webpack proxy and Nginx settings, implements heartbeat and reconnection logic for stability, and compares native WebSocket to Socket.io’s richer but heavier real‑time framework.
This article introduces CIM, an open‑source real‑time messaging system built on Mina or Netty that supports WebSocket, Android, iOS, desktop and embedded clients, explains its architecture, core modules, directory layout, and showcases console, Android and web demos.
This guide explains how to use RabbitMQ's MQTT plugin and MQTT.js to implement instant messaging, covering MQTT protocol basics, enabling RabbitMQ MQTT and Web‑MQTT, using MQTTBox for testing, creating a pure HTML/JavaScript chat client, and integrating MQTT into a SpringBoot application for backend notifications.
This article reviews Java WebSocket options—including the Java EE specification, SockJS, Socket.IO, and reactive stream implementations—detailing their advantages, drawbacks, and performance characteristics, and provides benchmark data to help developers choose the most suitable solution for their backend communication needs.
This article walks through building a multi‑client chatroom using Netty and HTML5 WebSocket, explaining why WebSocket outperforms Ajax polling, detailing server‑side handlers, client‑side JavaScript, and demonstrating connection lifecycle and message exchange with full code examples.
This article explains the limits of HTTP keep-alive, compares Ajax polling and long‑polling techniques for server push, and then details how the WebSocket protocol establishes a full‑duplex connection through a handshake and data‑transfer phase.
This article compares three real‑time data delivery techniques—long/short polling, Server‑Sent Events, and WebSockets—explaining their mechanisms, advantages, drawbacks, and providing sample client‑server implementations to help developers select the most suitable approach for a dashboard that streams GitHub/Twitter activity.
This article provides a systematic, hands‑on guide to DNS fundamentals—including dig queries, hierarchical lookups, Wireshark packet analysis, traditional DNS drawbacks, and HTTPDNS solutions—followed by a deep dive into WebSocket mechanics, handshake, frame structure, and security considerations, all illustrated with practical examples and code.
This article introduces a lightweight, generic Java SpringBoot-based admin platform that offers permission, menu, and user management, system settings, real‑time logging and monitoring, API encryption, dynamic permission loading, and customizable features such as online user tracking and personalized menus, all illustrated with screenshots and code links.
This article explains how to design a high‑concurrency flash‑sale (秒杀) system using Redis to preload inventory, pre‑decrement stock, queue requests asynchronously, generate orders, and notify users via WebSocket, thereby avoiding overselling and improving performance under heavy load.
