This tutorial explains how to build a real-time data visualization feature by setting up a PHP WebSocket server with Ratchet and displaying live data on the client side using Highcharts, covering environment setup, server and client code, and deployment considerations.
The article compares EventSource and WebSocket, outlining their respective advantages, disadvantages, and appropriate use cases for server‑push versus bidirectional real‑time communication in web applications such as the ChatGPT interface.
This tutorial explains how to create a basic real-time chat application by combining PHP backend logic, MySQL storage, AJAX polling, and WebSocket communication to enable instant message exchange in web browsers.
The guide walks through building a real‑time instant‑messaging system—using a multiplayer monster‑battle demo—to compare polling, long‑polling, SSE and WebSocket, explains the WebSocket handshake and frame format, shows a custom Node.js server implementation, and advises adopting mature IM SDKs for production.
This article introduces a Spring Boot library that uses a configuration annotation to enable WebSocket load balancing across microservice instances, explains its abstract design, connection management, message routing, and provides usage examples with code snippets while also mentioning related promotional content.
This article introduces a Spring‑Boot library that uses a configuration annotation to enable WebSocket load‑balancing across microservice instances, detailing its usage, abstract design, connection management, message routing, and extensibility for various long‑connection protocols.
This article explains how to solve the problem of message loss in WebSocket communication within a micro‑service architecture by introducing a library that uses a single configuration annotation to automatically establish inter‑instance connections, manage message routing, and support custom selectors for targeted delivery.
This guide introduces Swoole, a high‑performance asynchronous PHP framework for IoT, and walks through installing the extension, building TCP and WebSocket servers, performing asynchronous file I/O, and leveraging coroutines with complete code examples.
This article shares the team’s practical experience and solutions for embedding H5 pages in mini‑program WebViews, covering platform differences, communication mechanisms, onShow handling, common pitfalls, login‑state synchronization, payment integration, and the use of WebSocket to achieve real‑time cross‑page updates.
This article explains how to solve the WebSocket message‑delivery problem in a micro‑service environment by introducing a lightweight library that uses a custom annotation to automatically forward messages between service instances, with detailed design, configuration, and code examples.
This article explains the challenges of using WebSocket in a micro‑service environment, introduces a load‑balancing library with annotation‑based configuration, and details its abstract design, connection management, message routing, and selector mechanisms for targeted and broadcast communication.
This guide explains how a web front‑end can communicate with IC cards and RFID tags by launching a local WebSocket service, using a desktop plug‑in to handle hardware read/write operations, and integrating the data with the server for vehicle and driver management.
This article introduces Javalin, a lightweight Java web framework that supports HTTP/2, WebSocket, and asynchronous requests, demonstrates a practical code example with routing, request validation, handlers, and deployment steps, and even solves a common port‑conflict issue on macOS.
Javalin is a lightweight Java web framework that supports WebSocket, HTTP/2, and asynchronous requests, offering simple configuration, route definitions, parameter validation, handlers, access management, and easy deployment via an embedded Jetty server, with examples and troubleshooting tips for common issues like port conflicts.
This article introduces the open‑source chatGPT-service backend and chatGPT-stream frontend, explains their WebSocket integration, provides Gitee mirrors, and offers step‑by‑step commands for cloning, configuring, Docker deployment, compilation, and testing the real‑time ChatGPT application.
This article compares short polling, long polling, WebSocket, and Server‑Sent Events, explaining their mechanisms, advantages, drawbacks, and appropriate use cases, and provides practical code examples for implementing each method in modern frontend development.
This article details the design, bandwidth optimization, and reliability strategies of a custom bullet‑chat system for Southeast Asian live streaming, covering background challenges, problem analysis, compression, request throttling, long‑polling versus WebSocket trade‑offs, and a short‑polling solution that successfully supported 700 k concurrent users.
This article describes the design, challenges, and optimization strategies of a custom live‑streaming danmaku system for Southeast Asian markets, covering bandwidth constraints, latency issues, long‑polling versus WebSocket approaches, service splitting, caching, and a ring‑buffer implementation that supported 700 k concurrent users during a major sales event.
This guide demonstrates how to use Java 11’s HttpClient to build a WebSocket client, implement a listener for various message events, and send both text and binary data, including a complete runnable example that showcases connection setup, message handling, and periodic sending.
This article presents a detailed case study of designing a high‑throughput danmu (bullet‑screen) system for Southeast Asian live streaming, analyzing bandwidth constraints, latency issues, and evaluating long‑polling, WebSocket, and short‑polling approaches, ultimately describing the chosen short‑polling solution, service partitioning, caching, and ring‑buffer techniques to achieve stable performance for millions of concurrent users.
Learn how the RFC 6455 WebSocket protocol works with Spring Boot 2.4.13, covering the HTTP upgrade handshake, server response, custom HandlerMapping, annotation‑driven routing, and a reactive chat handler implementation with code examples and deployment tips.
This article introduces the WebSocket protocol, explains its principles and differences from HTTP, outlines typical real‑time application scenarios, and provides a step‑by‑step guide with code examples for testing WebSocket interfaces using Python, including request/response formats and automated test scripts.
This tutorial walks through building a front‑end publishing platform that initiates Jenkins builds, uses dynamic routing, and leverages Socket.io to stream real‑time build logs to the browser, covering both front‑end Vue components and back‑end Node integration.
This article demonstrates how to build a real‑time device monitoring solution by combining a Vue.js front‑end that visualizes device status with a SpringBoot back‑end that uses WebSocket to push abnormal alerts instantly to the client, complete with code examples and deployment steps.
This article explains how to create a web‑based chat application similar to WeChat using Netty as the core server, WebSocket for real‑time communication, and Spring MVC for HTTP handling, covering architecture, required tools, core code, and deployment steps.
This article analyzes Feakin's approach to online collaborative diagram editing, covering communication protocols, data formats, the trade‑offs between centralized OT and decentralized CRDT algorithms, and the Rust‑based server and client implementation using Actix, WebSocket, and WebAssembly.
This article guides readers through the design and implementation of a high‑performance, scalable instant‑messaging (IM) system using Go, detailing WebSocket protocol fundamentals, server‑side architecture, authentication, message handling, code examples, and optimization strategies for production deployment.
This article explains the fundamentals of instant‑messaging, dives deep into the WebSocket protocol and its handshake, and provides a step‑by‑step guide with Go code to quickly build a high‑availability, extensible IM system that supports registration, login, single‑chat, group‑chat, file upload and optimization strategies.
This article walks through building a QR‑code based login system using Spring Boot, detailing database design, role analysis, required APIs, step‑by‑step implementation, and full Java and JavaScript code for generating QR codes, handling WebSocket communication, and confirming user authentication.
This article introduces a data‑collection SDK with a real‑time visualization feature, explains the shortcomings of traditional packet‑capture and log‑based methods, describes the underlying architecture—including a new SDK entry, encrypted reporting, WebSocket communication and Elasticsearch storage—and provides step‑by‑step usage instructions for developers.
This article demonstrates how to create a real-time device inspection monitoring system using WebSocket, with a Vue front-end that visualizes device status and a SpringBoot back-end that pushes updates, covering project setup, code examples, configuration, and testing steps.
This tutorial walks through creating a Netty‑based WebSocket server in Java, adding Maven dependencies, integrating it with a SpringBootApplication, implementing server and channel handlers, crafting a simple HTML client, and extending the setup to support URL parameters, complete with code examples and screenshots.
This article explains various web message‑push techniques—including short and long polling, iframe streaming, Server‑Sent Events, MQTT and WebSocket—detailing their principles, advantages, drawbacks, and providing complete Spring Boot and JavaScript code examples for real‑time notification badges.
This article explains how modern web IDEs implement an integrated terminal using xterm.js and node-pty, analyzes the performance bottlenecks caused by massive output and RPC contention, and presents a simple batching optimization inspired by Hyper that dramatically improves responsiveness.
This article explains several server‑side techniques for real‑time web message push—including short and long polling, hidden‑iframe streaming, Server‑Sent Events, MQTT, and WebSocket—provides their principles, advantages, drawbacks, and complete Spring Boot/Java code examples for each approach.
The article explains why a custom instant‑messaging SDK was built for a customer‑service web client, outlines its three‑layer architecture (WebSocket/gRPC network, RxJS‑driven data‑link, and application logic), and details reliability features such as ACKs, retries, deduplication, and ordering to improve performance, stability, and scalability.
This article demonstrates how to build a Netty‑based WebSocket server integrated with Spring Boot, covering Maven dependencies, server initialization, channel handlers, a simple HTML client, and extending the handler to parse URL query parameters for custom communication.
This article demonstrates how to build a QR‑code based login system using Spring Boot, MySQL, and WebSocket, covering database design, role definition, API creation, front‑end image handling, and real‑time authentication notification through server‑push messages.
This article explains how to solve cross‑server WebSocket communication in a distributed Java application by using a message queue (Redis or Kafka) to broadcast messages, storing user‑node mappings, and providing complete Spring configuration, code examples, and a demo page for end‑to‑end testing.
This article explores practical solutions for implementing a distributed WebSocket cluster in a Spring Cloud environment, detailing the challenges of session sharing, comparing Netty and Spring WebSocket approaches, and presenting two strategies—session broadcasting and consistent‑hashing—along with gateway configuration, load‑balancing, and code examples.
This article explains four ways to use WebSocket in Java—J2EE, Spring, SocketIO, and Netty—covering protocol basics, required dependencies, configuration code, and practical examples so developers can choose the most suitable approach for real‑time communication.
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 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.