part i
putting the domain model to work 1
chapter 1: crunching knowledge 7
ingredients of effective modeling 12
knowledge crunching 13
continuous learning 15
knowledge-rich design 17
deep models 20
chapter 2: communication and the use of language 23
ubiquitous language 24
modeling out loud 30
one team, one language 32
documents and diagrams 35
written design documents 37
executable bedrock 40
explanatory models 41
chapter 3: binding model and implementation 45
model-driven design 47
modeling paradigms and tool support 50
letting the bones show: why models matter to users 57
.hands-on modelers 60
part ii
the building blocks of a model-driven design 63
chapter 4: isolating the domain 67
layered architecture 68
relating the layers 72
architectural frameworks 74
the domain layer is where the model lives 75
the smart ui “anti-pattern” 76
other kinds of isolation 79
chapter 5: a model expressed in software 81
associations 82
entities (a.k.a. reference objects) 89
modeling entities 93
designing the identity operation 94
value objects 97
designing value objects 99
designing associations that involve value objects 102
services 104
services and the isolated domain layer 106
granularity 108
access to services 108
modules (a.k.a. packages) 109
agile modules 111
the pitfalls of infrastructure-driven packaging 112
modeling paradigms 116
why the object paradigm predominates 116
nonobjects in an object world 119
sticking with model-driven design when
mixing paradigms 120
chapter 6: the life cycle of a domain object 123
aggregates 125
factories 136
choosing factories and their sites 139
when a constructor is all you need 141
designing the interface 143
where does invariant logic go? 144
entity factories versus value object factories 144
reconstituting stored objects 145
repositories 147
querying a repository 152
client code ignores repository implementation;
developers do not 154
implementing a repository 155
working within your frameworks 156
the relationship with factories 157
designing objects for relational databases 159
chapter 7: using the language: an extended example 163
introducing the cargo shipping system 163
isolating the domain: introducing the applications 166
distinguishing entities and value objects 167
role and other attributes 168
designing associations in the shipping domain 169
aggregate boundaries 170
selecting repositories 172
walking through scenarios 173
sample application feature: changing the destination
of a cargo 173
sample application feature: repeat business 173
object creation 174
factories and constructors for cargo 174
adding a handling event 175
pause for refactoring: an alternative design of the
cargo aggregate 177
modules in the shipping model 179
introducing a new feature: allocation checking 181
connecting the two systems 182
enhancing the model: segmenting the business 183
performance tuning 185
a final look 186
part iii
refactoring toward deeper insight 187
chapter 8: breakthrough 193
story of a breakthrough 194
a decent model, and yet . . . 194
the breakthrough 196
a deeper model 198
a sobering decision 199
the payoff 200
opportunities 201
focus on basics 201
epilogue: a cascade of new insights 202
chapter 9: making implicit concepts explicit 205
digging out concepts 206
listen to language 206
scrutinize awkwardness 210
contemplate contradictions 216
read the book 217
try, try again 219
how to model less obvious kinds of concepts 219
explicit constraints 220
processes as domain objects 222
specification 224
applying and implementing specification 227
chapter 10: supple design 243
intention-revealing interfaces 246
side-effect-free functions 250
assertions 255
conceptual contours 260
standalone classes 265
closure of operations 268
declarative design 270
domain-specific languages 272
a declarative style of design 273
extending specifications in a declarative style 273
angles of attack 282
carve off subdomains 283
draw on established formalisms, when you can 283
chapter 11: applying analysis patterns 293
chapter 12: relating design patterns to the model 309
strategy (a.k.a. policy) 311
composite 315
why not flyweight? 320
chapter 13: refactoring toward deeper insight 321
initiation 321
exploration teams 322
prior art 323
a design for developers 324
timing 324
crisis as opportunity 325
part iv
strategic design 327
chapter 14: maintaining model integrity 331
bounded context 335
recognizing splinters within a bounded context 339
continuous integration 341
context map 344
testing at the context boundaries 351
organizing and documenting context maps 351
relationships between bounded contexts 352
shared kernel 354
customer/supplier development teams 356
conformist 361
anticorruption layer 364
designing the interface of the anticorruption layer 366
implementing the anticorruption layer 366
a cautionary tale 370
separate ways 371
open host service 374
published language 375
unifying an elephant 378
choosing your model context strategy 381
team decision or higher 382
putting ourselves in context 382
transforming boundaries 382
accepting that which we cannot change: delineating
the external systems 383
relationships with the external systems 384
the system under design 385
catering to special needs with distinct models 386
deployment 387
the trade-off 388
when your project is already under way 388
transformations 389
merging contexts: separate ways ? shared kernel 389
merging contexts: shared kernel ? continuous
integration 391
phasing out a legacy system 393
open host service ? published language 394
chapter 15: distillation 397
core domain 400
choosing the core 402
who does the work? 403
an escalation of distillations 404
generic subdomains 406
generic doesn’t mean reusable 412
project risk management 413
domain vision statement 415
highlighted core 417
the distillation document 418
the flagged core 419
the distillation document as process tool 420
cohesive mechanisms 422
generic subdomain versus cohesive mechanism 424
when a mechanism is part of the core domain 425
distilling to a declarative style 426
segregated core 428
the costs of creating a segregated core 429
evolving team decision 430
abstract core 435
deep models distill 436
choosing refactoring targets 437
chapter 16: large-scale structure 439
evolving order 444
system metaphor 447
the “naive metaphor” and why we don’t need it 448
responsibility layers 450
choosing appropriate layers 460
knowledge level 465
pluggable component framework 475
how restrictive should a structure be? 480
refactoring toward a fitting structure 481
minimalism 481
communication and self-discipline 482
restructuring yields supple design 482
distillation lightens the load 483
chapter 17: bringing the strategy together 485
combining large-scale structures and bounded contexts 485
combining large-scale structures and distillation 488
assessment first 490
who sets the strategy? 490
emergent structure from application development 491
a customer-focused architecture team 492
six essentials for strategic design decision making 492
the same goes for the technical frameworks 495
beware the master plan 496
conclusion 499
appendix: the use of patterns in this book 507
glossary 511
references 515
photo credits 517
index 519
点击看大图
加载中...
