DDD 学习笔记：从领域原语到限界上下文

- 领域划分、明确边界、统一语言
- 限界上下文划分、上下文关系梳理
- 模块结构组织
- 建模
- 编码

String     → EmailAddress、AccountId
BigDecimal → Money、Percentage
两个 Date   → DateRange

register(String email, String phone);

register(EmailAddress email, PhoneNumber phone);

基础类型
String / Long / BigDecimal
        ↓ 封装业务语义
领域原语 DP
EmailAddress / AccountId / Money / Percentage
        ↓ 组成
实体 Entity
Customer / Account / OrderLine
        ↓ 组成并维护整体一致性
聚合 Aggregate
Order / BankAccount
        ↓ 多个领域对象都不适合承担时
领域服务 Domain Service

外部请求 DTO → 转换与校验 → DP → 实体或聚合

用户改了姓名，仍然是同一个用户；
订单修改了地址，仍然是同一个订单。

order.setStatus(PAID);

order.pay(payment);
order.cancel(reason);
order.ship(trackingNumber);

class Order {
    private OrderStatus status;
 
    public void cancel() {
        if (status == SHIPPED) {
            throw new DomainException("已发货订单不能取消");
        }
        status = CANCELLED;
    }
}

Order           → Entity
OrderId         → DP
ShippingAddress → Value Object
Money           → DP / Value Object

order.updateStatus(3);

order.cancel(reason);
order.confirmPayment(payment);
order.ship(trackingNumber);

销售上下文：客户是销售线索和跟进对象
订单上下文：客户是下单人
物流上下文：客户是收货相关方
财务上下文：客户是付款与开票主体

名词：订单、付款、发货单
动词：下单、支付、取消、发货
规则：已发货订单不能取消

Order 聚合
├── Order                 ← 聚合根
├── OrderLine             ← 内部实体
├── ShippingAddress       ← 值对象
└── Money                 ← DP / 值对象

order.addProduct(productId, quantity, price);
order.changeAddress(address);
order.cancel(reason);

orderLine.setQuantity(quantity);

class Order {
    private CustomerId customerId;
}

class Order {
    private Customer customer;
}

电商系统
├── 商品上下文
│   └── Product：描述、类目、售价
├── 订单上下文
│   └── Product：商品快照
├── 库存上下文
│   └── Product：库存单位
└── 物流上下文
    └── Product：待运输物品

订单上下文的 OrderPaid
        ↓ 事件 / DTO
物流上下文转换
        ↓
Shipment

限界上下文
└── 领域模型
    ├── 聚合 A
    │   └── 聚合根
    ├── 聚合 B
    │   └── 聚合根
    └── 领域服务

限界上下文划分模型边界；
聚合划分一致性边界；
聚合根控制聚合访问边界。

未追踪 + 对        → 仍不追踪
任意状态 + 错/勉强 → 薄弱，连续答对次数归零
薄弱 + 对          → 观察中
观察中 + 对        → 销账，从台账移除

from dataclasses import dataclass
from enum import StrEnum
 
 
class Verdict(StrEnum):
    CORRECT = "对"
    PARTIAL = "勉强"
    WRONG = "错"
 
 
class ConceptState(StrEnum):
    WEAK = "薄弱"
    OBSERVING = "观察中"
 
 
@dataclass(frozen=True)
class KnowledgeItemId:
    value: str
 
    def __post_init__(self) -> None:
        if not self.value.strip():
            raise ValueError("KnowledgeItemId 不能为空")
 
 
@dataclass(frozen=True)
class ConceptRecord:
    item_id: KnowledgeItemId
    state: ConceptState
    consecutive_correct: int
 
    def __post_init__(self) -> None:
        expected = 0 if self.state is ConceptState.WEAK else 1
        if self.consecutive_correct != expected:
            raise ValueError("状态与连续答对次数不一致")
 
 
def apply_verdict(
    record: ConceptRecord | None,
    verdict: Verdict,
    *,
    item_id: KnowledgeItemId,
) -> ConceptRecord | None:
    if verdict in {Verdict.PARTIAL, Verdict.WRONG}:
        return ConceptRecord(
            item_id=item_id,
            state=ConceptState.WEAK,
            consecutive_correct=0,
        )
 
    if record is None:
        return None
 
    if record.state is ConceptState.OBSERVING:
        return None
 
    return ConceptRecord(
        item_id=item_id,
        state=ConceptState.OBSERVING,
        consecutive_correct=1,
    )

from dataclasses import dataclass
from typing import Protocol
 
 
@dataclass(frozen=True)
class ConceptStateChanged:
    item_id: KnowledgeItemId
    before: ConceptState | None
    after: ConceptState | None
 
 
class ConceptProgress:
    def __init__(
        self,
        item_id: KnowledgeItemId,
        record: ConceptRecord | None = None,
    ) -> None:
        self.item_id = item_id
        self._record = record
 
    def record_verdict(
        self,
        verdict: Verdict,
    ) -> ConceptStateChanged:
        before = self._record
        self._record = apply_verdict(
            before,
            verdict,
            item_id=self.item_id,
        )
 
        return ConceptStateChanged(
            item_id=self.item_id,
            before=before.state if before else None,
            after=self._record.state if self._record else None,
        )
 
    @property
    def state(self) -> ConceptState | None:
        return self._record.state if self._record else None
 
 
class ConceptProgressRepository(Protocol):
    def load(self, item_id: KnowledgeItemId) -> ConceptProgress: ...
    def save(self, progress: ConceptProgress) -> None: ...
 
 
class EventPublisher(Protocol):
    def publish(self, event: ConceptStateChanged) -> None: ...
 
 
def record_assessment_result(
    *,
    item_id: KnowledgeItemId,
    verdict: Verdict,
    repository: ConceptProgressRepository,
    events: EventPublisher,
) -> None:
    progress = repository.load(item_id)
    event = progress.record_verdict(verdict)
    repository.save(progress)
    events.publish(event)

def test_wrong_then_two_correct_answers_discharge_memory() -> None:
    item_id = KnowledgeItemId("ddd.aggregate")
    progress = ConceptProgress(item_id)
 
    progress.record_verdict(Verdict.WRONG)
    assert progress.state is ConceptState.WEAK
 
    progress.record_verdict(Verdict.CORRECT)
    assert progress.state is ConceptState.OBSERVING
 
    progress.record_verdict(Verdict.CORRECT)
    assert progress.state is None
 
 
def test_wrong_answer_resets_observing_concept() -> None:
    item_id = KnowledgeItemId("ddd.bounded-context")
    progress = ConceptProgress(item_id)
 
    progress.record_verdict(Verdict.WRONG)
    progress.record_verdict(Verdict.CORRECT)
    progress.record_verdict(Verdict.PARTIAL)
 
    assert progress.state is ConceptState.WEAK

统一语言
  → KnowledgeItem / 薄弱 / 观察中 / 销账
 
领域原语
  → KnowledgeItemId
 
值对象与不变量
  → ConceptRecord
 
聚合根
  → ConceptProgress
 
跨边界契约
  → ConceptProgressRepository / EventPublisher
 
可执行规则
  → 状态机测试