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.
This guide walks you through creating a Spring Boot application that uses WebSocket and STOMP to exchange JSON messages between a browser client and a server, covering project setup, dependencies, Java POJOs, controller logic, WebSocket configuration, client‑side JavaScript, and how to build and run the executable JAR.
This article explains how the WebSocket API provides bidirectional, message‑oriented communication, compares its latency and overhead with XHR and SSE, discusses compression and custom protocols, and offers practical deployment and tuning guidelines for long‑lived connections.
This article explains the WebSocket protocol (RFC 6455), covering its HTTP upgrade handshake, binary frame format, message fragmentation, multiplexing and compression extensions, and the required header fields for establishing a secure, bidirectional communication channel between client and server.
The article introduces Base Admin, a lightweight backend management platform built with SpringBoot, Thymeleaf, WebSocket and Spring Security, detailing its technology stack, project structure, core features such as permission and menu management, real‑time logging, monitoring, API encryption, and recent updates.
This tutorial explains how to use the Workerman PHP socket framework and GatewayWorker to replace HTTP long‑polling with WebSocket‑based real‑time communication, covering protocol basics, short vs. long connections, integration with MVC frameworks, and complete client‑ and server‑side code examples.
This tutorial demonstrates how to build a WebSocket server using PHP's Swoole extension and a corresponding HTML/JavaScript client, covering protocol basics, server-side event handling for connections, messages, and closures, and showing the complete code and execution results for real‑time bidirectional communication.
This article explains the origins, definition, basic frame format, masking purpose, and handshake process of the WebSocket protocol, and demonstrates packet capture analysis with a simple demo to illustrate how full‑duplex communication works over a single TCP connection.
This article explains the principles and practical implementation of WebSocket, compares it with HTTP, discusses when to use it, and details a complete backend and frontend solution using Spring WebSocket, SockJS, and STOMP for real‑time communication in web applications.
This article explains the product features, technical challenges, technology choices, and detailed architecture design for a live‑streaming quiz application that must support up to one million concurrent users, high QPS, low latency, and secure financial transactions.
This article introduces Chrome extension fundamentals, outlines its core components and APIs, and provides a step‑by‑step guide—including server‑side WebSocket handling, content‑script communication, popup QR‑code generation, and installation methods—to create a flip‑pen remote‑control plugin.
This guide explains the STOMP protocol, its frame structure, and how to integrate it with Spring Boot to build a real‑time chat application, covering server‑side configuration, message broker setup, as well as the client‑side HTML and JavaScript needed for sending and receiving messages.
This article details the design, architecture, and implementation of a mobile instant‑messaging system for a travel platform, covering data‑channel handling, subscription and UI rendering, message de‑duplication, local push, reconnection strategies, message‑line management, and a migration to WebSocket for improved performance.
This article explains how a travel e‑commerce platform rebuilt its instant‑messaging service with Go, separating business logic, introducing a dual‑layer distributed architecture, and optimizing performance and reliability to handle massive concurrent connections and improve overall GMV.
This article explains how to extend a Django Channels‑based WebSSH tool with real‑time operation monitoring, group‑based messaging, and a forced‑disconnect feature, detailing the necessary layer configuration, consumer modifications, and WebSocket message handling for both operators and observers.
This article explains the limitations of short and long polling, introduces the WebSocket protocol and its handshake mechanism, and provides complete client‑side and Node.js server code to build a basic real‑time chat application with heartbeat keep‑alive support.
This article details the design and implementation of a scalable mobile instant‑messaging system for a travel app, covering architecture, data‑channel handling, subscription mechanisms, UI rendering, message de‑duplication, local push strategies, reconnection logic, and future upgrades to WebSocket.
This article highlights the latest tech releases, including TensorFlow 1.15’s final minor update with compatibility features, Firefox 70’s new WebSocket inspector for developers, the Windows 10 SDK 1909 update, and Microsoft’s open‑source DAPR and OAM projects aimed at simplifying microservice and cloud‑native application development.
This article walks you through deploying a WebSocket chat service and a gRPC ping service on Knative, covering repository cloning, Docker image preparation, Knative Service YAML configuration, kubectl deployment commands, and browser‑based verification to ensure the services run correctly in a serverless environment.
This article details the design, architecture, and implementation of a mobile instant‑messaging system for a travel platform, covering data channel design, message subscription, UI rendering, deduplication, local push, reconnection strategies, and the planned migration to WebSocket.
At a Tencent Cloud technical salon, Egret Technology’s senior product manager demonstrated how the Egret engine’s built‑in cloud development and WebSocket‑based real‑time data push enable mini‑programs such as leaderboards and chat rooms, eliminating server setup, reducing backend costs, and simplifying cross‑platform game creation.
