book

Patterns, Principles, and Practices of Domain-Driven Design

by Scott Millett, Nick Tune

May 2015

Intermediate to advanced

792 pages

22h 32m

English

Wrox

Read now

Unlock full access

Overview of the Book and TechnologyHow This Book Is OrganizedWho Should Read This BookSource CodeErratap2p.wrox.comSummary
The Challenges of Creating Software for Complex Problem DomainsHow the Patterns of Domain-Driven Design Manage ComplexityThe Practices and Principles of Domain-Driven DesignPopular Misconceptions of Domain-Driven DesignThe Salient Points
Knowledge Crunching and CollaborationGaining Domain Insight with Domain ExpertsPatterns for Effective Knowledge CrunchingLook For Existing ModelsThe Salient Points
Why Decompose a Problem Domain?How to Capture the Essence of the ProblemHow to Focus on the Core ProblemHow Subdomains Shape a SolutionNot All Parts of a System Will Be Well DesignedWhat If You Have No Core Domain?The Salient Points
What Is a Domain Model?Model-Driven DesignUsing a Ubiquitous Language to Bind the Analysis to the Code ModelCollaborating on a Ubiquitous LanguageHow to Create Effective Domain ModelsWhen to Apply Model-Driven DesignThe Salient Points
The Domain LayerDomain Model Implementation PatternsThe Salient Points
The Challenges of a Single ModelUse Bounded Contexts to Divide and Conquer a Large ModelImplementing Bounded ContextsThe Salient Points
A Reality MapRecognising the Relationships between Bounded ContextsCommunicating the Context MapThe Strategic Importance of Context MapsThe Salient Points
Application ArchitectureApplication ServicesApplication ClientsThe Salient Points

Overemphasizing the Importance of Tactical PatternsMissing the Real Value of DDD: Collaboration, Communication, and ContextSpending Too Much Time on What’s Not ImportantMaking Simple Problems ComplexUnderestimating the Cost of Applying DDDThe Salient Points
Selling DDDApplying the Principles of DDDExploration and ExperimentationMaking the Implicit ExplicitA Problem Solver First, A Technologist SecondHow Do I Know That I Am Doing It Right?The Salient Points
How to Integrate Bounded ContextsIntegrating Distributed Bounded ContextsThe Challenges of DDD with Distributed SystemsSOA and Reactive DDDThe Salient Points
Messaging FundamentalsBuilding an E-Commerce Application with NServiceBusMaintaining a Messaging ApplicationIntegrating a Bounded Context with Mass TransitThe Salient Points
Why Prefer HTTP?RPCRESTThe Salient Points
Tactical PatternsPatterns to Model Your DomainLifeCycle PatternsEmerging PatternsThe Salient Points
When to Use a Value ObjectDefining CharacteristicsCommon Modeling PatternsPersistenceThe Salient Points
Understanding EntitiesImplementing EntitiesCommon Entity Modeling Principles and PatternsThe Salient Points
Understanding Domain ServicesUtilizing Domain ServicesThe Salient Points
Essence of the Domain Events PatternEvent Handling ActionsDomain Events’ Implementation PatternsTesting Domain EventsThe Salient Points
Managing Complex Object GraphsAggregatesDefining Aggregate BoundariesImplementing AggregatesThe Salient Points
The Role of a FactoryThe Salient Points
RepositoriesA Misunderstood PatternAggregate Persistence StrategiesA Repository Is an Explicit ContractTransaction Management and Units of WorkTo Save or Not To SaveThe Repository as an Anticorruption LayerOther Responsibilities of a RepositoryRepository AntipatternsRepository ImplementationsThe Salient Points
The Limitations of Storing State as a SnapshotGaining Competitive Advantage by Storing State as a Stream of EventsEvent-Sourced AggregatesBuilding an Event StoreUsing the Purpose-Built Event StoreCQRS with Event SourcingRecapping the Benefits of Event SourcingWeighing the Costs of Event SourcingAdditional Learning ResourcesThe Salient Points
Design ConsiderationsExample 1: An HTML API-Based, Server-Side UI for Nondistributed Bounded ContextsExample 2: A Data API-Based, Client-Side UI for Distributed Bounded ContextsThe Salient Points
The Challenges of Maintaining a Single Model for Two ContextsA Better Architecture for Complex Bounded ContextsThe Command Side: Business TasksThe Query Side: Domain ReportingThe Misconceptions of CQRSPatterns to Enable Your Application to ScaleThe Salient Points
Differentiating Application Logic and Domain LogicApplication Service PatternsTesting Application ServicesThe Salient Points
Domain Reporting Within a Bounded ContextDomain Reporting Across Bounded ContextsThe Salient Points

Content preview from Patterns, Principles, and Practices of Domain-Driven Design

20 Factories

WHAT’S IN THIS CHAPTER?

How factories separate use from construction
Applying factory methods to aggregates
Using a factory method for reconstruction
Knowing when to use a factory

Wrox.com Code Downloads for This Chapter

The wrox.com code downloads for this chapter are found at www.wrox.com/go/domaindrivendesign on the Download Code tab. The code is in the Chapter 20 download and individually named according to the names throughout the chapter.

How do you create, persist, and retrieve domain objects while maintaining a domain model that is not distracted by technical concerns? The life cycle of complex domain objects may need coordination to begin and when being persisted. Ensuring invariants are met on creation is achieved through the utilization of the Gang of Four factory pattern.

The Role of a Factory

Aggregates, entities, and value objects can become complex when you’re creating a domain model for large and rich domains. If intimate knowledge is required to ensure valid instances of a dependent object are created, it can cloud the expressiveness of the domain. The knowledge of other objects’ invariants breaks the Single Responsibility Principle (SRP). It is recommended that you separate use from construction and explicitly encapsulate creation logic within a factory object if it is complex or if it can be expressed better. Object creation is not a domain concern, but it does live within the domain layer of an application. You will rarely talk about factories ...