This guide demonstrates how to integrate RocketMQ 4.8.0 into a Spring Boot 2.3.9 application, covering dependency setup, configuration, sending and receiving plain, ordered, clustered, broadcast, and transactional messages, with complete code examples and execution results.
This article explains the need for a messaging system, explores Kafka's core concepts, cluster architecture, performance optimizations like sequential disk writes and zero‑copy, and provides detailed guidance on sizing hardware, configuring producers and consumers, and managing a production Kafka deployment.
This article explains the fundamental message exchange architectures and routing patterns—including publish‑subscribe, fan‑out, unidirectional and bidirectional streaming, as well as unicast, broadcast, multicast, and anycast—illustrated with diagrams and practical examples for modern backend systems.
This article outlines a backend messaging center architecture that targets 10,000 messages per second inbound via RocketMQ, 1,000 messages per second outbound to third‑party platforms, and ensures 100% high availability using Spring Cloud Gateway, Kubernetes, Elasticsearch, and related technologies.
This article introduces RabbitMQ's core concepts, compares AMQP with JMS, outlines its key features, and demonstrates four working patterns—work queue, routing, publish/subscribe, and wildcard—through detailed Java producer and consumer code examples.
This article provides a comprehensive overview of message queues, explaining their purpose, usage scenarios, two communication models, and detailing Java Message Service (JMS) as well as popular MQ implementations such as RabbitMQ and Kafka, complete with diagrams and code examples.
This article explains the fundamental message exchange patterns—including publish‑subscribe, fan‑out, unidirectional and bidirectional streaming—as well as routing models such as unicast, broadcast, multicast, and anycast, illustrating each with common technology examples.
This document outlines the technical, business, and product goals, functional requirements, architecture diagrams, technology selections, and detailed design and operational plans for building a highly available messaging center capable of handling 10,000 messages per second upstream and 1,000 messages per second downstream.
Discover the most popular Java open‑source repositories on GitHub for May, including high‑performance API gateways, design‑pattern libraries, cloud‑native messaging platforms, multi‑language algorithm collections, data‑integration tools, and blockchain implementations, each with star counts and brief overviews.
This article introduces Apache Kafka, explains its publish‑subscribe and point‑to‑point models, outlines why it is used for decoupling and high‑availability, and provides a step‑by‑step Spring Boot integration guide with configuration, producer and consumer code samples.
This article explains the fundamental message exchange architectures—such as publish‑subscribe, fan‑out, unidirectional and bidirectional streaming, unicast, broadcast, multicast, and anycast—and how they are used in systems like Redis, Kafka, RabbitMQ, ZeroMQ and IBM MQ to simplify communication between architects and developers.
To handle exploding daily traffic, the team rebuilt the messaging platform with a unified API, concurrent consumption, MongoDB storage, and a priority scheme that uses separate Kafka topics and adjustable pull ratios, while employing a state‑machine‑driven thread pool, multi‑tier delay mechanisms, and MongoDB/Redis‑based fatigue control, delivering fast, traceable, hierarchical urgent delivery with visual metrics and content safety.
This article explains the fundamental messaging exchange architectures such as Pub‑Sub, Fanout, Unidirectional and Bidirectional streaming, and the routing patterns including Unicast, Broadcast, Multicast and Anycast, illustrating how they are used in systems like Redis, Kafka, RabbitMQ and IBM MQ to simplify communication between producers and consumers.
This article provides a step‑by‑step tutorial on installing Apache Pulsar with Docker, managing it via Pulsar Manager, and integrating it into a Spring Boot application using the Pulsar Java Spring Boot starter, complete with code examples and UI screenshots.
This article explains RabbitMQ's core messaging patterns—including simple, work queues, publish/subscribe, routing, topics, RPC, and publisher confirms—along with the four main exchange types, providing practical use‑case examples for each to help developers choose the appropriate pattern for their backend systems.
Over four years at Ele.me, the author chronicles the transformation of the order platform from a single‑machine Python monolith to a distributed, sharded, message‑driven architecture, detailing challenges in scaling, performance testing, fault injection, Redis usage, and service separation that shaped today’s robust backend.
This guide walks you through setting up RocketMQ Console 2.0 on a RocketMQ 4.8.0 cluster, configuring its properties, building and running the service, and testing message sending and receiving using a Spring Boot application, including topic creation tips.
This article visually breaks down Kafka’s core concepts—including producers, consumers, topics, partitions, consumer groups, and cluster architecture—explaining how messages flow, are stored, and replicated across partitions and nodes, while highlighting the role of ZooKeeper in managing metadata.
This article compares RabbitMQ, Kafka, and RocketMQ from a high‑availability perspective, explaining each system's deployment modes, replication mechanisms, and the trade‑offs between scalability and fault tolerance.
This article compares Redis list, Kafka, and Pulsar as messaging middleware, explaining their architectures, strengths, and weaknesses—including queue fundamentals, partitioning, cursor management, consumer groups, high‑availability mechanisms, storage strategies, and consumption models—to help readers choose the right solution for large‑scale systems.
This article explains internal service communication patterns, covering request/response and asynchronous messaging, their implementations, message formats, RPC and REST principles, service discovery methods, channel types, and key considerations for choosing a message‑queue component.
This article presents a Python script that shows how to programmatically send text, markdown, and image‑text (news) messages through an Enterprise WeChat robot, enabling automated test report notifications that incorporate phone numbers and group mentions.
This guide shows how to use Python to post text, markdown, and image‑text (news) messages to a WeChat Work webhook, covering required headers, payload structures, and example code for each message type.
This article explains Kafka's role as a decoupling message buffer, describes topics, partitions, replication, consumer groups, controller coordination with Zookeeper, and performance optimizations such as sequential writes, zero‑copy, log segmentation, and its reactor‑style network design.
The article chronicles Eleme’s four‑year journey of transforming its order platform—from the early Python‑based Zeus monolith through team formation, service decoupling, sharding, message broadcasting, testing automation, Redis and cache redesign, to virtual product handling and governance—highlighting practical challenges, decisions, and hard‑won engineering insights.
This article introduces seven RabbitMQ messaging patterns—Simple, Work Queues, Publish/Subscribe, Routing, Topics, RPC, and Publisher Confirms—explains their typical application scenarios, and provides complete Java code examples for each pattern along with a summary of the four exchange types.
A production RocketMQ cluster suffered a 10‑minute message‑send timeout after a broker’s memory failure caused a server reboot, and the post analyzes the routing registration, name‑server removal logic, client‑side timeout handling, root cause of name‑server “dead‑lock”, and proposes deployment and code‑level fixes to prevent recurrence.
This article outlines five Spring-based approaches for using Apache RocketMQ—including Spring Messaging, Spring Cloud Stream, Spring Cloud Bus, Spring Cloud Data Flow, and Spring Cloud Function—detailing each project's features, typical use cases, and how they fit into modern Java microservice architectures.
This article explores five integration approaches for using Apache RocketMQ within the Spring ecosystem, detailing each project's features, typical use cases, and how they complement Spring Boot, Spring Messaging, and Spring Cloud Stream for building robust, scalable microservices.
A Pulsar community expert investigated why MultiTopicsConsumerImpl delivered only a fraction of the expected throughput, identified lock contention and EventLoop overhead as the main culprits, applied lock‑removal and thread‑pool optimizations, and achieved nearly four‑fold performance gains.
This guide walks through the essential layers of a backend technology stack for startups, covering language choices, core components like DNS, load balancing, CDN, RPC frameworks, databases, messaging, logging, monitoring, configuration, deployment, and operational best‑practice processes.
The article details how Xianyu’s 2020 messaging failures—lost messages, wrong avatars, and order status errors—were traced to duplicate IDs, push‑logic mismatches, and client bugs, and solved by introducing global UUIDs, ACK‑based retries, hierarchical conversation models, hybrid storage caching, and real‑time monitoring, boosting delivery reliability above 99.9%.
This guide details how to set up a high‑availability RocketMQ cluster with two name servers and four brokers across two Linux hosts, covering directory preparation, configuration file edits, service startup commands, and verification of the deployment.
Enterprise integration, essential for delivering modern customer experiences, involves connecting diverse applications, data, and devices across distributed and cloud environments using messaging, application connectors, data streams, integration patterns, and APIs, with approaches evolving from point‑to‑point links to ESB and cloud‑native architectures.
This article explains RabbitMQ’s origins, core components, message publishing and consumption patterns, routing modes, persistence mechanisms, delivery guarantees, RPC support, clustering and mirrored‑queue designs, as well as its flow‑control strategy, providing a comprehensive overview for backend developers.
This article provides a detailed tutorial on integrating Kafka with Spring using Spring‑Kafka, covering simple setup, embedded Kafka testing, topic creation, message sending and receiving, transaction support, listener configurations, manual acknowledgment, error handling, retry and dead‑letter queues, and related code examples.
Apache RocketMQ 4.8.0 has been released, featuring extensive optimizations and bug fixes, with significant performance, functionality, and stability enhancements to the Raft‑based DLedger mode, including asynchronous pipeline processing, batch log replication, and various lock and cache improvements that boost throughput by multiple times.
This article compares RabbitMQ and Apache Kafka by examining their internal designs, messaging models, ordering guarantees, routing, timing, retention, fault‑tolerance, scalability, and consumer complexity, then provides concrete guidance on when to choose each technology for real‑world systems.
During JD.com's 11.11 shopping festival, engineers tackled billions of transactions by evolving a five‑year architecture roadmap, implementing robust messaging and delay queues, deploying smart NICs, optimizing storage, and leveraging AI‑driven traffic control, all while sharing practical lessons on monitoring, load testing, and fault‑tolerance.
This article examines Apache Pulsar, an open‑source messaging platform created by Yahoo, compares it with Kafka by outlining Kafka’s common pain points, highlights Pulsar’s multi‑tenant architecture, layered storage, built‑in functions, and security features, and discusses the trade‑offs of each solution.
This article details the architecture, protocol design, permission control, reliability mechanisms, and scaling strategies of a long‑connection gateway built with OpenResty, Kafka, and Redis, illustrating how to share persistent connections across multiple business services while ensuring high performance and fault tolerance.
This article explains how to use Spring's event‑driven mechanism to decouple business operations such as saving a product and sending notifications, showing step‑by‑step code for custom events, publishing, asynchronous listeners, and custom thread‑pool configuration to improve resilience and maintainability.
This article analyzes the challenges of tightly coupled microservices and presents practical decoupling techniques—including asynchronous messaging, event‑driven architecture, CQRS, local caching, and service refactoring—to improve resilience and availability in modern backend systems.
This article discusses how to reduce coupling between microservices by converting synchronous calls to asynchronous messaging, employing message middleware, event‑driven architecture, CQRS patterns, local caching, data landing, and refactoring techniques such as merging services, extracting common modules, and adjusting granularity.
This article walks through the background of RocketMQ, explains why an Operator is needed for cloud‑native deployments, and provides a complete, hands‑on tutorial for installing RocketMQ Operator via OperatorHub or manually, creating a RocketMQ cluster on Kubernetes, verifying it with producer/consumer examples, and cleaning up the resources.
This article explains the core purposes of message queues such as converting synchronous operations to asynchronous, decoupling services, and handling traffic spikes, then details RabbitMQ architecture, various exchange types (Direct, Topic, Fanout), provides Spring‑Boot code examples for producers and consumers, and discusses persistence, acknowledgment mechanisms, and best‑practice configurations for reliable messaging.
This article explains how Apache Pulsar’s layered architecture separates I/O modes, uses BookKeeper for durable storage, and leverages multi‑replica write quorums and hierarchical caches to provide efficient tail‑read, catch‑up read, and long‑term storage options such as S3, Azure and GCS.
This article introduces Redis Pub/Sub messaging, explains its purpose of decoupling publishers and subscribers, demonstrates command-line operations such as PUBLISH, SUBSCRIBE, PSUBSCRIBE, and provides a complete Java Spring Boot example using Jedis to publish and subscribe to channels.
Tellus, a user‑and‑item task system for Xianyu’s lightweight publishing, guides sellers to complete missing item details or adjust prices by decoupling task creation via MetaQ, storing billions of records in Table Store, and offering configurable, template‑based tasks that have doubled completion rates and accelerated feature rollout.
This article compares Apache Kafka and RabbitMQ, detailing their architectural differences, message handling models (pull vs push), performance characteristics, and ideal use cases, helping readers choose the appropriate messaging system for streaming, high‑throughput, or legacy protocol scenarios.
This article documents the supported features, deprecated services, and specific limitations of a range of MQTT brokers, providing a concise reference for developers to understand each broker's capabilities and constraints within IoT and backend messaging systems.
This article provides a comprehensive overview of Kafka, explaining how topics are divided into partitions, the roles of producers and consumers, consumer groups, broker responsibilities, offset management, data persistence, replication mechanisms, leader‑follower coordination, and the use of Zookeeper for metadata.
This guide demonstrates how to establish RabbitMQ connections using the Java client, covering minimal connection code, passive queue declaration, thread safety, consumer push/pull modes, custom thread pools, address lists, NIO support, automatic network recovery, and heartbeat configuration, with practical code examples.
This article explains the end‑to‑end process of a Kafka producer sending a message to a broker, covering client components, the internal cache storage model, partition selection logic, and the workings of the sender thread and network client.
This article compiles essential Kafka interview topics, covering cluster sizing, partition and replica configuration, offset management, topic creation, log structure, election mechanisms, partition assignment strategies, handling data backlog, exactly‑once semantics, idempotence, transactions, and performance tuning with practical command examples.
This article explains how RocketMQ’s network filter was merged into the CNCF Envoy project, details the message flow and stateful networking challenges within a service mesh, describes on‑demand CDS handling, and outlines future enhancements such as Pull support and broker‑side proxying.
This article recounts the four‑year journey of Ele.me's order platform, detailing the transition from a monolithic Zeus system to service‑oriented components, the challenges of sharding, message broadcasting, performance testing, Redis optimization, and the cultural practices that shaped a resilient backend architecture.
This article explains the fundamental differences between RabbitMQ and Apache Kafka, covering asynchronous messaging patterns, the internal architectures of both systems, their respective strengths and weaknesses, and guidance on choosing the appropriate solution for various scenarios.
This guide explains common use cases for delayed tasks, describes two RabbitMQ delayed‑queue implementations—including TTL with dead‑letter exchanges and the rabbitmq‑delayed‑message‑exchange plugin—provides detailed configuration steps, code examples in PHP, and demonstrates how to run and verify the solution.
This article details Yanxuan's evolution from a chaotic, multi‑queue setup to a unified, cloud‑native message center built on RocketMQ and Kafka, describing current services, scheduling mechanisms, publish‑subscribe implementation, and future plans for platformization and Kubernetes‑based resource management.
This guide introduces Signal Messenger as a privacy‑focused open‑source alternative to mainstream apps, outlines its key security features, and provides step‑by‑step commands to install the desktop client on Ubuntu/Linux.
This article provides a systematic tutorial on using Spring‑Kafka, covering basic setup, embedded Kafka for testing, topic creation methods, message sending with KafkaTemplate, transactional messaging, request‑reply patterns, advanced @KafkaListener configurations, manual acknowledgment, listener lifecycle control, SendTo forwarding, and retry with dead‑letter queues, all illustrated with complete code examples.
This article provides a thorough tutorial on using Spring‑Kafka, covering basic Maven setup, producer and consumer code, embedded Kafka for testing, programmatic topic creation, synchronous and asynchronous message sending, transaction handling, request‑reply patterns, advanced @KafkaListener options, manual acknowledgments, lifecycle control, message forwarding with @SendTo, and retry with dead‑letter queues.
This article explains how microservices, unlike monolithic applications, rely on inter‑process communication mechanisms, describes various interaction styles, API definition and evolution, handling partial failures, and compares synchronous (REST, Thrift) and asynchronous (messaging) IPC technologies.
The article details the step‑by‑step architectural evolution of Mafengwo's instant‑messaging platform—from an initial PHP‑based monolith, through polling optimizations with OpenResty, to a Go‑implemented, micro‑service‑oriented design that improves scalability, reliability, and multi‑device synchronization.
The article gives a thorough overview of Apache Kafka, explaining its core concepts, architecture, deployment steps, monitoring tools, and offset management, including broker and topic structures, producer/consumer APIs, replication, leader election, consumer groups, offset committing, and practical configuration and troubleshooting guidance.
This article explains what RabbitMQ is, why it is used, typical application scenarios, how to ensure reliable message publishing and consumption, the roles of sender and receiver acknowledgments, routing mechanisms, clustering options, advantages, drawbacks, and provides interview‑style Q&A with a keyword to obtain full answers.
This article introduces Apache Pulsar, a cloud‑native pub/sub messaging platform that solves traditional messaging system limitations with a layered architecture, offering independent scaling, multi‑tenant isolation, cross‑region replication, zero rebalancing, unified queue‑and‑stream models, and built‑in functions and proxy support.
Learn how to use Python, wxpy, and a timer to automatically fetch a daily quote and send personalized good‑morning or good‑night messages to a WeChat contact, complete with code examples and deployment tips.
This article provides a comprehensive overview of the MQTT CONNECT packet, covering its fixed and variable header structures, protocol name, level, flags, keep‑alive settings, session handling, will message behavior, payload composition, and the server's validation and response process.
This guide explains why using identical @Input and @Output channel names in Spring Cloud Stream causes bean definition conflicts, and shows how to rename channels and configure them to share the same destination topic so a microservice can safely produce and consume its own messages.
This article provides a comprehensive tutorial on installing ZeroMQ, explains its basic socket types and messaging patterns such as PUB‑SUB, REQ‑REP, and PUSH‑PULL, and offers practical notes, code snippets, and configuration tips for effective use in backend applications.
This article explains how Java‑based microservices can keep data handling manageable by using domain‑driven design, separate data stores, hybrid persistence, event‑driven communication, JPA, EJB, Bean Validation, CDI, and various messaging protocols to achieve consistency and scalability.
The article describes the layered front‑end architecture of 58 MicroChat, covering its network, SDK, UI, integration, storage, security, polyfill, and quality‑monitoring modules, as well as the message center design, cross‑platform compatibility strategies, and ongoing quality‑monitoring practices.
This article introduces the fundamentals of message middleware, explains its key application scenarios such as asynchronous processing, system decoupling, flow control, and distributed transaction consistency, details the three transmission modes (point‑to‑point, publish/subscribe, request‑reply), and provides a step‑by‑step ActiveMQ quick‑start guide with Spring Boot integration and complete Java code examples.
This article explains how to use RabbitMQ to build Remote Procedure Call (RPC) mechanisms and delayed message queues, detailing the required exchanges, correlation IDs, callback queues, and providing practical Node.js code examples for both client and server sides.
This article introduces RabbitMQ as an AMQP‑based message broker, explains its fundamental components such as producers, consumers, exchanges, queues, bindings, connections and channels, and details the four exchange types, providing a solid foundation for backend developers to start using RabbitMQ in Node.js.
This step‑by‑step guide shows how to set up a RabbitMQ server, create a Spring Boot project with Gradle or Maven, define a message receiver, configure queues, exchanges and bindings, and send and receive text messages using RabbitTemplate and a CommandLineRunner.
Apache RocketMQ, Alibaba's high‑performance distributed messaging middleware, has officially graduated to an Apache Top‑Level Project, highlighting its robust features, broad ecosystem adoption across e‑commerce, IoT, finance and big‑data, and Alibaba's strong commitment to open‑source leadership.
This article presents a comprehensive Java backend engineer learning roadmap, outlining essential skills from version control and Maven to core Java, frameworks, system and JVM performance tuning, messaging middleware, OAuth, Redis, and data processing, accompanied by recommended books and online resources for each topic.
This guide walks you through setting up Kafka and Zookeeper, adding Spring Integration dependencies, configuring application.yml, creating producer and consumer configurations with @Configuration and @EnableKafka, implementing a @KafkaListener, and testing the integration via a Spring MVC endpoint, while highlighting common pitfalls.
The article examines why Go is well‑suited for high‑concurrency, complex communication distributed systems like the 360 message‑push platform, detailing its performance, architecture, challenges, optimization techniques, and operational monitoring compared with traditional C implementations.
This article explains ESB fundamentals such as subjectId, clientId, and key, describes how to configure test environments with topic prefixes, and provides detailed Telnet commands (count‑sub, list‑sub, list‑sender) plus Q&A for diagnosing message flow issues.
Taobao’s Open Platform sustains hundreds of billions of daily API calls and messages by employing a pipeline‑based high‑performance API gateway with multi‑level caching, asynchronous processing, granular traffic control, a highly reliable push‑pull messaging system, and a zero‑loss data‑sync service that dynamically balances resources during massive traffic spikes.
The conversation covers practical challenges and solutions for distributed transactions, evaluates RPC frameworks like Thrift, Dubbo, and gRPC, discusses session replay attack mitigations, and explores reliable messaging patterns using queues and pub/sub systems such as RabbitMQ and Kafka.
Distributed queue programming treats a queue as a fundamental, cross‑process abstraction, guiding developers to select synchronous or asynchronous, decoupled, persistent messaging solutions and offering four core models—point‑to‑point, producer‑consumer, publish‑subscribe, and MVC—while the article illustrates real‑world designs for billing, cache updates, and ticket processing.
The article examines various messaging patterns—Message Channel, Publisher‑Subscriber, Message Router, and others—explaining their principles, advantages, and implementation details, and illustrates their use in enterprise distributed architectures through concrete code examples and case studies such as CIMS and a medical system.
This article details the design and implementation of 58’s real‑time messaging platform, covering its business background, overall architecture, protocol design for extensibility and debugging, and solutions for fast TCP reconnection to ensure stable, high‑throughput delivery for intra‑city freight services.
This article details the architectural evolution of Kuaidi Dache from 2013‑2014, covering LBS bottlenecks, MongoDB scaling, long‑connection stability, distributed system refactoring, a wireless open platform, real‑time monitoring with Storm and HBase, and a data‑center built on sharding and synchronization.
The article details Weibo's journey in building a multi‑data‑center active‑active architecture, covering its evolution, technical challenges such as latency and data synchronization, the adopted MCQ‑based messaging solution, operational best practices, and future directions for high‑availability deployments.
The article explains the publish‑subscribe (pub/sub) messaging model, its time, space, and synchronization decoupling features, typical real‑time scenarios such as chat and log processing, and details how Redis implements pub/sub through channels and pattern subscriptions, including command syntax and internal data structures.
The article details Uber senior engineer Zhao Lei’s presentation on building a highly available messaging platform, covering single‑point failure mitigation, sharding approaches, large‑scale outage handling, cross‑region failover, and the practical engineering practices and protocols used to keep billions of users online.
This article explains the Pull mode of Pushlets, detailing its protocol, server‑side session management, client interactions, key configuration parameters, and the encapsulated Channel API that enables long‑connection message pushing for browsers and Java clients.
The article details Weibo's evolution toward multi‑active cross‑datacenter deployment, describing initial motivations, early synchronization attempts, the eventual MCQ‑based messaging solution, operational challenges such as latency and data consistency, and best‑practice recommendations for large‑scale distributed systems.
