Tagged articles
Real-time Messaging
37 articles · Page 1 of 1
This article explains Spring Boot's WebSocket and STOMP integration, covering connection establishment, message routing architecture, broker types, destination prefixes, and practical code examples for real-time features like chat and notifications.
Message BrokerReal-time MessagingSTOMP
0 likes · 14 min read

The article analyzes the limitations of native WebSocket for large‑scale, low‑bandwidth, and unreliable‑network scenarios and demonstrates how MQTT, especially with EMQX, provides built‑in message routing, QoS levels, offline storage, and effortless clustering, reducing development and operational overhead.
EMQXIoTMQTT
0 likes · 16 min read

This article recounts the migration from a simple HTTP polling approach to an MQTT‑based real‑time communication architecture, detailing the motivations, technical comparisons, implementation steps, performance gains, operational challenges, and future directions for scalable event‑driven systems.
MQTTReal-time Messagingbackend architecture
0 likes · 8 min read

This guide explains how RabbitMQ with MQTT provides lighter protocol overhead, built‑in QoS, reliable offline messaging and powerful topic routing, offering a more stable and scalable alternative to WebSocket for mobile, IoT and instant‑messaging scenarios, with full code examples for both front‑end and back‑end.
IoTMQTTRabbitMQ
0 likes · 9 min read

This guide walks through creating a full‑stack WebSocket solution using Netty for the server, Spring Boot for lifecycle management, Redis for token validation, and Vue2 on the client, covering configuration, token handling, heartbeat detection, channel management, and message broadcasting with complete code examples.
NettyReal-time MessagingVue2
0 likes · 37 min read

This guide demonstrates how to integrate WebSocket and STOMP into a Spring Boot application, covering setup, core modules, code examples for broadcasting and targeted messages, and a cluster mode using Redis for distributed session forwarding.
ClusterReal-time MessagingSTOMP
0 likes · 6 min read

This article explains WebSocket fundamentals, compares pull and push models, details the WebSocket handshake flow, presents a complete Go server and client implementation, analyzes performance bottlenecks of a million‑user bullet‑screen system, and proposes concrete optimizations such as packet merging, lock granularity, JSON encoding reduction, and HTTP/2‑based clustering.
GoReal-time Messagingscalable architecture
0 likes · 13 min read

This article explains how to design a live‑streaming danmaku (bullet‑screen) feature by using Redis Zset as the underlying data structure, limiting the list to the latest ten messages, and handling retrieval via polling APIs or WebSocket, with Kafka for message buffering and a distributed lock to avoid ordering issues.
KafkaReal-time MessagingWebSocket
0 likes · 8 min read

This article analyzes the challenges of real-time, reliability, and message ordering in a customer service instant messaging system and presents solutions such as WebSocket adoption, ACK-based reliability, heartbeat mechanisms, and a structured message protocol to ensure efficient and stable communication.
ACK mechanismIM SystemReal-time Messaging
0 likes · 11 min read

This article details Baidu’s internally built unified long‑connection service in Go, covering its motivation, architecture, functional implementation, performance optimizations, multi‑business support, deployment strategy, and lessons learned for delivering secure, high‑concurrency, low‑latency real‑time connectivity across mobile applications.
Long ConnectionReal-time Messagingbackend architecture
0 likes · 21 min read

This guide explains how to restrict access to Pusher channels using private channels, covering authentication flow, required server‑side PHP setup, client‑side JavaScript integration, and step‑by‑step code examples for publishing and receiving secure real‑time messages.
JavaScriptPHPPrivate Channels
0 likes · 5 min read

This article explains how to set up WebSocket communication in Spring Boot 2.7.12, covering the protocol basics, handshake process, custom HandlerMapping, annotation-driven routing, and a reactive WebFlux handler with code examples, plus deployment considerations behind reverse proxies.
JavaReal-time MessagingWebFlux
0 likes · 7 min read

This guide explains WebSocket fundamentals, shows the HTTP handshake process, provides JavaScript client examples, and walks through a full server‑side implementation using the high‑performance PHP Webman framework with the GatewayWorker plugin, including installation, configuration, and advanced message handling.
GatewayWorkerPHPReal-time Messaging
0 likes · 8 min read

An in‑depth Spring Boot 3 tutorial explains WebSocket fundamentals, the HTTP upgrade handshake, core Spring APIs, configuration options, origin handling, and testing steps, enabling developers to build real‑time, bidirectional communication services for web applications.
JavaReal-time MessagingWebSocket
0 likes · 10 min read

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.
Long PollingReal-time MessagingWebSocket
0 likes · 12 min read

This tutorial shows how to combine Spring Boot and Netty‑SocketIO to build a simple real‑time push system with broadcast, group and single‑user messaging, providing Maven dependencies, configuration files, Java classes, a REST controller and two HTML client pages for demonstration.
Real-time MessagingSocketIOspring-boot
0 likes · 16 min read

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.
JavaReal-time MessagingWebSocket
0 likes · 12 min read

This article demonstrates how to build a real‑time messaging system for a space‑station scenario using RabbitMQ and Spring Boot, covering configuration of direct and fanout exchanges, scheduling updates, one‑to‑one chat, and broadcast messaging with complete Java code examples.
JavaRabbitMQReal-time Messaging
0 likes · 14 min read

RTMS (Real Time Message Service) is a frame‑synchronization‑based real‑time communication solution that offloads logic from the server, uses in‑memory processing, and employs decentralized, non‑persistent, publish‑subscribe routing to dramatically improve latency, scalability, and interactivity for high‑frequency multi‑user scenarios.
Publish‑SubscribeRTMSReal-time Messaging
0 likes · 10 min read

This article outlines essential techniques for building large‑scale backend systems, covering product analysis, microservice architecture principles, the evolution of real‑time push technologies, request idempotency strategies, and comprehensive service governance challenges and solutions.
IdempotencyReal-time MessagingService Governance
0 likes · 5 min read

The article outlines the challenges of real‑time messaging in live‑streaming education, presents a multi‑stage backend architecture—including AccessServer, MessageServer, and specialized services—along with caching, clustering, and future enhancements such as connection migration and QUIC to achieve high reliability, low latency, and massive concurrency.
Real-time Messagingbackend architecturedistributed systems
0 likes · 12 min read

This article explores core concepts, ID design, read/write fan-out, push‑pull models, and industry implementations for large‑scale instant messaging systems, discussing trade‑offs in message diffusion, unique identifier strategies, real‑time delivery, ordering, unread counts, multi‑device sync, and deployment considerations.
Real-time Messagingid-generationinstant messaging
0 likes · 23 min read

Baidu’s live‑streaming message service evolved from a basic group‑chat model to a scalable multicast architecture that delivers up to a million concurrent users per room with sub‑second latency, using message aggregation, compression, and priority channels to manage QPS, bandwidth, and reliable gift delivery.
Real-time Messagingarchitecturehigh concurrency
0 likes · 28 min read

This article analyzes Baidu's live‑stream messaging system, compares it with ordinary group chat, identifies scalability challenges, proposes a multicast (mcast) architecture, evaluates performance, bandwidth, and client impact, and outlines further enhancements such as historical and gift messages.
Real-time Messagingbackend architecturelive streaming
0 likes · 29 min read

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.
JavaReal-time MessagingWebSocket
0 likes · 12 min read

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.
JavaReal-time MessagingSTOMP
0 likes · 21 min read

The article presents a flexible fatigue‑control mechanism for Omega’s real‑time user‑reach system that replaces fixed windows with dynamic, user‑scene‑business dimensions and a minimum interval, eliminating duplicate daily messages, dispersing delivery times, maintaining stable 6000‑QPS performance, and paving the way for reusable components and recommendation integration.
Real-time MessagingUser Experiencebackend design
0 likes · 7 min read

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.
Real-time MessagingSTOMPWebSocket
0 likes · 12 min read

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.
Real-time MessagingWebSocketmessage deduplication
0 likes · 17 min read

Meipai’s live‑stream bullet‑comment platform progressed from an initial HTTP‑polling design supporting one million users, through a high‑availability dual‑room architecture, to a scalable long‑connection system with gRPC routing, dynamic degradation, and caching, solving message ordering, Redis bottlenecks, and ensuring seamless user experience.
High AvailabilityLong ConnectionReal-time Messaging
0 likes · 11 min read

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.
Node.jsReal-time MessagingSocket.IO
0 likes · 9 min read

This article dissects the design of 58 Daojia’s universal real‑time messaging platform, detailing the challenges of end‑to‑cloud, cloud‑to‑end, and end‑to‑end communication, the shortcomings of traditional HTTP and push solutions, and the optimized TCP, message‑bus, RPC, and protocol extensions that achieve scalability, reliability, and cross‑account chat.
Message QueueProtocol DesignReal-time Messaging
0 likes · 12 min read

The article details Meizu's large‑scale real‑time push architecture, covering system scale, four‑layer design, power‑consumption optimizations, network reliability challenges, massive connection handling, load‑balancing strategies, strict monitoring, and gray‑release practices to ensure high performance and stability.
Gray ReleaseReal-time Messagingbackend scalability
0 likes · 12 min read

The article details Meizu's large‑scale real‑time push architecture, covering system scale, four‑layer design, mobile power‑saving optimizations, network instability handling, massive connection techniques, load‑balancing strategies, comprehensive monitoring, and gray‑release deployment practices.
Gray ReleaseReal-time Messaginghigh concurrency
0 likes · 11 min read


21CTODec 9, 2015 · Backend Development
This article explains how Worktile’s team collaboration platform combines a single‑page AngularJS front‑end with Node.js, Redis, MongoDB, and ejabberd XMPP services to achieve cross‑platform access, native‑like interactions, and high‑performance real‑time updates for over 100,000 teams.
AngularJSMEAN stackNode.js
0 likes · 10 min read

Worktile’s architecture combines a single‑page AngularJS front‑end with a Node.js/Express backend, leveraging MongoDB, Redis, and ejabberd for real‑time messaging, illustrating how SPA design, modular services, and long‑connection techniques enable a stable, high‑performance team collaboration platform.
AngularJSMongoDBNode.js
0 likes · 11 min read

The article explains how Worktile achieves cross‑platform web access, native‑like SPA experience, real‑time messaging, and service stability by using AngularJS for the frontend, Node.js, Redis, MongoDB, and ejabberd/XMPP for backend and push services.
AngularJSMongoDBNode.js
0 likes · 10 min read
