中台架构与实现：基于DDD和微服务 (欧创新 邓頔)（Z-Library）

【One-Line Pitch】 A practical field guide to building a reusable business middle platform by combining Domain-Driven Design with microservices—written for architects, tech leads, and digital-transformation managers who must turn a tangled legacy system into clean, evolvable domain models and services. 【Book Arc】 - **Opening (~0%–10%)**: Frames the problem: monolithic legacy systems, duplicated IT capabilities, and the "dual core / two frontends" trap. Introduces the business + data middle-platform strategy and the "split then merge" capability-building logic. - **Early (~10%–30%)**: Lays the conceptual foundation—why microservices need DDD, the "iron triangle" of DDD, middle platform, and microservices, plus core building blocks: domains/subdomains, bounded contexts, entities, value objects, aggregates, and domain events. - **Middle (~30%–50%)**: Moves into architecture and design mechanics: DDD layered architecture, onion architecture, service evolution within a microservice, project-level vs. enterprise-level integration, and the BFF layer for cross-platform orchestration. - **Late (~50%–75%)**: Applies DDD end-to-end—event storming, rebuilding the middle-platform business model, designing the microservice code model, keeping domain and code models aligned, and evolving the architecture. - **Ending (~75%–100%)**: Extends to frontend design (micro-frontends, unitized design) and closes with a full middle-platform case study (insurance order design) walking through the complete top-down modeling flow. 【Key Takeaways】 - **DDD is the shared methodology for both middle-platform modeling and microservice design** (Early): strategic design builds the reusable domain model; tactical design turns it into services. This "iron triangle" is the book's central thesis. - **The middle platform is a business model, not a technology stack** (Opening): its value comes from沉淀 reusable capabilities, so modeling must start from business domains, not from infrastructure choices. - **"Split" and "merge" are two halves of one strategy** (Opening): split to create single-responsibility, stable domain models; merge to compose enterprise-level capabilities and unify frontend experience. - **Bounded context is the practical boundary tool** (Early): it resolves terminology conflicts via ubiquitous language and gives microservice splitting a defensible edge—subdomains and bounded contexts usually map one-to-one or one-to-many. - **Aggregates enforce consistency and enable code reorganization** (Early): one aggregate, one repository; aggregate-level packaging makes future microservice splitting and migration far easier. - **Domain events decouple microservices** (Early): event construction, persistence, event bus, and message middleware form the mechanism for cross-context collaboration and eventual consistency. - **Layered architecture must stay clean** (Middle): keep domain logic in the domain layer, orchestration in the application layer, and use BFF for enterprise-level cross-platform composition. - **Model-code consistency is a deliberate discipline** (Late): maintain a domain-object inventory and map domain objects to code objects to prevent drift between design and implementation. 【Reading Tips】 - Read Part 1 and Part 2 together, as the author suggests—concepts like bounded context and aggregate are easier to grasp once you see the middle-platform context. - Deep-read the event storming and domain modeling chapters (Part 3); these are the operational core. Skim the frontend/micro-frontend chapters if your role is backend-focused. - Treat the insurance order case study as a capstone: read it after the modeling chapters to see how all concepts connect in one flow. - Pay attention to the code-structure conventions (aggregate directories, repository placement)—they are the bridge from model to maintainable code. - Keep the "split vs. merge" tension in mind throughout; it is the recurring design judgment the book teaches. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book in detail, with later chapters (frontend design, the insurance case study, and detailed code walkthroughs) represented mainly by chapter summaries. Specific code listings and full case-study steps are not reproduced here.