Domain-Driven Design with Java - A Practitioner's Guide: Create simple, elegant, and valuable software solutions for complex business problems

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