Domain-driven design software: the way to cope with core complexity (English version) (highly recommended by many world-class software masters)

Source: Internet
Author: User

Domain-driven design software: the way to cope with core complexity (English version) (highly recommended by many world-class software masters)

Basic Information

Author: (US) Eric Evans
Series name: Turing programming Series
Press: People's post and telecommunications Press
ISBN: 9787115224071
Mounting time:
Published on: February 1, April 2010
Start: 16
Other Details View: http://www.china-pub.com/196594

 

Media comment

This book should appear on the shelves of every software developer.
-- Kent Beck, founder of Extreme Programming
Eric's book is amazing. He tells you exactly how to make software design meet your ideal model needs ....... This book is infinite. Eric has many interesting stories and has a set of descriptions. After being published, it will become a must-read classic for software developers.
-- Ralph Johnson, author of design patterns
If you think that your investment in object-oriented programming has not been paid off, you will know what you missed after reading this book.
-- Ward cunnheim, a pioneer in design patterns and agile software methods

Eric Evans demonstrated the importance of developing core domain models. He built a solid framework and provided a set of implementation techniques and techniques. What has precipitated here is the constant wisdom of the past, and the methodology of the time has become the end of tomorrow, and it is still brilliant.
-- Dave Collins, author of designing object-oriented user interfaces
Eric describes the language of nowhere to use, the benefits of sharing models with users, the management of object lifecycles, and the process and results of in-depth reconstruction from the perspective of actual users, this is a huge contribution to our field.
-- Luke Hohmann, author of beyond Software Architecture

 

Directory

Part I
Putting the domain model to work 1
Chapter 1: crunching knowledge 7
Ingredients of valid tive 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 Rule 30
One team, one language 32
Documents and diagrams 35
Written design documents ents 37
Executable bedrock 40
Explanatory models 41
Chapter 3: binding model and implementation 45
Model-driven design 47
Modeling paradigms and tool support 50
Leader 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
Invalid tural 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
Accesskey 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
Design 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
Aggregatboundaries 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
Cargo aggregate 177
Modules in the shipping model 179
Introducing a new feature: Allocation checking 181
Connect the two systems 182
Enhancing the model: segmenting the business 183
Performance Tuning 185
A final look186
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 models 198
A sobering demo-199
The payoff 200
Opportunities 201
Focuses on basics 201
Epilogue: A Case of new insights 202
Chapter 9: making implicit concepts explain it 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
Application and implementing specification 227
Chapter 10: supple design 243
Intention-revecaling interfaces 246
Side-effect-free functions 250
Assertions 255
Conceptual limit S 260
Standalone classes 265
Closure of operations 268
Declarative design 270
Domain-specific ages 272
A declarative style of design 273
Extending specifications in a declarative style 273
Angles of attack282
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
Com posite 315
Why not flyweight? 320
Chapter 13: refactoring toward deeper insight 321
Initialization 321
Federation ation teams 322
Prior art 323
A Design for developers 324
Ti Ming 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
Antiequaluption layer 364
Designing the interface of the antifraud uption layer 366
Implementing the antimo-uption 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 demo-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 is 419
The Distillation document as process tool 420
Cohesive mechanisms 422
Generic subdomain versus cohesive mechanic 424
When a mechanic 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 demo-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 shoshould a structure be? 480
Refactoring toward a fitting structure 481
Minimalism 481
Communicating 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
Assess ment first 490
Who sets the strategy? 490
Emergent structure from application development 491
A customer-focused Architecture Team 492
Six essentials' for strategic design demo-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
Reference 515
Photo credits 517
Index 519

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.