领域驱动设计 on 方糖猫Blog

视频系统 DDD 实战：巴西 IPTV 项目的领域拆分

Fri, 23 Aug 2024 17:00:00 +0800

视频系统 DDD 实战：巴西 IPTV 项目的领域拆分

2021 年到 2025 年，我负责面向巴西市场的 IPTV 视频点播系统。这是一个用户量过百万、业务持续演进的系统。在几次大的产品迭代中，我们引入了领域驱动设计（DDD）来控制系统复杂度。这篇文章会完整复盘当时的领域拆分过程。

一、项目背景

系统核心功能：

视频上传：支持 tus / FTP / 网盘 / m3u8 等多种来源
视频转码：h264 / h265 多码率输出
DRM 加密：永新 / 自研加密方案
元数据管理：同步 IMDb / TMDB / PP 等外部数据源
播放列表：专题、分类、推荐
播放鉴权：用户权限、设备管理、防盗链

服务用户：200 万+，峰值日活 40 万。

二、为什么需要 DDD？

2.1 早期的问题

系统最初是一个单体应用，模块按技术分层组织：

controller/
service/
dao/
entity/

这种结构在业务简单时没问题，但随着功能增加，开始出现：

一个需求改动涉及多个「层」，改哪里不确定
业务逻辑散落在 Service 中，相似功能重复实现
转码、鉴权、元数据互相耦合，改一个模块影响多个模块
新成员上手慢，需要全局理解才敢改代码

2.2 DDD 带来的改变

DDD 不是银弹，但它帮我们做了两件事：

按业务边界组织代码，而不是按技术分层
显式定义领域概念，让业务逻辑有明确的归属

三、领域划分

3.1 核心域识别

我们先识别出系统的核心业务域：

flowchart TD
    content["内容域 (Content)<br/>媒资管理、视频文件、转码任务、DRM 加密"]
    metadata["元数据域 (Metadata)<br/>影片信息、演员、分类、标签、外部数据源同步"]
    playback["播放域 (Playback)<br/>播放鉴权、播放地址生成、防盗链、码率适配"]
    user["用户域 (User)<br/>用户账户、订阅、设备、播放历史"]
    recommendation["推荐域 (Recommendation)<br/>播放列表、专题、个性化推荐"]
    billing["计费域 (Billing)<br/>套餐、订单、支付、用量统计"]
    content --- metadata --- playback --- user --- recommendation --- billing

3.2 域间关系

flowchart LR
    playback["播放域"] -- 依赖 --> content["内容域"]
    playback -- 依赖 --> user["用户域"]
    recommendation["推荐域"] -- 依赖 --> metadata["元数据域"]
    recommendation -- "依赖（获取热门数据）" --> playback
    billing["计费域"] -- 依赖 --> user
    metadata -- 依赖 --> external["外部数据源"]

依赖方向尽量保持单向，避免循环依赖。

四、内容域详细设计

内容域是最复杂的域之一，我们以它为例展开。

4.1 聚合根设计

flowchart TD
    root["MediaAsset（媒资聚合根）"]
    file["MediaFile（视频文件）"]
    raw["原始文件"]
    transcoded["转码后文件（多码率）"]
    drmfile["DRM 加密文件"]
    job["TranscodingJob（转码任务）"]
    license["DrmLicense（DRM 许可证信息）"]
    root --> file
    file --> raw
    file --> transcoded
    file --> drmfile
    root --> job
    root --> license

MediaAsset 是聚合根，外部系统只能通过它访问内部实体。

4.2 关键领域事件

内容域会产生大量领域事件，其他域可以订阅：

事件	含义	订阅方
`MediaAssetUploaded`	媒资上传完成	转码服务
`TranscodingCompleted`	转码完成	内容域自身、播放域
`DrmEncryptionCompleted`	DRM 加密完成	播放域
`MetadataSynced`	元数据同步完成	推荐域
`MediaAssetPublished`	媒资发布上线	推荐域、搜索服务

4.3 状态流转

媒资从上传到发布的状态机：

flowchart TD
    UPLOADED --> PENDING_TRANSCODE --> TRANSCODING --> PENDING_DRM --> DRM_ENCRYPTED --> PENDING_METADATA --> METADATA_READY --> FINAL["PUBLISHED / REJECTED"]

每个状态变更都通过领域事件触发下一步操作。

五、分层架构

每个领域内部采用 DDD 经典四层架构：

flowchart TD
    ui["用户接口层<br/>REST Controller / DTO"]
    app["应用层<br/>Application Service / 用例编排"]
    domain["领域层<br/>Entity / Value Object / Domain Service / Repository Interface / Domain Event"]
    infra["基础设施层<br/>Repository Impl / MQ Client / External API Client / DB / Cache"]
    ui --- app --- domain --- infra

5.1 领域层示例

public class MediaAsset {
    private MediaAssetId id;
    private String title;
    private MediaStatus status;
    private List<MediaFile> files;
    private List<TranscodingJob> transcodingJobs;

    public void upload(MediaFile file) {
        this.files.add(file);
        this.status = MediaStatus.UPLOADED;
        registerEvent(new MediaAssetUploadedEvent(this.id));
    }

    public void completeTranscoding(TranscodingJob job) {
        this.transcodingJobs.add(job);
        this.status = MediaStatus.TRANSCODING_COMPLETED;
        registerEvent(new TranscodingCompletedEvent(this.id, job.getOutputFiles()));
    }
}

5.2 防腐层设计

与外部系统（IMDb / TMDB / PP）对接时，使用防腐层（Anti-Corruption Layer）：

public interface MetadataSourceClient {
    ExternalMetadata fetch(String externalId);
}

// IMDb 适配器
public class ImdbClientAdapter implements MetadataSourceClient {
    private final ImdbApiClient imdbClient;

    @Override
    public ExternalMetadata fetch(String externalId) {
        ImdbResponse response = imdbClient.fetch(externalId);
        return MetadataConverter.fromImdb(response);
    }
}

这样外部 API 的数据结构变化不会直接影响到我们内部的元数据模型。

六、微服务拆分过程

6.1 第一次拆分：按技术边界

早期我们按技术栈拆：

upload-service
transcoding-service
metadata-service
playback-service

结果导致一个业务操作要跨多个服务，分布式事务复杂。

6.2 第二次拆分：按领域边界

调整后按 DDD 领域拆分：

content-service（内容域）
metadata-service（元数据域）
playback-service（播放域）
user-service（用户域）
recommendation-service（推荐域）
billing-service（计费域）

每个服务有清晰的业务边界和聚合根。

6.3 服务间通信

场景	通信方式	说明
领域事件传播	RocketMQ	异步、最终一致
同步查询	HTTP / gRPC	强一致查询
配置/字典数据	Redis 缓存	高频读取

七、领域事件实现

7.1 事件定义

public class TranscodingCompletedEvent extends DomainEvent {
    private final MediaAssetId mediaAssetId;
    private final List<FileUrl> outputFiles;
    private final Instant completedAt;
}

7.2 事件发布

领域层只负责注册事件，应用层统一发布：

@Transactional
public void handleTranscodingCallback(TranscodingJobId jobId, List<FileUrl> outputs) {
    MediaAsset asset = mediaAssetRepository.findByJobId(jobId);
    asset.completeTranscoding(new TranscodingJob(jobId, outputs));

    mediaAssetRepository.save(asset);
    eventPublisher.publish(asset.getDomainEvents());
    asset.clearDomainEvents();
}

7.3 事件消费

@Component
public class PlaybackEventListener {

    @RocketMQMessageListener(topic = "content-events", selectorExpression = "TranscodingCompleted")
    public class Listener implements RocketMQListener<TranscodingCompletedEvent> {
        @Override
        public void onMessage(TranscodingCompletedEvent event) {
            playbackService.preparePlayUrls(event.getMediaAssetId(), event.getOutputFiles());
        }
    }
}

八、几次关键演进

8.1 从单体到领域化单体

第一步不是拆微服务，而是先在单体内部按领域组织代码包：

com.ftmao.iptv.content
com.ftmao.iptv.metadata
com.ftmao.iptv.playback

这样可以在不引入分布式复杂度的前提下，先验证领域划分是否合理。

8.2 从同步调用到事件驱动

转码完成后，原本播放域通过接口轮询内容域查询状态。后来改为内容域发布 TranscodingCompleted 事件，播放域订阅。

收益：

内容域和播放域解耦
新增订阅方不需要改内容域
系统扩展性更好

8.3 引入 CQRS 处理播放查询

播放接口对性能要求很高，我们单独做了读模型：

写模型：MediaAsset 聚合根
读模型：Redis 中的播放信息缓存

当内容发布或更新时，通过事件同步更新读模型。

九、踩过的坑

9.1 领域划分过细

早期我们划分了 10 多个领域，导致服务数量爆炸，运维成本剧增。

教训：领域数量要匹配团队规模。小团队 4-6 个领域足够。

9.2 领域事件丢失

消息队列配置不当，出现过领域事件丢失，导致播放域看不到新发布的内容。

教训：关键领域事件必须持久化，支持重放和补偿。

9.3 贫血领域模型

很多「DDD」项目最后变成了 Transaction Script 套壳，实体只有 getter/setter。

教训：要把业务规则和状态变更放在领域对象里，而不是 Service 里。

9.4 过度设计聚合根

一开始想把所有内容相关的东西都放到 MediaAsset 聚合根里，结果聚合根过大，事务边界混乱。

教训：聚合根要小而聚焦，跨聚合用领域事件协作。

十、效果与反思

10.1 量化效果

指标	优化前	优化后
新需求平均改动文件数	40 个	20 个
线上因耦合导致的 Bug	10 次/月	2 次/月
新成员独立上手时间	3 周	1 周

10.2 核心反思

DDD 不是先拆分微服务，而是先拆清楚业务边界。微服务是结果，不是起点。
领域事件是域间协作的核心，但事件丢失和顺序问题必须重视。
不要追求完美的领域模型，先有一个可用的模型，再迭代优化。
DDD 需要团队共识，不是架构师一个人画几张图就行的。

十一、总结

巴西 IPTV 项目让我对 DDD 有了真实的体感。它不是教科书上的概念，而是解决复杂业务系统演化问题的工程方法。

对于视频系统这类业务复杂、流程长、多团队协作的系统，DDD 能带来的最大价值是：

让每个业务概念都有清晰的归属
让系统变更的影响范围可控
让新成员能更快理解业务

如果你也在做 DDD 实践，欢迎在评论区交流领域划分和事件驱动的经验。

《领域驱动设计·精简版》详解：零基础读懂 DDD 的核心概念

Sat, 29 Jul 2023 14:00:00 +0800

《领域驱动设计·精简版》详解：零基础读懂 DDD 的核心概念

DDD 要回答的问题是：

软件是为了解决现实业务问题而存在的，可为什么代码写着写着，就和业务彻底脱节了？

Eric Evans 的答案是：问题出在"模型"上。业务在领域专家脑子里，代码在程序员手里，中间隔着层层"翻译"，每翻译一次就失真一次。DDD 的全部内容，就是围绕"如何建立一个好模型、并让模型直接活在代码里"展开的。

本文面向从未接触过 DDD 的读者，按全书结构逐章展开，配合图解和实例，帮你建立完整的知识地图。

第 1 章简介：软件为什么会偏离领域

领域与领域模型

**领域（Domain）**就是软件要解决的那个现实问题。做银行系统，金融业务就是领域；做空中交通监控，航线和飞行就是领域。

书里用了一个类比：造汽车。工人们各自负责某个零件，但如果没人理解整车，造出来的只是一堆零件的集合体，不是一辆好车。软件也一样——你不能在对金融业务一无所知的情况下写出好的银行软件。谁懂业务？不是架构师，不是分析师，是领域专家（银行的业务人员、空管的调度员）。

但领域知识是海量而杂乱的，不可能全部塞进软件。我们需要从中建立抽象——即领域模型（Domain Model）：

模型不是一张图，也不是专家脑子里的全部知识，而是"经过严格组织并进行选择性抽象的知识"。

建模意味着取舍。银行软件会记录客户的住址，但绝不会记录客户眼睛的颜色——前者是业务需要的，后者不是。选择保留什么、放弃什么，正是建模的核心工作。

书里的案例：空中交通监控系统

全书反复使用同一个例子：空中交通监控系统。飞机（Aircraft）按计划航线（Route）飞行，航线由一系列定位点（Fix）组成，每个定位点是一个三维坐标（3DPoint：经度、纬度、海拔）。系统接收雷达数据，计算飞机的真实飞行轨道，发现两架飞机航线可能交叉时向管制员报警。

最初的设计里，Route 直接关联 3DPoint，后来团队发现：地面屏幕上显示的航线其实只需要二维投影，于是模型被重构为 Route 关联 2DPoint——模型随理解的加深而演进，这正是 DDD 强调的动态过程。

第 2 章通用语言（Ubiquitous Language）

翻译是万恶之源

开发人员和领域专家说着两种语言：

开发人员满脑子是类、方法、继承、多态、框架；
领域专家满口是飞机、航线、海拔、偏航告警。

于是每次沟通都在"翻译"：开发人员把业务术语翻译成技术概念去写代码，再把技术实现翻译回业务语言去汇报。每一次翻译都丢失信息，错误理解就这样悄悄积累。更糟的是，很多时候团队连"翻译错了"都发现不了，直到软件上线才爆发。

用模型当语言的骨架

DDD 的核心原则之一：使用一种基于模型的语言进行所有交流——讨论用它，文档用它，代码里的类名、方法名也用它。因为语言贯穿所有交流形式，所以叫通用语言（Ubiquitous Language）。

flowchart LR
    subgraph 传统方式["传统方式：靠翻译，层层失真"]
        E1["领域专家<br/>（业务行话）"] -->|需求翻译| A1["分析师文档"]
        A1 -->|设计翻译| D1["开发人员"]
        D1 -->|代码实现| C1[("代码<br/>（第三套术语）")]
    end
    subgraph DDD方式["DDD 方式：一种语言贯通"]
        E2["领域专家"] <==>|"通用语言<br/>（基于领域模型）"| D2["开发人员"]
        D2 --- C2[("代码 = 模型<br/>术语完全一致")]
        E2 --- C2
    end

实例：空管系统里有个概念叫"偏航告警"。如果代码里叫 YawDeviationWarningProcessor，而管制员嘴里叫"偏航告警"，需求评审时大家讨论的是 A，代码里实现的是 B，三个月后没人能对上号。按 DDD 的做法，团队约定统一叫"偏航告警（RouteDeviationAlert）"，类名、数据库表、会议讨论全部用同一个词——模型和代码之间不再存在翻译层。

通用语言不是一次定稿的，它随模型的演进而演进：当你发现某个词说不清一件事，往往不是表达问题，而是模型有问题——这就是重构的信号。

第 3 章模型驱动设计（Model-Driven Design）

这是全书篇幅最大的一章，讲模型怎么落地成代码。Eric Evans 提供了一套标准化的"构造块"（Building Blocks）。

分层架构

先把领域层隔离出来，别让业务逻辑散落在界面和数据库代码里：

flowchart TD
    UI["用户界面层<br/>展示信息、接收输入"]
    APP["应用层<br/>协调任务、编排流程<br/>（很薄，不含业务规则）"]
    DOM["领域层<br/>★ 业务概念、业务规则、业务状态<br/>模型的家"]
    INFRA["基础设施层<br/>持久化、消息、框架支撑"]
    UI --> APP --> DOM
    INFRA -.支撑.- DOM

关键原则：领域层不依赖界面，不被基础设施污染。判断标准很简单——把界面整个换掉（比如从网页换成 App），领域层应该一行都不用改。

七个构造块

flowchart LR
    subgraph 领域层["领域层的构造块"]
        direction TB
        E["实体 Entity<br/>有身份，有生命周期"]
        VO["值对象 Value Object<br/>无身份，不可变"]
        S["服务 Service<br/>不属于任何对象的操作"]
        M["模块 Module<br/>按概念分组"]
        AGG["聚合 Aggregate<br/>一致性边界 + 聚合根"]
        F["工厂 Factory<br/>封装复杂创建"]
        R["资源库 Repository<br/>封装查询与重建"]
        AGG --> E
        AGG --> VO
        F --> AGG
        R --> AGG
    end

① 实体（Entity）：靠"身份"区分

有些对象，即使属性全变了，它还是"它"。一架飞机换了涂装、换了座椅布局，航班号 CA1234 还是那架飞机。实体由身份标识（ID）定义，而不是属性。人也是典型的实体——同名同姓的两个人依然是两个人。

② 值对象（Value Object）：靠"属性"区分

有些对象没有身份，只描述"是什么"。地址"北京市海淀区某路 1 号"就是值对象：两个地址属性完全相同，就是同一个地址，可以互换、可以共享。值对象应该是不可变的——要改就新建一个。

新手最常见的错误是把一切都建成实体。书里建议：优先考虑值对象，只有当"身份"确实重要时才用实体——值对象更简单、更安全、性能更好。

③ 服务（Service）：无家可归的操作

有些操作天然不属于任何实体或值对象。比如"转账"：钱从 A 账户到 B 账户，这个操作该挂在 A 身上还是 B 身上？都不合适。把它做成一个领域服务 TransferService。判断标准：操作的概念属于领域，但它本身是无状态的。

④ 模块（Module）：高内聚、低耦合的分组

把概念上紧密相关的类放进同一个模块。模块名也应该进入通用语言——当团队说"这是计费模块的事"，所有人都知道边界在哪。

⑤ 聚合（Aggregate）：一致性的边界

对象之间关系复杂时，改一个对象可能牵连一片。聚合的解法是：把关联紧密的对象圈进一个边界，选一个实体做"聚合根"（Aggregate Root），外部只能通过根访问内部对象。

书里的例子：客户（Customer）是聚合根，地址（Address）、联系人是内部对象。外部想要地址？找客户要，拿到的是一个拷贝，不能直接改——所有对聚合内部的修改都经过根把关，不变量（invariant）就有了守护者。

flowchart TD
    subgraph 聚合边界["聚合边界"]
        ROOT["客户 Customer<br/>（聚合根）"]
        ADDR["地址 Address"]
        CONTACT["联系人 Contact"]
        ROOT --> ADDR
        ROOT --> CONTACT
    end
    OUT["外部对象"] -->|"只能持有根的引用"| ROOT
    OUT -.->|"禁止直接访问"| ADDR

⑥ 工厂（Factory）：封装"怎么造"

创建一个复杂聚合涉及大量知识：内部结构、对象间关系、初始规则。如果让调用方自己 new 再拼装，等于"给你塑胶、橡胶、金属、硅，自己组装一台打印机"——组装知识泄漏到了所有调用点。工厂把创建逻辑收进一处，客户只要说"我要一个完整的客户聚合"。

⑦ 资源库（Repository）：封装"怎么找"

对象创建后存进数据库，之后要用时再取出来。资源库给领域对象提供一个"像集合一样"的查询接口（findById、findByName），把 SQL 和 ORM 细节全部藏在背后。领域代码面对的好像是一个内存中的对象集合，至于底下是 MySQL 还是 MongoDB，领域层不关心。

三者分工一句话：工厂管出生，资源库管找回，聚合管活着时的一致性。

第 4 章面向深层理解的重构

模型不是一次画对的。随着对业务理解的加深，团队会不断发现"原来的模型表达不了新需求"。DDD 的态度是：持续重构，并且专门朝"深层理解"的方向重构——不是消除代码重复那种技术重构，而是当领域专家随口说出一个新概念时，敏锐地意识到"这个词值得成为模型里的一等公民"。

书里称之为凸现关键概念：把隐晦的、散落在各处的业务规则，提炼成显式的类和方法。

实例：空管系统最初把"两机航线交叉判断"写在一段几百行的过程代码里。重构后，团队把它提炼成 FlightPathConflict 对象和 conflictsWith() 方法——业务规则从"代码的副作用"变成了"模型中可以直接讨论的概念"。测试可以单独写，管制员和开发可以用同一个词讨论它。

第 5 章保持模型一致性：大型项目的生存法则

前面讲的都是"一个团队、一个模型"的情况。企业级项目有多个团队并行开发，理想中"全公司统一的大模型"实际上根本维持不住——每个团队都知道自己后院里有什么，但对其他地方一无所知，改一处就可能破坏别人的功能。

Eric Evans 的结论很反直觉：不要试图维持一个注定四分五裂的大模型，而是有意识地把大模型拆成几个小模型，每个模型有清晰的边界。

界定的上下文（Bounded Context）

每个模型只在一个明确的边界内有效，这个边界叫界定的上下文。同一个词在不同上下文里可以有完全不同的含义：

实例：电商系统里"商品"这个词——

在销售上下文里，它有价格、促销、库存；
在物流上下文里，它只有重量、体积、包装方式；
在售后上下文里，它只有保修期和维修记录。

试图用一个统一的 Product 类满足三个团队，结果一定是个臃肿的"上帝类"。承认三个上下文各有各的"商品"，反而各自清晰。

flowchart LR
    subgraph 销售上下文["销售上下文"]
        P1["商品：价格/促销/库存"]
    end
    subgraph 物流上下文["物流上下文"]
        P2["商品：重量/体积/包装"]
    end
    subgraph 售后上下文["售后上下文"]
        P3["商品：保修期/维修记录"]
    end
    P1 <-->|"上下文映射<br/>（翻译）"| P2
    P2 <-->|"上下文映射"| P3

上下文之间的六种关系模式

上下文不能各自为战，它们之间需要集成。书里给出了一组模式，按"两个团队的合作意愿和权力关系"来选择：

flowchart TD
    Q{"两个上下文如何共处？"}
    Q -->|"愿意深度共享代码"| SK["共享内核 Shared Kernel<br/>划出一块双方都依赖的小模型<br/>共同维护，改动需协商"]
    Q -->|"上下游关系明确"| CS["客户-供应商 Customer-Supplier<br/>上游按下游需求规划开发"]
    Q -->|"下游无力影响上游"| CF["顺从者 Conformist<br/>直接采用上游模型，放弃翻译"]
    Q -->|"要对接脏乱差的遗留系统"| ACL["防崩溃层 Anticorruption Layer<br/>建一层翻译，把污染挡在门外"]
    Q -->|"集成成本 > 收益"| SW["独立方法 Separate Ways<br/>干脆不集成，各做各的"]
    Q -->|"一个系统被多方集成"| OHS["开放主机服务 Open Host Service<br/>定义标准协议，免去一对一翻译"]

几个重点：

上下文映射（Context Map）：把所有上下文和它们之间的关系画在一张图上。这张图是大型项目里最重要的架构文档——它让每个团队都看清"我的边界在哪、我和谁有契约"。
共享内核：两个团队共用一小部分模型（比如通用的客户标识）。共享意味着牵一发而动全身，所以内核要尽量小。
防崩溃层（ACL）：对接遗留系统时，遗留模型往往概念混乱。如果直接在自己的代码里用它的概念，好模型会被污染。ACL 是一层专门的翻译器：外面进来的是遗留概念，翻成本地模型再入内。遗留系统的"腐烂"被挡在层外。
顺从者 vs 防崩溃层：下游对上游没有话语权时，要么顺从（直接用上游模型），要么自建翻译层。前者省成本，后者保纯洁——取决于上游模型的质量。
开放主机服务：当你的系统要被十个团队集成时，给每个团队定制翻译层会把你拖垮。定义一套标准协议（比如一套公共 API），所有集成方遵循它。

精炼（Distillation）：找到核心域

大模型拆小之后还有一个问题：哪里最值得投入最优秀的人力？答案是核心域（Core Domain）——代表领域本质、构成业务竞争力的那一小块。

书里的例子非常精彩：空中交通监控系统里，“航线"看起来无处不在，但它其实是个普通概念，很多领域都有航线。系统真正的"心脏"是基于雷达数据实时计算飞行轨道、发现航线交叉并告警的那个模块——这才是这套系统区别于任何普通航线系统的本质，也是最该投入最强团队、精雕细琢的地方。其余部分（普通子域）可以外包、可以买现成组件、可以交给初级团队。

战略层面的启示：不是所有代码都值得写好。把最好的资源压在核心域上，其他地方"够用就行”。

第 6 章专访 Eric Evans

书末是 InfoQ 对 Eric Evans 的访谈，几个观点值得记住：

DDD 不是新方法，而是对二十年来优秀团队实践的系统化总结；
DDD 与敏捷并不冲突，恰恰相反——没有好模型的敏捷团队，重构会越来越吃力；
DDD 的难点不在技术，在于团队是否愿意持续地和领域专家坐在一起打磨模型和语言。

全书总结：一张 DDD 知识地图

mindmap
  root((领域驱动设计<br/>DDD))
    核心思想
      软件是领域的映射
      模型是选择性抽象
      模型直接活在代码里
    通用语言
      一种语言贯穿讨论与代码
      说不清 = 模型有问题
    模型驱动设计
      分层架构
        界面层
        应用层
        领域层
        基础设施层
      构造块
        实体 = 身份
        值对象 = 属性 + 不可变
        服务 = 无状态操作
        聚合 = 一致性边界
        工厂 = 管创建
        资源库 = 管存取
    深层理解
      持续重构
      凸现关键概念
    保持模型一致性
      界定的上下文
      上下文映射
        共享内核
        客户-供应商
        顺从者
        防崩溃层
        独立方法
        开放主机服务
      精炼出核心域

DDD 最打动人的地方在于，它把软件开发从"写代码"重新定义为"持续理解业务、并把理解精确表达出来“的过程。代码只是表达模型的介质，模型才是资产。

如果你是零基础读者，建议按这个顺序消化：先吃透"通用语言”（它不需要任何技术背景，却能立刻改善团队协作），再掌握七个构造块（写代码时随时对照），最后在有大型项目或微服务需求时再深入"界定上下文"那一套——你会发现近年火热的微服务拆分方法论，思想源头正是这本书的 Bounded Context。

《领域驱动设计》精简版：一张图看懂 DDD，引用开源 ddd-demo

Thu, 27 Jul 2023 20:00:00 +0800

《领域驱动设计》精简版：一张图看懂 DDD，引用开源 ddd-demo

这份笔记基于 Eric Evans 的《领域驱动设计》以及 Vaughn Vernon 的《实现领域驱动设计》《领域驱动设计精粹》，结合日常工程实践做了补充。文中完整代码实现参考开源项目 soulnew/ddd-demo，可直接克隆运行。

一、为什么需要 DDD？

传统分层架构（Controller → Service → DAO）的问题：

问题	表现
贫血模型	`Service` 里全是 if/else，Entity 只有 getter/setter
语义泄漏	业务术语被翻译成 `status = 1`，新人读不懂
边界模糊	一个 `OrderService` 同时处理库存、支付、物流
复用困难	同样叫“用户”，在会员、权限、订单里含义不同

DDD 的核心主张：让软件结构对齐业务领域，用业务语言写代码，用边界保护领域模型。

二、一张图：DDD 战略-战术全景

mindmap
  root((领域驱动设计 DDD))
    战略设计 Strategic Design
      领域 Domain
      子域 Subdomain
        核心域 Core
        支撑域 Supporting
        通用域 Generic
      限界上下文 Bounded Context
      上下文映射 Context Mapping
        合作关系 Partnership
        共享内核 Shared Kernel
        客户-供应商 Customer-Supplier
        遵奉者 Conformist
        防腐层 ACL
        开放主机服务 OHS
        发布语言 PL
        各行其道 Separate Ways
    战术设计 Tactical Design
      实体 Entity
      值对象 Value Object
      聚合 Aggregate
      领域服务 Domain Service
      仓储 Repository
      工厂 Factory
      领域事件 Domain Event
      应用服务 Application Service
    统一语言 Ubiquitous Language
    分层架构 Layered Architecture
      用户界面层 UI
      应用层 Application
      领域层 Domain
      基础设施层 Infrastructure

记忆口诀：先战略（划边界），后战术（建模型），全程讲“统一语言”。

三、战略设计：先画地图，再打仗

3.1 领域 = 问题空间 + 解决方案空间

graph LR
    A[问题空间<br/>Problem Space] --> B[领域 Domain<br/>业务要解决的问题]
    B --> C[子域 Subdomain<br/>可独立讨论的业务板块]
    C --> D[核心域 Core Domain<br/>竞争优势]
    C --> E[支撑域 Supporting<br/>定制但非核心]
    C --> F[通用域 Generic<br/>可外购/复用]
    D --> G[解决方案空间<br/>Solution Space]
    E --> G
    F --> G
    G --> H[限界上下文 Bounded Context<br/>一个模型只在一个上下文内有效]

示例：在线医疗平台

子域	类型	说明
问诊	核心域	核心竞争力，需精研模型
处方	支撑域	受监管约束，需定制但非差异化
支付	通用域	可直接对接微信/支付宝
消息通知	通用域	短信/推送可用第三方

3.2 限界上下文 Bounded Context

定义：限界上下文是领域模型能够保持一致性和完整性的显式边界。在边界内部，每个业务术语、概念、规则都有精确且唯一的含义；同一概念在不同限界上下文中可以拥有不同定义。它是 DDD 战略设计中保护模型不被语义污染的最小单元。

同一个业务名词，在不同上下文里含义可能完全不同。DDD 用“限界上下文”给模型画边界。

graph TB
    subgraph 商品上下文 Product Context
        P1[商品 = SKU + 价格 + 库存]
    end
    subgraph 订单上下文 Order Context
        P2[商品 = 快照 + 购买时价格 + 数量]
    end
    subgraph 物流上下文 Logistics Context
        P3[商品 = 重量 + 体积 + 易碎标识]
    end
    subgraph 营销上下文 Marketing Context
        P4[商品 = 卖点 + 优惠券适用规则]
    end
    P1 -.->|映射| P2
    P1 -.->|映射| P3
    P1 -.->|映射| P4

关键认知：不要追求“一个全局统一的数据模型”，要在上下文内部统一，在上下文之间显式映射。

3.3 上下文映射模式

定义：上下文映射模式是 DDD 中用于描述不同限界上下文之间集成关系与协作方式的战略模式集合。由于每个限界上下文都有自己的模型和统一语言，当业务流程跨越多个上下文时，需要通过上下文映射来显式定义它们如何依赖、转换与协作，从而保证边界清晰、演化可控。

graph LR
    A[上下文 A] -->|合作关系<br/>Partnership| B[上下文 B]
    C[上下文 C] -->|共享内核<br/>Shared Kernel| D[上下文 D]
    E[上游 Upstream] -->|客户-供应商<br/>Customer-Supplier| F[下游 Downstream]
    G[强势上游] -->|遵奉者<br/>Conformist| H[下游]
    I[下游] -->|防腐层 ACL| J[外部系统]
    K[开放主机服务 OHS<br/>+ 发布语言 PL] --> L[下游]
    M[上下文 M] -.->|各行其道<br/>Separate Ways| N[上下文 N]

模式	使用场景
合作关系	两个团队互相依赖，共同演进
共享内核	核心模型由双方共同维护，改动需同步
客户-供应商	上游优先服务下游需求，下游有话语权
遵奉者	上游强势（如外部 SaaS），下游无条件接受
防腐层 ACL	隔离遗留系统或外部 API，保护领域模型
开放主机服务 + 发布语言	上游提供稳定 API/协议，供多个下游消费
各行其道	关联微弱，各自独立

3.4 从限界上下文到微服务边界

限界上下文是语义边界——一个模型在这个边界内含义一致；微服务是部署边界——独立代码库、独立数据库、独立发布单元。二者不是一回事，但 DDD 划分微服务边界时，最可靠的起点就是限界上下文。

映射原则

graph LR
    A[业务领域] --> B[识别子域<br/>Core / Supporting / Generic]
    B --> C[定义限界上下文<br/>语义边界]
    C --> D{是否满足<br/>拆分条件？}
    D -->|是| E[一个微服务]
    D -->|否| F[多个上下文合并<br/>或模块化单体]
    E --> G[独立数据库<br/>独立部署<br/>API / 事件交互]

默认规则：一个限界上下文对应一个微服务。

例外情况：

情况	处理
上下文内部模块差异极大（性能、安全、团队）	可进一步拆分，但要保留相同的“统一语言”子空间
多个上下文非常小且高度协作	可合并为一个服务，内部用模块隔离
团队规模小、业务简单	先模块化单体，随演进再拆
强一致事务需求	优先放在同一服务 / 同一数据库内

拆分的启发条件

满足以下任意一条，都可以把限界上下文拆成独立微服务：

独立演进：团队能独立发布，不阻塞他人。
独立伸缩：流量特征不同，例如订单读多写少，库存强一致写频繁。
独立故障域：一个服务故障不应拖垮整个平台。
独立技术栈：某些上下文需要特殊存储（图数据库、时序数据库等）。
合规隔离：支付、医疗、金融数据需要独立部署和审计。

案例：B2C 电商的微服务边界划分

以常见的 B2C 电商为例，演示“子域 → 限界上下文 → 微服务”的完整推导过程。

第一步：识别子域

子域	类型	说明
订单	核心域	下单、状态机、优惠计算
库存	核心域	实时库存、预占、扣减
支付	通用域	对接微信 / 支付宝 / 信用卡
物流	支撑域	运单、轨迹、配送规则
商品	核心域	类目、属性、价格
营销	支撑域	优惠券、满减、秒杀
会员	支撑域	积分、等级、权益

第二步：定义限界上下文与统一语言

同一个业务名词在不同上下文里含义不同，这正是拆分的语义依据。

上下文	“商品”在该上下文中的含义	“订单”在该上下文中的含义
商品上下文	SKU、SPU、类目、主图、售价	无
订单上下文	商品快照（下单时的价格和描述）	聚合根：状态、金额、行项
库存上下文	可售数量、预占数量、仓库	无
物流上下文	重量、体积、易碎标识	发货单、包裹、运单
营销上下文	适用优惠券的商品范围	优惠分摊、实付金额

关键判断：如果两个地方对“商品”的定义和生命周期完全不同，就应分属不同上下文，也倾向于拆成不同微服务。

第三步：映射为微服务

graph TB
    subgraph 微服务边界
        P[商品服务<br/>Product Service]
        O[订单服务<br/>Order Service]
        I[库存服务<br/>Inventory Service]
        PAY[支付服务<br/>Payment Service]
        L[物流服务<br/>Logistics Service]
        M[营销服务<br/>Marketing Service]
        U[会员服务<br/>Member Service]
    end

    O -->|预占库存| I
    O -->|发起支付| PAY
    I -->|OrderPaid 事件| L
    O -->|查询商品信息| P
    O -->|计算优惠| M
    U -->|积分抵扣| O

第四步：选择上下文映射模式

关系	模式	说明
订单 → 库存	客户-供应商 + 最终一致	订单调用库存预占接口；库存发布 `InventoryReserved` 事件
订单 → 支付	开放主机服务 OHS	支付提供标准支付网关 API，多个业务共用
库存 → 物流	发布语言 PL + 领域事件	`OrderPaid` 事件触发物流创建发货单
订单 → 商品	遵奉者 / ACL	商品模型由商品服务定义，订单只保存快照
营销 → 订单	共享内核 Shared Kernel	优惠分摊算法需双方共同维护

常见反模式

反模式	问题	正确做法
按 CRUD 实体拆分	`UserService`、`OrderService`、`ProductService` 只是数据表代理	按业务能力（上下文）拆分，服务内包含完整业务规则
按前端页面拆分	一个页面一个服务	页面是组合层，服务应按领域聚合
过度拆分	一次下单调 20 个接口	先模块化单体，验证边界后再拆
共享数据库	多个服务直接操作同一张表	每个服务拥有自己的数据，通过 API / 事件交互

一句话：微服务边界不是拍脑袋定的，而是从“限界上下文”出发，结合团队、性能、合规、发布节奏再微调的结果。

四、战术设计：在限界上下文里建模型

4.1 核心概念关系图

classDiagram
    class AggregateRoot {
        +Entity root
        +invariant()
    }
    class Entity {
        +identity
        +continuity
    }
    class ValueObject {
        +immutable
        +equality by value
    }
    class DomainEvent {
        +eventId
        +occurredOn
        +payload
    }
    class Repository {
        +save(aggregate)
        +byId(id)
    }
    class DomainService {
        +cross-aggregate logic
    }
    class Factory {
        +create()
    }
    AggregateRoot --> Entity : contains
    AggregateRoot --> ValueObject : contains
    AggregateRoot --> DomainEvent : publishes
    Repository --> AggregateRoot : persists
    Factory --> AggregateRoot : creates
    DomainService --> AggregateRoot : orchestrates

4.2 实体 Entity vs 值对象 Value Object

graph LR
    subgraph Entity
        E1[Order #1001] --> E2[状态变化<br/>待支付 → 已发货 → 已完成]
        E2 --> E3[同一 identity<br/>状态变了还是它]
    end
    subgraph Value Object
        V1[Money amount=100 currency=CNY] --> V2[不可变]
        V2 --> V3[替换即新生<br/>money = money * 2]
    end

判断标准：

如果对象需要被追踪生命周期，有独立身份 → 实体
如果对象只描述属性，换了值就等于换了对象 → 值对象

五、完整设计 Demo：电商订单上下文

完整的代码实现可参考开源项目：

Gitee: soulnew/ddd-demo
https://gitee.com/soulnew/ddd-demo

该项目演示了一个典型的 DDD 工程结构，包括：

领域层：实体、值对象、聚合根、领域服务、领域事件
应用层：应用服务、Command/Query、事务编排
基础设施层：仓储实现、外部 API 适配、消息发布
接口层：Controller / API 入口

建议结合本节的战术概念，重点阅读：

domain/ 下的聚合根如何封装业务规则（如订单状态机）。
application/ 下的应用服务如何编排用例，不写业务规则。
infrastructure/ 下的仓储实现如何把领域模型映射到持久化。

如果你想快速跑通一个最小可运行示例，也可以直接克隆该项目：

git clone https://gitee.com/soulnew/ddd-demo.git

下面只保留一个最小示意图，帮助理解“充血模型”与“贫血模型”的关键差异。

5.1 充血模型 vs 贫血模型对比

贫血模型	充血模型
`OrderService` 里写 `if (status.equals("PAID"))`	`Order.pay()` 自己封装状态机
`OrderEntity` 只有 getter/setter	`Order` 有业务方法，规则集中在领域对象
规则散落在 Service	不变量、状态变更由聚合根保证
持久化即领域模型	持久化是领域模型的投影

核心原则：把“什么样合法”的判断放到领域对象里，应用服务只负责“什么时候调用”。

六、分层架构：代码放哪里？

graph TB
    subgraph 用户界面层 UI/API
        U1[Controller / Handler]
    end
    subgraph 应用层 Application
        A1[Application Service]
        A2[DTO / Command / Query]
    end
    subgraph 领域层 Domain
        D1[Entity]
        D2[Value Object]
        D3[Domain Service]
        D4[Domain Event]
        D5[Repository Interface]
    end
    subgraph 基础设施层 Infrastructure
        I1[Repository Implementation]
        I2[Message Queue]
        I3[Database]
        I4[External API Client]
    end

    U1 --> A1
    A1 --> D1
    A1 --> D3
    D1 --> D2
    D1 -.->|发布| D4
    A1 --> D5
    D5 -.->|由| I1
    I1 --> I3
    A1 -.->|发送| I2
    A1 -.->|调用| I4

依赖方向：UI → 应用 → 领域；基础设施通过接口被领域依赖（依赖倒置）。

层级	职责	不该做的事
UI	接收请求、返回响应	不直接操作 Repository
应用层	编排用例、事务、权限校验	不写业务规则
领域层	业务规则、不变量、状态变更	不依赖框架/数据库
基础设施	持久化、消息、外部调用	不侵入领域规则

七、聚合设计：四条黄金规则

graph TB
    subgraph 聚合根 Order
        O1[Order] --> L1[OrderLineItem]
        O1 --> L2[OrderLineItem]
        O1 --> M1[Money total]
        O1 --> A1[Address shipping]
        O1 --> E1[DomainEvent list]
    end
    subgraph 外部只能通过聚合根访问
        X[其他上下文] -->|byId/order.pay| O1
        X -.->|❌ 不能直接修改| L1
    end

一个聚合只有一个聚合根，外部对象只能引用聚合根 ID。
聚合内部强一致，跨聚合最终一致（用领域事件）。
小聚合优先，大聚合会成性能瓶颈和并发热点。
删除聚合根级联删除其内部对象。

反例：如果把 User 和 Order 放在同一个聚合里，用户每次下单都会锁定整个用户聚合，极端不合理。

八、领域事件：跨聚合/上下文的胶水

sequenceDiagram
    participant O as Order 聚合
    participant E as Event Bus
    participant I as Inventory 上下文
    participant L as Logistics 上下文
    O->>O: order.pay()
    O->>E: publish OrderPaid
    E->>I: consume OrderPaid
    I->>I: 扣减库存
    E->>L: consume OrderPaid
    L->>L: 创建发货单

领域事件的价值：

解耦：Order 不需要知道 Inventory 和 Logistics 的存在。
最终一致：接受短时间不一致，换取可扩展性。
审计：事件日志本身就是业务轨迹。

九、常见反模式与纠正

反模式	现象	纠正
贫血领域模型	Entity 只有字段，Service 全是逻辑	把不变规则和状态变更放回实体
万能聚合	一个聚合包含十几个实体	按业务不变量拆分，跨聚合用事件
数据库驱动建模	先建表，再写代码	先建模，再映射持久化
跨上下文直接引用	Order 直接持有 Inventory 对象	只存 ID，通过 ACL/OHS 交互
应用层写业务规则	`if order.status == ...` 散落在 Service	下放到领域对象
值对象可变	`money.setAmount(100)`	用 final 类 + 不可变字段，替换而非修改

十、什么时候用 DDD，什么时候不用？

flowchart TD
    A[项目是否复杂？] -->|否| B[简单 CRUD 即可]
    A -->|是| C[业务是否快速变化？]
    C -->|否| D[事务脚本 / 简单分层]
    C -->|是| E[团队是否愿意投入统一语言？]
    E -->|否| F[DDD 收益低]
    E -->|是| G[DDD 值得尝试]
    G --> H[从核心域开始<br/>小步迭代]

适合 DDD：

业务复杂、领域专家与开发需紧密协作
核心域需要长期演进
微服务边界模糊，需要战略设计

不适合 DDD：

简单数据录入/展示系统
生命周期短、需求稳定的项目
团队没有领域专家时间投入

十一、实战案例：新项目从 0 到 1 落地 DDD

前面讲的都是概念和 Demo，下面以 在线健身私教平台 FitCoach 为例，把“如何划分领域、子域、限界上下文、微服务，以及如何决策充血/贫血模型、如何裁剪 DDD”串成一条完整思路。

11.1 项目背景与目标

FitCoach 要做一个连接私教与学员的平台，核心能力包括：

学员购买课程包、预约上课时间、查看训练记录
教练管理学员、制定训练计划、记录每次上课内容
运营人员配置课程 SKU、促销活动、处理退款申诉
对接第三方支付、短信推送、以及第三方直播上课工具

业务不算极端复杂，但涉及“课程、预约、课时、计划、会员、支付、营销”多个概念，且预计会快速迭代。这正是 DDD 能帮上忙的地方：先把业务地图画清楚，再决定怎么写代码。

11.2 第一步：识别领域与子域

领域（Domain） 就是整个健身私教业务要解决的问题空间。通过事件风暴或用户旅程，可以识别出以下子域：

子域	类型	判断理由	投入策略
私教课程与预约	核心域	直接决定用户体验和变现效率	投入最好的领域专家和工程师
训练计划与记录	核心域	教练专业能力的载体，差异化关键	与课程域紧密协作演进
会员与教练档案	支撑域	需要定制，但不是竞争壁垒	内部实现，够用即可
支付与财务	通用域	行业通用能力	对接微信/支付宝，封装标准接口
消息通知	通用域	短信/推送/站内信	使用第三方 SaaS
内容（文章/视频）	支撑域	运营辅助，提升留存	可用开源 CMS 改造

划分子域的权衡要点：

不要从技术模块出发。例如不要先想“需要一个 UserService”，而要想“会员管理”这个业务能力。
核心域通常只有 1-2 个。如果把所有子域都标成核心，等于没有重点。
通用域不要自己造轮子。支付、通知直接买，团队精力留给核心域。
子域边界可以随业务演化。MVP 阶段可以把“训练计划”放在“课程域”里，等业务复杂后再拆出来。

11.3 第二步：划分限界上下文

划分的核心问题是：同一个业务名词，在不同地方含义是否不同？生命周期是否独立？

以“课程”这个词为例：

上下文	“课程”在该上下文中的含义	关键概念
课程目录上下文	可售卖的课程 SKU：价格、有效期、适用人群、退费规则	CourseCatalog, PricePolicy
预约调度上下文	一次具体的上课时间：教练、学员、时段、状态	Appointment, TimeSlot
训练记录上下文	一次实际上课产生的记录：消耗课时、训练内容、教练反馈	TrainingRecord, ConsumedSession
营销上下文	参与促销的课程范围：满减、套餐、优惠券适用	PromotionRule, Bundle
财务上下文	课程订单的应收、实收、退款流水	CourseOrder, Refund

因为“课程”的含义和生命周期在每个上下文里都不同，所以应该拆成不同的限界上下文。FitCoach 最终划分如下：

课程目录上下文（Course Catalog Context）
预约调度上下文（Scheduling Context）
训练记录上下文（Training Record Context）
会员上下文（Member Context）
教练上下文（Coach Context）
支付上下文（Payment Context）
营销上下文（Marketing Context）
消息通知上下文（Notification Context）

关键判断：如果两个地方对同一个名词的定义和生命周期不同，就倾向于拆成不同上下文；如果概念高度一致且总是一起变化，可以合并。

11.4 第三步：推导微服务边界

默认规则是一个限界上下文对应一个微服务，但 FitCoach 还要考虑团队规模、数据一致性、发布频率、性能特征。

限界上下文	微服务决策	决策理由
课程目录	独立服务	变化频繁，运营经常调整 SKU 和价格
预约调度	独立服务	高并发读，学员大量刷可选时段，需单独伸缩
训练记录	独立服务	写多读少，数据量大，未来可能要独立归档
会员 + 教练档案	合并为“账户服务”	MVP 阶段都很薄，且登录后经常一起查询；内部用模块隔离
支付	独立服务	涉及资金安全、合规审计、对接第三方
营销	独立服务	活动频繁，不能影响核心预约链路
消息通知	独立服务	可被多个业务复用，适合独立演进

合并的例外处理：

会员和教练虽然业务概念不同，但 MVP 阶段数据模型简单，合并可以减少一次远程调用。
如果后续教练业务复杂化（排期、评级、分成、资质认证），再把教练上下文拆成独立服务。

一句话：微服务边界从限界上下文出发，再结合团队、性能、合规、数据一致性做微调。

11.5 第四步：选择上下文映射模式

不同上下文之间不是孤立的，需要显式定义它们如何协作。

graph LR
    A[预约上下文] -->|Customer-Supplier| B[课程目录上下文]
    C[训练记录上下文] -->|Customer-Supplier| A
    D[支付上下文] -->|OHS + PL| E[预约上下文]
    F[营销上下文] -->|Shared Kernel| A
    G[消息通知上下文] -->|Conformist| H[短信/推送第三方]
    I[账户服务] -->|OHS + PL| J[所有业务服务]
    K[训练记录上下文] -->|ACL| L[直播上课工具]

关系	模式	说明
预约 → 课程目录	客户-供应商	预约需要课程的名称、价格、时长；课程目录提供稳定查询接口
训练记录 → 预约	客户-供应商	训练记录基于已完成的预约生成
支付 → 各业务	开放主机服务 OHS	支付提供统一的收款、退款、对账 API
营销 → 预约	共享内核 Shared Kernel	促销分摊、优惠券核销规则需要双方共同维护
消息通知 → 第三方	遵奉者 Conformist	直接调用第三方 SDK，模型由第三方定义
训练记录 → 直播工具	防腐层 ACL	直播工具接口不稳定，通过 ACL 隔离，保护领域模型

11.6 第五步：充血模型 vs 贫血模型决策

DDD 并不要求全场充血。模型选择应该看该上下文的业务复杂度，而不是追求统一风格。

上下文	推荐模型	理由
预约调度	充血模型	状态机复杂：待预约 → 已预约 → 已签到 → 已完成 → 已取消；有取消规则、爽约规则
训练记录	充血模型	记录不可变，但课时消耗计算、教练评分聚合有业务规则
课程目录	贫血模型可接受	主要是 CRUD，业务规则少
账户服务	贫血模型	数据管理为主，验证规则简单
消息通知	贫血/过程式	基本是发送逻辑，无复杂领域规则
营销	充血模型	优惠计算、互斥规则、分摊逻辑复杂

预约上下文的充血模型示例：

public class Appointment {
    private AppointmentId id;
    private TimeSlot timeSlot;
    private MemberId memberId;
    private CoachId coachId;
    private AppointmentStatus status;
    private List<DomainEvent> domainEvents = new ArrayList<>();

    public void cancel(LocalDateTime now) {
        if (status != AppointmentStatus.BOOKED) {
            throw new DomainException("只能取消已预约的课程");
        }
        if (timeSlot.start().minusHours(24).isBefore(now)) {
            throw new DomainException("开课 24 小时内不可取消");
        }
        this.status = AppointmentStatus.CANCELLED;
        domainEvents.add(new AppointmentCancelled(id, now));
    }

    public void checkIn(LocalDateTime now) {
        if (status != AppointmentStatus.BOOKED) {
            throw new DomainException("未预约不能签到");
        }
        this.status = AppointmentStatus.COMPLETED;
        domainEvents.add(new AppointmentCheckedIn(id, memberId, coachId, now));
    }
}

决策口诀：

状态机复杂、不变量多、业务规则变化快 → 充血模型
主要是增删改查、数据为主、规则简单 → 贫血模型即可
不确定时，先写贫血，等规则复杂了再重构为充血

11.7 第六步：DDD 是否可以裁剪？

可以，而且应该根据项目情况裁剪。 DDD 不是全有或全无的框架。

场景 1：只用战略设计，战术设计从简

适合情况：业务复杂但技术栈简单、团队经验不足、MVP 阶段要快速上线。
FitCoach 初期做法：先画好限界上下文和微服务边界，服务内部用简单 CRUD + Service 实现。
价值：至少解决了“边界混乱、术语不一致、重复造轮子”的问题。

场景 2：只用战术设计，在已有边界内建模

适合情况：系统边界已经清楚，但某个模块内部逻辑混乱（如遗留系统重构）。
FitCoach 示例：课程目录已经稳定，但预约状态机满是 if/else，可以只对“预约上下文”做充血模型重构。
风险：如果战略边界本身不清晰，战术设计会变成“在错误的地方做正确的事”。

场景 3：战略 + 战术都用，但不用高级模式

这是最常见的落地方式。
FitCoach 可以用：限界上下文 + 充血模型 + 领域事件 + 分层架构。
可以先不用：事件溯源、CQRS、六边形架构的严格形式。

裁剪原则

复杂的地方用 DDD，简单的地方不要硬套。
先战略后战术，边界不清不要深入建模型。
一个项目可以不同上下文用不同成熟度：核心域充血 + 贫血，通用域直接用 SDK。
不要为了 DDD 而 DDD，目标是降低业务复杂度，不是写出“DDD 标准代码”。

11.8 落地时间线建议

阶段	目标	关键产出
Week 1-2	事件风暴 + 统一语言	子域图、限界上下文图、术语表
Week 3	微服务边界与映射模式	服务拆分方案、接口契约初稿
Week 4-6	核心域战术设计	聚合、实体、值对象、领域事件、测试
Week 7-8	基础设施 + 集成测试	数据库、消息队列、CI/CD 流水线
持续	演进	根据业务变化调整边界和模型

新手常犯的错误：一上来就在所有服务里写聚合根、值对象、领域事件。正确做法是先画地图，再对核心域精雕细琢，其他域能跑通即可。

十二、一句话总结

DDD = 用“统一语言”沟通业务，用“限界上下文”划分边界并推导微服务边界，用“聚合/实体/值对象”封装领域知识，用“领域事件”连接上下文，让软件结构真正反映业务结构。

把 soulnew/ddd-demo 的 Demo 跑一遍，再画一张你自己业务的战略地图，并尝试标出可能的微服务边界，你就已经比 80% 自称做 DDD 的人更接近它的本质了。

参考

Eric Evans. Domain-Driven Design: Tackling Complexity in the Heart of Software
Vaughn Vernon. Implementing Domain-Driven Design
Vaughn Vernon. Domain-Driven Design Distilled

领域驱动设计 on 方糖猫Blog

视频系统 DDD 实战：巴西 IPTV 项目的领域拆分

视频系统 DDD 实战：巴西 IPTV 项目的领域拆分

一、项目背景

二、为什么需要 DDD？

2.1 早期的问题

2.2 DDD 带来的改变

三、领域划分

3.1 核心域识别

3.2 域间关系

四、内容域详细设计

4.1 聚合根设计

4.2 关键领域事件

4.3 状态流转

五、分层架构

5.1 领域层示例

5.2 防腐层设计

六、微服务拆分过程

6.1 第一次拆分：按技术边界

6.2 第二次拆分：按领域边界

6.3 服务间通信

七、领域事件实现

7.1 事件定义

7.2 事件发布

7.3 事件消费

八、几次关键演进

8.1 从单体到领域化单体

8.2 从同步调用到事件驱动

8.3 引入 CQRS 处理播放查询

九、踩过的坑

9.1 领域划分过细

9.2 领域事件丢失

9.3 贫血领域模型

9.4 过度设计聚合根

十、效果与反思

10.1 量化效果

10.2 核心反思

十一、总结

《领域驱动设计·精简版》详解：零基础读懂 DDD 的核心概念

《领域驱动设计·精简版》详解：零基础读懂 DDD 的核心概念

第 1 章 简介：软件为什么会偏离领域

领域与领域模型

书里的案例：空中交通监控系统

第 2 章 通用语言（Ubiquitous Language）

翻译是万恶之源

用模型当语言的骨架

第 3 章 模型驱动设计（Model-Driven Design）

分层架构

七个构造块

① 实体（Entity）：靠"身份"区分

② 值对象（Value Object）：靠"属性"区分

③ 服务（Service）：无家可归的操作

④ 模块（Module）：高内聚、低耦合的分组

⑤ 聚合（Aggregate）：一致性的边界

⑥ 工厂（Factory）：封装"怎么造"

⑦ 资源库（Repository）：封装"怎么找"

第 4 章 面向深层理解的重构

第 5 章 保持模型一致性：大型项目的生存法则

界定的上下文（Bounded Context）

上下文之间的六种关系模式

精炼（Distillation）：找到核心域

第 6 章 专访 Eric Evans

全书总结：一张 DDD 知识地图

《领域驱动设计》精简版：一张图看懂 DDD，引用开源 ddd-demo

《领域驱动设计》精简版：一张图看懂 DDD，引用开源 ddd-demo

一、为什么需要 DDD？

二、一张图：DDD 战略-战术全景

三、战略设计：先画地图，再打仗

3.1 领域 = 问题空间 + 解决方案空间

3.2 限界上下文 Bounded Context

3.3 上下文映射模式

3.4 从限界上下文到微服务边界

映射原则

拆分的启发条件

案例：B2C 电商的微服务边界划分

第一步：识别子域

第二步：定义限界上下文与统一语言

第三步：映射为微服务

第四步：选择上下文映射模式

常见反模式

第 1 章简介：软件为什么会偏离领域

第 2 章通用语言（Ubiquitous Language）

第 3 章模型驱动设计（Model-Driven Design）

第 4 章面向深层理解的重构

第 5 章保持模型一致性：大型项目的生存法则

第 6 章专访 Eric Evans