Tagged articles
Decoupling
74 articles · Page 1 of 1
The article explains that dependency injection is just one inversion-of-control pattern; Java adopts DI due to its object-oriented purity and reflection-enabled runtime frameworks, while Go and C++ prefer lighter callbacks, closures, and compile-time abstraction via headers, making DI frameworks less necessary despite the pattern's universal value for decoupling and testing.
C++DecouplingGo
0 likes · 6 min read

This tutorial explains the Observer design pattern with a Java implementation using an e-commerce order system where payment triggers logistics and procurement updates, demonstrating loose coupling between subject and observers.
Behavioral PatternDecouplingDesign Patterns
0 likes · 7 min read

This article explains the Chain of Responsibility design pattern with a practical Java example of a leave approval workflow, showing how it decouples request senders from receivers and enables flexible, extensible handling through a chain of handlers.
Chain of ResponsibilityDecouplingDesign Patterns
0 likes · 7 min read

This article explains Java Semaphore's core decoupling property—where any thread can acquire or release permits—contrasting it with ReentrantLock's thread-owned locking, demonstrates with Java 17 code examples, and shows real-world rate-limiting applications in Sentinel, Dubbo, and Tomcat.
ConcurrencyDecouplingJava
0 likes · 8 min read

This article explains how event sourcing replaces synchronous call chains with domain events to decouple microservices, detailing the four core event elements, a three-step publish-subscribe flow using Spring Cloud Stream, and a practical template for implementation.
DecouplingEvent StormingMicroservices
0 likes · 6 min read

The article distinguishes real process integration from mere interface wiring, outlining four value layers (eliminating manual data entry, single source of truth, event-driven automation, end-to-end visibility), four architectural steps (bus topology, three-level decoupling, contract-first design, process orchestration), and business-centric success metrics.
BPMNDecouplingESB
0 likes · 14 min read

The article analyzes the structural flaw of tightly coupling session, harness, and sandbox in a single container, proposes separating them into three independent interfaces, and demonstrates how this redesign improves fault tolerance, security, and reduces Time‑to‑First‑Token latency by about 60% while enabling flexible, scalable agent deployments.
Agent ArchitectureDecouplingHarness
0 likes · 11 min read

Anthropic engineers discovered that tightly coupling an AI agent's reasoning core and execution environment caused failures and latency, so they redesigned Claude Harness to separate the brain from the hands, introduce an append‑only event log, and achieve up to 60% lower startup latency while improving security and scalability.
AI agentsClaudeDecoupling
0 likes · 12 min read

The article explains how the Command pattern encapsulates a request as an object, enabling storage, queuing, undo/redo, and decoupling between request senders and executors, with concrete Java examples and guidance on when the pattern is appropriate.
DecouplingDesign PatternsInvoker
0 likes · 13 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

The article explains how using a message queue as a buffer, asynchronous processor, and decoupling layer enables flash‑sale systems to handle tens of thousands of orders per second, reducing database overload, cutting response time from 500 ms to 50 ms, and preventing cascade failures.
Asynchronous ProcessingDecouplingSystem Design
0 likes · 5 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.
DecouplingDesign PatternsJava
0 likes · 6 min read

The article explains how using a message queue such as Kafka lets an order service return quickly by handling non‑critical tasks like SMS, points, and logging asynchronously, thereby improving latency, decoupling services, and smoothing traffic spikes while also covering Kafka's core concepts and trade‑offs.
Asynchronous ProcessingDecouplingKafka
0 likes · 11 min read


liandkJun 14, 2026 · Fundamentals
This article explains the Factory Method design pattern, illustrates its core principle of separating object creation from business logic, presents everyday analogies, and provides a complete Java implementation with abstract product, concrete products, abstract factory, concrete factories, and a test driver.
DecouplingDesign PatternJava
0 likes · 4 min read

This article explores microservices architecture beyond basic decomposition, covering decoupling principles, service boundary identification, governance pillars (observability, traffic control), distributed transaction patterns, data management strategies, API design best practices, infrastructure choices (Kubernetes, Service Mesh), organizational alignment via Conway's Law, and when to avoid microservices.
CQRSConway's LawDecoupling
0 likes · 12 min read

The article analyses why message queues are not a cure‑all, using real e‑commerce and finance incidents to dissect the three core benefits—decoupling, asynchronous processing, and peak‑shaving—while exposing production challenges such as loss, duplication, ordering, dead‑letter handling, and end‑to‑end consistency, and offering concrete Java code, benchmark tables and a practical MQ selection guide.
DecouplingKafkaPeak Shaving
0 likes · 32 min read

The article explains how the COLA‑DDD layered architecture merges Clean Object‑Oriented and Layered Architecture with Domain‑Driven Design to eliminate large‑muddy code, improve iteration speed, enhance scalability, and provide clear layer boundaries, CQRS, event‑driven processing, and low‑risk technical evolution.
COLADDDDecoupling
0 likes · 11 min read

The article explains how replacing tightly‑coupled controller‑service calls with an event‑driven signal network in PHP improves decoupling, extensibility, testability, and asynchronous processing, using Symfony's EventDispatcher and Laravel's Events as concrete examples.
BackendDecouplingLaravel
0 likes · 7 min read

Custom events let developers decouple UI components by broadcasting semantic actions, offering a flexible alternative to direct calls or global state, and improving maintainability, testability, and performance, with best‑practice naming, payload design, bubbling, and cancelable options explained alongside practical JavaScript examples.
Decouplingcustom eventsevent-driven architecture
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 Chain of Responsibility design pattern, its core concepts, typical use‑cases such as approval workflows and logging, provides step‑by‑step Java examples—including a basic leave‑request system and an advanced builder‑based chain—covers real‑world framework integrations, compares it with other patterns, and lists practical pros, cons, and best‑practice tips.
Chain of ResponsibilityDecouplingDesign Pattern
0 likes · 10 min read

This article explains why RPC should be used when callers need immediate results, why forcing MQ for request‑response adds complexity and risk, and how combining RPC for result‑sensitive flows with MQ for fire‑and‑forget events achieves clean architectural decoupling.
DecouplingDesign PatternsMicroservices
0 likes · 6 min read


ITPUBJun 14, 2025 · Backend Development
The article explains why RPC should be used when callers need immediate results, while MQ is preferable for fire‑and‑forget notifications, illustrating the trade‑offs with code examples, common pitfalls of misusing each method, and practical steps to achieve physical and logical decoupling in backend systems.
DecouplingMicroservicesRPC
0 likes · 6 min read

Componentization reduces software complexity by breaking logic into single‑responsibility, decoupled units that can be statically orchestrated with a Java DSL or dynamically configured via JSON, while clear interfaces, appropriate granularity, and extension points ensure reusable, maintainable, and adaptable workflows.
DSLDecouplingWorkflow Orchestration
0 likes · 22 min read

The article reveals why most account designs get trapped by tightly coupling business transaction states with ledger entries, explains the pitfalls of updating massive historical records, and proposes a decoupled, pure‑account approach that treats each state change as an immutable accounting event.
Decouplingaccountingfinancial systems
0 likes · 7 min read

BlockFramework is an open‑source Android client‑side framework that decouples business logic into reusable Blocks, offering clear separation, tree‑based UI assembly, rich communication patterns, unified development standards, and high‑performance features such as asynchronous view inflation and data binding.
AndroidBlockFrameworkDecoupling
0 likes · 8 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 introduces message queues, explaining their role in high‑traffic systems, key characteristics such as asynchronous communication, decoupling, reliability and buffering, compares point‑to‑point and publish‑subscribe models, and reviews popular implementations like RabbitMQ, Kafka, ActiveMQ, RocketMQ and Pulsar.
Backend DevelopmentDecouplingKafka
0 likes · 8 min read

The article describes the background, pain points, and detailed design of the Xinge messaging platform, including decoupling of messages, lifecycle management, rate‑limiting strategies, template usage, and future enhancements to provide a unified, reliable backend service for business notifications.
BackendDecouplingMicroservices
0 likes · 9 min read

This article explores Go interfaces, explaining how they enable polymorphism, reduce coupling, and support extensibility through clear examples and real‑world scenarios such as API design, testing, plugins, and dependency injection.
DecouplingExtensibilityPolymorphism
0 likes · 8 min read

This article explains the Command design pattern, describes its key participants and advantages, and provides five Python examples demonstrating command encapsulation, undo/redo functionality, file operations, shopping‑cart management, and menu handling to illustrate how the pattern decouples request senders from receivers.
DecouplingDesign PatternsPython
0 likes · 9 min read

This article demonstrates how to replace tightly‑coupled if‑else or switch‑case parser selection with the Service Locator Pattern in a Spring Java application, enabling easy addition of new file‑type parsers without modifying client code and adhering to the open‑closed principle.
DecouplingDesign PatternJava
0 likes · 8 min read

Learn how to use Spring's Application Event mechanism to separate main and sub‑processes in Java applications, covering custom event and listener creation, publishing events, abstract base event design, singleton manager, and a real‑world order‑cancellation SMS notification case.
BackendDecouplingDesign Pattern
0 likes · 10 min read

This article explains why message queues are used to decouple services, enable asynchronous processing, smooth traffic spikes, and improve performance, while also detailing the new challenges they introduce such as reduced availability, increased complexity, duplicate consumption, data consistency, message loss, ordering, and backlog, along with practical solutions for each issue.
Asynchronous ProcessingData ConsistencyDecoupling
0 likes · 18 min read

This article explains why message queues are essential for decoupling services, enabling asynchronous processing, and smoothing traffic spikes, then details the new challenges they introduce—such as availability, complexity, duplicate consumption, ordering, and data consistency—and offers concrete mitigation strategies for each issue.
Asynchronous ProcessingData ConsistencyDecoupling
0 likes · 15 min read


DevOpsOct 23, 2022 · Fundamentals
The article explains software engineering’s first‑principle laws—software is a virtual product that can only be created once—critiques waterfall, advocates agile and DevOps, and emphasizes granularity and decoupling (including Infrastructure as Code) as essential practices for modern development.
Decouplingfirst principlesgranularity
0 likes · 10 min read

This article explains what a Message Queue (MQ) is, outlines its main benefits such as decoupling, asynchronous processing, peak‑shaving and log handling, discusses drawbacks like reduced availability and added complexity, and presents typical problems with duplicate consumption, message loss, ordering and backlog along with practical mitigation strategies.
DecouplingMQMessage Reliability
0 likes · 6 min read

The article analyzes Alibaba's business middle platform strategy, exposing its inefficiencies caused by deep coupling, high collaboration, cognitive, and stability costs, and proposes practical solutions such as thinning business capabilities, strengthening platform services, decoupling via service-oriented architecture, and adopting Platform-as-Code with componentization.
BackendDecouplingPlatform as Code
0 likes · 11 min read

This article explains how message queues help decouple services, enable asynchronous processing, smooth traffic spikes, and improve system resilience, while also detailing common challenges such as reduced availability, increased complexity, duplicate consumption, data consistency, message loss, ordering, and backlog, along with practical mitigation strategies.
Data ConsistencyDecouplingasynchrony
0 likes · 15 min read

This article explains the motivations for introducing message queues—such as decoupling, asynchronous processing, and traffic shaping—then details the typical challenges like availability, complexity, duplicate consumption, data consistency, message loss, ordering, and backlog, and provides practical solutions for each issue.
Asynchronous ProcessingDecouplingreliability
0 likes · 14 min read

This article examines iQIYI's journey from a monolithic mobile codebase to a decoupled, component‑driven middle platform, detailing Alibaba's big‑middle‑platform strategy, the platform's architecture, SDK management, high‑availability design, and plans to offer SaaS services.
DecouplingSaaSiQIYI
0 likes · 15 min read

This article explains the fundamentals of message queues, compares synchronous and asynchronous communication, discusses the benefits of sender‑receiver decoupling, outlines performance and reliability considerations, and provides practical guidance for designing robust distributed messaging architectures.
Decouplingasynchronous communicationmessage-queue
0 likes · 9 min read

This article explains the drawbacks of traditional synchronous architectures, outlines why adopting message queues improves latency, coupling, and peak‑handling, and then details common MQ problems such as duplicate messages, data inconsistency, loss, ordering, backlog, and increased complexity along with concrete mitigation strategies.
Backend DevelopmentDecouplingSystem Design
0 likes · 13 min read

This article explains the drawbacks of traditional synchronous request handling, introduces message queues as a solution for asynchronous processing, decoupling services, and traffic shaping, and then details the common MQ challenges—duplicate messages, data inconsistency, loss, ordering, backlog, and added system complexity—along with practical mitigation strategies.
Asynchronous ProcessingDecouplingbackend-architecture
0 likes · 15 min read

This article explores the essence of layered architecture, explaining why layering is used, its advantages and disadvantages, core design principles, and practical ways to apply logical and physical layers in real‑world software projects.
DecouplingDesign PrinciplesLayered Architecture
0 likes · 8 min read

This article introduces RabbitMQ, explains its core concepts and typical scenarios such as decoupling, asynchronous processing, and traffic shaping, and discusses the benefits and challenges of integrating a message queue into backend architectures.
Asynchronous ProcessingDecouplingRabbitMQ
0 likes · 8 min read

The article explores how enterprises can reduce tight coupling in microservice architectures by converting synchronous calls to asynchronous messaging, adopting message‑oriented middleware, applying event‑driven analysis, and leveraging CQRS patterns, while also offering practical refactoring tactics for overly coupled services.
CQRSDecouplingMicroservices
0 likes · 20 min read

This article explains what RabbitMQ is, describes common scenarios such as decoupling services, improving asynchronous processing efficiency, and handling traffic spikes, and outlines the benefits and drawbacks of integrating a message queue into system architecture.
DecouplingRabbitMQasynchronous
0 likes · 8 min read

This article explains why message queues are essential for decoupling systems, enabling asynchronous processing and peak‑shaving, outlines their advantages and disadvantages, compares popular MQ products, and provides practical guidance on high availability, reliability, ordering, and architectural design.
DecouplingHigh Availabilityarchitecture
0 likes · 12 min read

This article explains the concept of ThinkPHP Hook behaviors, demonstrates how to define, bind, and trigger custom behavior classes with code examples, and shows how to decouple login logic using event‑like hooks for more maintainable backend development.
BackendDecouplingEvent
0 likes · 6 min read

The article analyzes common coupling problems in microservice architectures and presents practical decoupling techniques—including asynchronous messaging, event‑driven design, local caching, data landing, and CQRS—while also offering refactoring guidelines for tightly coupled services.
BackendCQRSDecoupling
0 likes · 20 min read

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.
CQRSDecouplingMicroservices
0 likes · 21 min read

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.
CQRSDecouplingMicroservices
0 likes · 19 min read

This article explains the fundamentals of message queues, why they are needed for decoupling, asynchronous processing and throttling, introduces JMS concepts, details ActiveMQ storage options and protocols, and provides practical Java and Spring Boot code examples for producers, consumers, and advanced features such as transactions, persistence, and delayed delivery.
ActiveMQDecouplingJava
0 likes · 26 min read

The article examines why tightly coupled microservices cause reliability issues, then presents practical techniques—such as converting synchronous calls to asynchronous messaging, adopting event‑driven architecture, using CQRS, caching, and strategic refactoring—to achieve loose coupling and improve system resilience.
CQRSDecouplingMicroservices
0 likes · 21 min read


58 TechJul 22, 2020 · Mobile Development
This article explains the background, goals, and step‑by‑step methodology for refactoring a mature mobile platform app into an App Factory that supports rapid, modular development of innovative independent apps through systematic decoupling, middleware management, and automated engineering pipelines.
AndroidDecouplingapp factory
0 likes · 22 min read

The article explains why and how to use message queues to achieve low‑coupling, better performance, fault tolerance, and eventual consistency in an e‑commerce order‑processing flow, discusses common pitfalls such as message loss and duplication, and compares popular queue products like RabbitMQ, Kafka, and RocketMQ.
DecouplingKafkaRabbitMQ
0 likes · 10 min read

Learn how the Command pattern separates request issuance from execution, introducing roles like Command, ConcreteCommand, Receiver, Invoker, and Client, and see real‑world analogies and examples such as Hystrix and Java’s ThreadPoolExecutor that illustrate its widespread use in modern software.
DecouplingDesign PatternUML
0 likes · 4 min read

The article explains why proper business system design is crucial for low‑coupling, illustrating concepts such as listener and observer patterns, asynchronous execution, scheduled tasks, and message middleware with Java code examples to show how to achieve modular, maintainable back‑end services.
DecouplingSchedulingasynchronous
0 likes · 16 min read

iQIYI Knowledge’s universal audio‑video playback architecture decouples player, business logic, SDKs and page lifecycles via observer patterns and adapters, enabling seamless scene switching across multiple windows—including floating and short‑video panes—without interrupting playback, simplifying third‑party integration and reducing development overhead.
DecouplingObserver Patternaudio-video
0 likes · 10 min read

This article introduces RabbitMQ, explains its core concepts and AMQP protocol, outlines common scenarios such as decoupling, asynchronous processing, and traffic shaping, and discusses the benefits and challenges of integrating a message queue into backend architectures.
AMQPDecouplingRabbitMQ
0 likes · 8 min read

This article explains the role of message‑queue middleware in distributed systems, covering its communication patterns, ten key advantages such as decoupling and scalability, and practical use cases like asynchronous processing, traffic shaping, log handling, and e‑commerce architectures.
Asynchronous ProcessingDecouplingSystem Design
0 likes · 14 min read

This article explains how using message queues for asynchronous communication decouples services, improves fault tolerance, and enhances performance, illustrated with a real‑world early‑education app case and a guide to employing dead‑letter queues for handling failed messages.
Dead Letter QueueDecouplingasynchronous communication
0 likes · 9 min read

Java’s Service Provider Interface (SPI) is a built‑in discovery mechanism that decouples implementation from usage by letting providers place fully qualified class names in META‑INF/services files, enabling frameworks such as JDBC, logging, and Dubbo to load multiple vendor implementations at runtime via ServiceLoader, though it has limitations like lack of on‑demand loading and concurrency issues.
DecouplingFramework ExtensionJava SPI
0 likes · 8 min read

The article explains why message queues are employed for decoupling, asynchronous processing, and load‑shedding, outlines their advantages and disadvantages, and compares popular MQ products such as Kafka, ActiveMQ, RabbitMQ, and RocketMQ to guide technology selection.
DecouplingKafkaRabbitMQ
0 likes · 5 min read

This article explains what a message queue (MQ) is, why it is needed beyond in‑memory Java queues, and how it enables decoupling, asynchronous processing, peak‑shaving and rate‑limiting, while also discussing high‑availability, data‑loss, and consumer‑side considerations.
DecouplingHigh AvailabilityJava
0 likes · 11 min read

Xianyu refactored its item publishing and editing features using the self‑developed SWAK framework, first extracting business logic into isolated packages to separate platform code, then service‑izing the rental business via remote RPC, dramatically improving code clarity, reuse, team coordination, and system scalability.
DecouplingRPCSWAK
0 likes · 12 min read


JD TechJun 11, 2018 · Backend Development
Message queues enable asynchronous, decoupled communication between systems, and this article explains core scenarios such as decoupling, peak‑shaving, achieving eventual consistency, broadcast consumption, and retry handling, while highlighting implementation details, pull‑mode code, and important considerations like idempotency and consumption monitoring.
BroadcastDecouplingIdempotency
0 likes · 10 min read

This article explains the core concepts, component diagram, message flow, cross‑center sequencing, high‑availability design, and detailed ActiveMQ configuration for OneMM message‑oriented middleware, highlighting how asynchronous and decoupled communication improves system efficiency and scalability.
ActiveMQDecouplingasynchronous
0 likes · 15 min read

This article explains how message queues enable system decoupling, smooth traffic spikes, achieve eventual consistency, support broadcast consumption, and handle retry pitfalls, providing practical code examples and architectural guidelines for reliable backend design.
BroadcastDecouplingLoad Smoothing
0 likes · 10 min read

The article shares practical insights on planning, designing, developing, testing, and rolling out a large‑scale backend system refactor, emphasizing resource limits, pain points of legacy code, unit‑test protection, layering, decoupling, monitoring, and staged deployment to ensure stability during high‑traffic events.
DecouplingPerformance Monitoringbackend-architecture
0 likes · 9 min read


DevOpsOct 10, 2017 · R&D Management
The article shares a year‑long experience of applying agile and lean principles—especially splitting and decoupling—to improve delivery efficiency, team structure, and value flow across large waterfall projects, small process‑optimisation tasks, and product‑centric squads, highlighting concrete practices, outcomes, and future plans.
AgileDecouplingLean
0 likes · 12 min read


转转QASep 11, 2016 · Mobile Development
As smartphones become full‑featured computers, traditional PC/M functionalities are migrating to mobile apps, causing teams to face pre‑, mid‑, and post‑development challenges such as coordination friction, technical debt, and high coupling, and the article proposes concrete improvement measures including clearer collaboration, reduced coupling, parallel versioning, and iterative release cycles.
DecouplingProcess Improvementmobile development
0 likes · 10 min read

The article describes Ctrip Tech's Gateway system, detailing its origin as a monolithic wireless service, the need for gradual decoupling, the implementation process for HTTP and TCP traffic, and the resulting features such as routing, isolation, rate limiting, circuit breaking, anti‑scraping, and monitoring.
BackendDecouplingcircuit breaking
0 likes · 5 min read
