Domain-Driven Design with Java

Description

Description Adopt a practical and modern approach to architecting and implementing DDD-inspired solutions to transform abstract business ideas into working software across the entire spectrum of the software development life cycle Key Features: Implement DDD principles to build simple, effective, and well-factored solutions Use lightweight modeling techniques to arrive at a common collective understanding of the problem domain Decompose monolithic applications into loosely coupled, distributed components using modern design patterns Book Description: Domain-Driven Design (DDD) makes available a set of techniques and patterns that enable domain experts, architects, and developers to work together to decompose complex business problems into a set of well-factored, collaborating, and loosely coupled subsystems. This practical guide will help you as a developer and architect to put your knowledge to work in order to create elegant software designs that are enjoyable to work with and easy to reason about. You'll begin with an introduction to the concepts of domain-driven design and discover various ways to apply them in real-world scenarios. You'll also appreciate how DDD is extremely relevant when creating cloud native solutions that employ modern techniques such as event-driven microservices and fine-grained architectures. As you advance through the chapters, you'll get acquainted with core DDD's strategic design concepts such as the ubiquitous language, context maps, bounded contexts, and tactical design elements like aggregates and domain models and events. You'll understand how to apply modern, lightweight modeling techniques such as business value canvas, Wardley mapping, domain storytelling, and event storming, while also learning how to test-drive the system to create solutions that exhibit high degrees of internal quality. By the end of this software design book, you'll be able to architect, design, and implement robust, resilient, and performant distributed software solutions. What You Will Learn: Discover how to develop a shared understanding of the problem domain Establish a clear demarcation between core and peripheral systems Identify how to evolve and decompose complex systems into well-factored components Apply elaboration techniques like domain storytelling and event storming Implement EDA, CQRS, event sourcing, and much more Design an ecosystem of cohesive, loosely coupled, and distributed microservices Test-drive the implementation of an event-driven system in Java Grasp how non-functional requirements influence bounded context decompositions Who this book is for: This book is for intermediate Java programmers looking to upgrade their software engineering skills and adopt a collaborative and structured approach to designing complex software systems. Specifically, the book will assist senior developers and hands-on architects to gain a deeper understanding of domain-driven design and implement it in their organization. Familiarity with DDD techniques is not a prerequisite; however, working knowledge of Java is expected. Cover Copyright Contributors Table of Contents Preface Part 1: Foundations Chapter 1: The Rationale for Domain-Driven Design Why do software projects fail? Inaccurate requirements Too much architecture Too little architecture Excessive incidental complexity Uncontrolled technical debt Ignoring non-functional requirements Modern systems and dealing with complexity How software gets built Complexity is inevitable Optimizing the feedback loop What is DDD? Understanding the problem using strategic design Promoting a shared understanding using a ubiquitous language Implementing the solution using tactical design Why is DDD relevant? Why now? Rise of open source Advances in technology Rise of distributed computing Summary Further reading Chapter 2: Where and How Does DDD Fit? Architecture styles Layered architecture Vertical slice architecture Service-oriented architecture (SOA) Microservices architecture Event-driven architecture (EDA) Command Query Responsibility Segregation (CQRS) Serverless architecture The big ball of mud Which architecture style should you use? Programming paradigms Object-oriented programming Functional programming Which paradigm should you choose? Summary Part 2: Real-World DDD Chapter 3: Understanding the Domain The domain of international trade International trade at KP Bank Understanding international trade strategy at KP Bank The business model canvas The lean canvas Impact maps Wardley maps International trade products and services Summary Further reading Chapter 4: Domain Analysis and Modeling Technical requirements Understanding a letter of credit An LC issuance application Enhancing shared understanding Domain storytelling Using DST for an LC application EventStorming Introducing EventStorming Using EventStorming for the LC issuance application Summary Further reading Chapter 5: Implementing Domain Logic Technical requirements Continuing our design journey Implementing the command side Tooling choices Bootstrapping the application Identifying commands Identifying aggregates Test-driving the system Implementing the command Implementing the event Designing the aggregate Persisting aggregates State-stored aggregates Event-sourced aggregates Persistence technology choices Which persistence mechanism should we choose? Enforcing policies Summary Further reading Chapter 6: Implementing the User Interface – Task-Based Technical requirements API styles CRUD-based APIs Task-based APIs Task-based or CRUD-based? Bootstrapping the UI Implementing the UI MVVM primer Creating a new LC Declarative view View delegate View-model Summary Further reading Chapter 7: Implementing Queries Technical requirements Continuing our design journey Implementing the query side Tooling choices Identifying queries Creating the query model Query-side persistence choices Exposing a query API Advanced query scenarios Historic event replays Types of replays Event replay considerations Event design Event handlers with side effects Summary Further reading Chapter 8: Implementing Long-Running Workflows Technical requirements Continuing our design journey Implementing sagas Orchestration Choreography Handling deadlines Summary Further reading Chapter 9: Integrating with External Systems Continuing our design journey Bounded context relationships Symmetric relationship patterns Asymmetric relationship patterns Implementation patterns Data-based Code-based IPC-based Summary Further reading Part 3: Evolution Patterns Chapter 10: Beginning the Decomposition Journey Continuing our design journey Decomposing our monolith Changes to frontend interactions Protocol options Transport format Compatibility and versioning REST APIs Changes for event interactions Changes in database interactions Data migration Cut-over Summary References Chapter 11: Decomposing into Finer-Grained Components Continuing our design journey Saga as a standalone component Commands and queries as standalone components Distributing individual query components Even more fine-grained decomposition Effects on the domain model Decomposing the frontend Where to draw the line Team organization Summary Further reading Chapter 12: Beyond Functional Requirements Observability Technology metrics Business metrics DevOps metrics Consistency Performance and scale Trunk-based development Continuous testing Contract testing Mutation testing Chaos testing Deployment automation Refactoring Breaking an existing monolith Merging into coarse-grained bounded contexts Invocation style Synchronous invocation Asynchronous invocation Logging Segregating logging code Dealing with sensitive data Log format Log aggregation Tracing Versioning Components APIs Data Summary Closing thoughts Index Other Books You May Enjoy