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.
This article presents five practical patterns—single‑use‑case classes, a lightweight Facade, self‑validating input records, domain‑event side‑effects, and ports‑and‑adapters—that transform monolithic Spring @Service classes into modular, readable, testable, and transaction‑safe components, improving maintainability and extensibility.
The article examines a payroll bug caused by exposing internal collections, then explains three immutable‑focused rules for aggregate roots—expose only through the root, keep each transaction to a single aggregate, and reference other aggregates by ID only—showing how proper design prevents consistency errors, performance loss, and concurrency conflicts in Spring Boot applications.
The article analyzes the pitfalls of synchronous calls in a payroll microservice, defines domain events and their naming conventions, compares them with message‑queue messages, and presents two concrete implementations—Spring ApplicationEvent for intra‑process decoupling and RocketMQ with a transactional outbox for cross‑process communication—while also clarifying when event sourcing is appropriate.
The article argues that Domain‑Driven Design is not an architectural style but a two‑layer framework—strategic design defines bounded contexts and ubiquitous language, while tactical design supplies the modeling tools—explaining common misreadings and showing how DDD complements Clean, Hexagonal, CQRS, and Event Sourcing approaches.
A comprehensive practical guide to implementing Domain-Driven Design in complex business systems, covering bounded context division using Event Storming and subdomain analysis, aggregate root and entity design with code examples, domain event patterns for decoupling and eventual consistency, and integrating DDD with Spring Boot's layered architecture using onion/clean architecture principles.
The article explains how Domain‑Driven Design addresses the pitfalls of bloated services, unclear boundaries, and inconsistent terminology by introducing bounded contexts, aggregates, and domain events, and outlines a step‑by‑step adoption process while debunking common misconceptions.
The article explains the DDD rich (or active) model, its core characteristics, compares it with the anemic model, and shows how to apply it in a shared‑rental billing domain using Java, DDD layers, domain events, and a lightweight framework.
The article explains Domain‑Driven Design’s philosophy of aligning business language with code, defines key concepts such as bounded contexts, entities, value objects, aggregates, and shows how these ideas translate into microservice decomposition, event‑driven integration, and reduced coupling for cloud‑native systems.
This article explains what domain events are, how to define them with proper naming and attributes, explores multiple techniques for publishing events in Go—including parameter injection, static-like helpers, return‑based and repository‑based approaches—and describes strategies for consuming events safely and atomically.
This article explains how Airwallex uses Domain-Driven Design (DDD) to model a complex payment system, covering problem and solution spaces, bounded contexts, domain models, services, events, infrastructure, and the transition from domain concepts to microservices.
In this interview, senior ZTE architect Zhang Xiaolong explains why development teams should adopt Domain‑Driven Design, outlines key practices such as a unified language, layered architecture, and domain events, and discusses common obstacles—including limited case studies and tooling gaps—and offers practical solutions to successfully implement DDD in complex, high‑performance telecom software.
The article, the second in a DDD practice series, shows how immutable domain events can capture business milestones and be stored and published, introduces Saga—both choreography and orchestration—to manage distributed transactions with compensations, and explains how CQRS separates read and write models, illustrating each concept with Java code while highlighting the resulting decoupling, scalability, and modeling clarity alongside added complexity and storage challenges.
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.
