Tagged articles
Publish‑Subscribe
31 articles · Page 1 of 1
The article analyzes common pitfalls of Spring Event—such as publishing during shutdown or early startup, unsuitability for strong‑consistency use cases, and the need for graceful shutdown, idempotent listeners, and extra reliability measures—while comparing it with message‑queue solutions.
IdempotencyPublish‑SubscribeSpring
0 likes · 12 min read

The article explains the Observer pattern by first showing the problems of hard‑coding post‑payment actions, then detailing how defining a subject, observer interface, and concrete observers decouples the system, discusses push vs pull notification models, and illustrates real‑world uses in Spring events, GUI listeners, and message queues.
DecouplingJavaObserver Pattern
0 likes · 14 min read


liandkJul 17, 2026 · Fundamentals
This article introduces the Observer pattern, explains its purpose of decoupling publishers and subscribers, walks through a complete Java implementation with an official‑account subscription example, lists typical business scenarios, compares it with the Mediator pattern, and outlines its advantages and pitfalls.
DecouplingJavaObserver Pattern
0 likes · 6 min read

This guide explains the fanout (publish/subscribe) pattern in RabbitMQ, compares it with other exchange types, clarifies common misconceptions, and provides a step‑by‑step Spring Boot implementation—including configuration, producer, multiple consumers, testing, and best‑practice recommendations.
Message BroadcastingPublish‑SubscribeRabbitMQ
0 likes · 10 min read

This article explains the concept of an Event Bus, when to apply it in frontend projects, provides a full JavaScript implementation, demonstrates its use with a login scenario, and outlines best practices and pitfalls for maintaining clean, decoupled code.
DecouplingEvent BusJavaScript
0 likes · 11 min read

This article explains the lightweight publish/subscribe MQTT protocol, its origin, key features, usage scenarios, differences from traditional message queues, topic structures and wildcards, as well as practical client tools like Mosquitto and MQTTX with configuration examples.
IoTMQTTMessage Broker
0 likes · 15 min read

This article shares hard‑won lessons from production incidents and provides practical guidelines—graceful shutdown, proper startup timing, suitable business scenarios, reliability patterns, and idempotent handling—to use Spring Event safely and effectively in Java backend systems.
BackendEventIdempotence
0 likes · 12 min read

This article explains MQTT’s lightweight publish‑subscribe protocol, its architecture, key features, QoS levels, typical IoT use cases, and why it’s preferred over HTTP for low‑bandwidth, low‑power applications, including examples from agriculture, industrial automation, transportation, and even social messaging platforms like Facebook Messenger.
IoTMQTTMessaging Protocol
0 likes · 12 min read

This article explains how Spring Event provides a publish‑subscribe mechanism to decouple Spring components, details its default synchronous behavior, shows how to make listeners asynchronous, demonstrates ordering and error handling, compares it with message‑queue solutions, and offers practical guidelines for safe usage.
DecouplingPublish‑SubscribeSpring
0 likes · 22 min read

This article explains the Observer and Publish‑Subscribe design patterns, compares their concepts and implementations, and provides ten practical Python code examples ranging from simple event notification to distributed messaging with libraries such as pubsub, redis, asyncio, Flask, threading, ZeroMQ, and PySide2.
Observer PatternPublish‑Subscribeevent handling
0 likes · 11 min read

This article explains the Observer design pattern, its intent, real‑world analogies, advantages and drawbacks, and provides a complete JavaScript example with prototype‑based code to illustrate how publishers and subscribers interact in an event‑driven system.
Observer PatternPublish‑Subscribedesign patterns
0 likes · 12 min read

This article explains the concepts, differences, and implementation approaches of the Observer and Publish‑Subscribe design patterns, and provides ten practical Python code examples covering GUI, networking, asynchronous, and distributed scenarios.
Asynchronous ProgrammingObserver PatternPublish‑Subscribe
0 likes · 11 min read

MQTT is a lightweight, publish/subscribe messaging protocol ideal for IoT and mobile environments, offering low bandwidth usage, reliability, and TLS/SSL security, and the article provides a detailed PHP example demonstrating connection, subscription, publishing, message processing, and graceful disconnection.
IoTMQTTPHP
0 likes · 4 min read

This article explains how to design and implement a basic task system—covering task configuration, display, progress tracking, and reward collection—while using Kafka for decoupling services and a publish/subscribe event layer to keep task logic independent of event sources.
KafkaPublish‑SubscribeTask System
0 likes · 8 min read

Learn how to effectively use React Context for state management, avoid props drilling, and eliminate redundant re‑renders by implementing a custom publish‑subscribe store, selector hooks, and performance optimizations similar to libraries like zustand.
ContextFrontend DevelopmentPublish‑Subscribe
0 likes · 11 min read

This article explains the Observer (publish‑subscribe) pattern, illustrates it with a humorous dialogue, provides complete Go interface and struct implementations for subjects and observers, shows sample client code and output, and discusses practical refactoring using the pattern for configuration changes.
Design PatternGoObserver Pattern
0 likes · 8 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 explains the Observer pattern, compares it with the Publish‑Subscribe model, showcases Java's built‑in Observable and Observer classes, provides complete code examples, and discusses practical considerations such as memory leaks and performance optimizations.
JDKJavaObserver Pattern
0 likes · 10 min read

This article explains how Kafka can be used for data ingestion and event distribution by illustrating production‑consumer and publish‑subscribe models, describing core concepts such as topics, partitions and consumer groups, and offering practical design options for handling different event scenarios.
Data IngestionEvent DistributionKafka
0 likes · 9 min read

Kafka is an Apache‑hosted distributed streaming platform that provides high‑throughput, durable, publish‑subscribe messaging, originally developed by LinkedIn; this article explains its core concepts, message system classifications, architecture components, APIs, replication, consumer groups, and guarantees, comparing it with other messaging solutions.
KafkaPublish‑Subscribebig data
0 likes · 17 min read

MQTT and CoAP are lightweight IoT communication protocols with distinct architectures—MQTT uses a publish/subscribe model ideal for WAN scenarios and bandwidth‑constrained devices, while CoAP follows a request/response pattern suited for local networks and HTTP compatibility, and the article explains their differences and appropriate use cases.
CoAPIoT protocolsMQTT
0 likes · 6 min read

Zhihu’s infrastructure team designed a high‑performance, scalable long‑connection gateway that decouples business logic via publish‑subscribe, leverages OpenResty, Kafka, and Redis, implements fine‑grained ACL, sliding‑window flow control, and ensures message reliability and horizontal scalability for millions of concurrent devices.
KafkaLong ConnectionMessage Reliability
0 likes · 15 min read

This article explains how modern message middleware works by describing the two primary communication styles—message queuing and publish‑subscribe—illustrating each with examples, comparing their characteristics, and listing common middleware products to help developers choose the appropriate solution for their backend systems.
Message BrokerMessage QueuePublish‑Subscribe
0 likes · 5 min read

This article explains the motivations behind using message‑queue middleware, outlines its benefits such as decoupling, asynchronous processing and peak‑shaving, describes point‑to‑point and publish‑subscribe communication models, and provides a detailed overview of Kafka’s architecture, terminology, data flow, storage strategy, and consumer group mechanics.
BackendKafkaPublish‑Subscribe
0 likes · 15 min read

MQTT is a lightweight, open‑source publish/subscribe protocol that powers the IoT’s global nervous system by delivering small‑header messages over TCP/IP with configurable QoS, low bandwidth, and optional TLS security, making it ideal for battery‑constrained devices, scalable deployments, and real‑time applications such as home monitoring.
IoTMQTTMessaging Protocol
0 likes · 10 min read


JD TechApr 2, 2018 · Backend Development
This article introduces the MQTT protocol, outlines its key characteristics, explains the challenges it poses for IoT messaging, and details how JMQ addresses these challenges through a layered proxy‑broker architecture, subscription management, quality‑of‑service handling, and real‑world JD deployment.
IoTJMQMQTT
0 likes · 8 min read

This article explains how to apply Domain‑Driven Design's domain events to separate reply handling from push notification logic, discusses the shortcomings of embedding side‑effects directly, compares Spring and Guava event mechanisms, and provides a custom Guava‑based publisher implementation with synchronous and asynchronous buses.
EventBusGuavaJava
0 likes · 8 min read

This article explains the producer‑consumer and publish‑subscribe messaging patterns, introduces RabbitMQ’s core concepts such as exchanges, queues, routing keys, and reliability mechanisms, and demonstrates how to apply these patterns to data ingestion and event distribution scenarios with practical diagrams.
Message QueueMessaging PatternsProducer-Consumer
0 likes · 9 min read

This article explains Kafka's core concepts and compares producer‑consumer and publish‑subscribe models, illustrating how to apply each pattern for data ingestion and event distribution in distributed backend systems, and offers practical design alternatives when Kafka’s native capabilities fall short.
KafkaMessage QueueProducer-Consumer
0 likes · 10 min read

MQTT, a lightweight publish/subscribe protocol designed for low‑bandwidth, unstable networks, has evolved since its 1999 IBM inception into an open‑standard IoT messaging solution, offering reliable delivery, three QoS levels, persistent sessions, and minimal overhead, addressing key IoT connectivity challenges.
IoTLow BandwidthMQTT
0 likes · 4 min read

This article explains how EventBus replaces explicit publisher‑subscriber registration for in‑process event dispatch in Java, provides a concise code example, a one‑minute migration guide, details on listeners and producers, a terminology table, and a comprehensive FAQ covering usage, design decisions, and testing considerations.
AnnotationsEventBusIn-Process
0 likes · 11 min read
