← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共7章,点击直达)
一、DDD核心概念二、战术设计三、DDD架构模式四、Spring Boot DDD落地五、DDD与微服务六、面试高频综合题面试速记口诀

Q124 DDD领域驱动设计与架构实战

20K Java+AI 岗位高频考点 — DDD是应对复杂业务系统的核心方法论,大厂面试常考限界上下文、聚合设计、六边形架构。覆盖战略设计、战术设计、Spring Boot落地、微服务拆分。

一、DDD核心概念

1. DDD的核心概念?


领域(Domain):业务知识和规则的总和
子域(Subdomain):
  - 核心域(Core):企业核心竞争力(如推荐算法)
  - 支撑域(Supporting):支撑核心域(如认证)
  - 通用域(Generic):通用能力(如邮件)

限界上下文(Bounded Context):领域的边界
  - 同一个词在不同上下文中含义不同
  - 每个 Context 有自己的模型、数据库、团队
  - 是微服务拆分的核心依据

统一语言(Ubiquitous Language):
  - 开发和业务使用相同的术语
  - 代码命名与业务概念一致

2. 战略设计 vs 战术设计?


战略设计(宏观):
- 子域划分
- 限界上下文定义
- 上下文映射关系
- Event Storming

战术设计(微观):
- Entity(实体)
- Value Object(值对象)
- Aggregate(聚合)
- Repository(仓储)
- Domain Service(领域服务)
- Domain Event(领域事件)
- Factory(工厂)

3. 限界上下文映射关系?


合作关系( Partnership ):两个上下文协同开发
共享内核( Shared Kernel ):共享部分模型
客户-供应商( Customer-Supplier ):下游依赖上游
遵循者( Conformist ):完全遵循上游模型
防腐层( ACL ):隔离外部模型的适配层
开放主机服务( OHS ):上游提供标准协议
发布语言( Published Language ):标准的事件/DTO格式

实际应用:
订单Context → 调用 → 支付Context
            → 用ACL隔离支付接口变化
            → 通过OHS+PL发布订单事件

二、战术设计

4. Entity vs Value Object?


Entity(实体):
- 有唯一标识(ID)
- 有生命周期
- 可变
- 示例:User(id=1, name="张三") → name可改,ID不变

Value Object(值对象):
- 无唯一标识
- 不可变(Immutable)
- 通过属性判断相等
- 示例:Address(city, street, zipCode)、Money(amount, currency)

Java实现:
public record Money(BigDecimal amount, String currency) {
    public Money {
        if (amount.compareTo(BigDecimal.ZERO) < 0)
            throw new IllegalArgumentException("金额不能为负");
    }
    public Money add(Money other) {
        return new Money(amount.add(other.amount), currency);
    }
}

5. Aggregate(聚合)?


聚合:一组相关对象的集合,作为数据修改的单元

聚合根(Aggregate Root):
- 聚合的入口对象
- 外部只能通过聚合根访问聚合内对象
- 保证聚合内的一致性

规则:
1. 聚合要小(只包含必须一起修改的对象)
2. 聚合间通过ID引用(不直接引用对象)
3. 一次事务只修改一个聚合
4. 聚合内强一致性,聚合间最终一致性

示例:
Order(聚合根) → OrderItem(内部实体) → Money(值对象)
  |
  ├── 用户ID(引用其他聚合,只存ID)
  └── 地址(值对象)

6. Repository(仓储)?


// 仓储接口定义在领域层,实现在基础设施层
public interface OrderRepository {
    Order findById(OrderId id);
    void save(Order order);
    List<Order> findByUserId(String userId);
}

// 实体包含业务逻辑
public class Order extends AggregateRoot {
    private OrderId id;
    private List<OrderItem> items;
    private OrderStatus status;

    // 业务方法(充血模型)
    public void addItem(Product product, int quantity) {
        if (status != OrderStatus.CREATED) throw new DomainException("订单已确认");
        items.add(new OrderItem(product.getId(), product.getPrice(), quantity));
    }

    public void confirm() {
        if (items.isEmpty()) throw new DomainException("订单不能为空");
        this.status = OrderStatus.CONFIRMED;
        registerEvent(new OrderConfirmedEvent(this.id));
    }
}

7. Domain Service(领域服务)?


// 不属于任何实体的业务逻辑
@Service
public class OrderDomainService {
    public Money calculateTotal(Order order) {
        return order.getItems().stream()
            .map(item -> item.getPrice().multiply(item.getQuantity()))
            .reduce(Money.ZERO, Money::add);
    }

    public boolean canCancel(Order order) {
        return order.getStatus() == OrderStatus.CREATED
            && Duration.between(order.getCreatedAt(), Instant.now()).toHours() < 24;
    }
}

8. Domain Event(领域事件)?


// 领域事件定义
public record OrderCreatedEvent(OrderId orderId, String userId, Money total, Instant occurredOn)
    implements DomainEvent {}

public record OrderPaidEvent(OrderId orderId, String paymentId, Instant occurredOn)
    implements DomainEvent {}

// 聚合根发布事件
public abstract class AggregateRoot {
    private final List<DomainEvent> events = new ArrayList<>();

    protected void registerEvent(DomainEvent event) {
        events.add(event);
    }

    public List<DomainEvent> pullEvents() {
        List<DomainEvent> copy = new ArrayList<>(events);
        events.clear();
        return copy;
    }
}

// Spring ApplicationEventPublisher集成
@Component
public class DomainEventPublisher {
    @Autowired ApplicationEventPublisher publisher;

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void publishAfterCommit(List<DomainEvent> events) {
        events.forEach(publisher::publishEvent);
    }
}

三、DDD架构模式

9. 分层架构?


┌─────────────────────────┐
│   Interface(接口层)       │  Controller、DTO
├─────────────────────────┤
│   Application(应用层)     │  Application Service、编排
├─────────────────────────┤
│   Domain(领域层)          │  Entity、VO、Aggregate、DomainService
├─────────────────────────┤
│   Infrastructure(基础设施) │  Repository实现、外部服务、MQ
└─────────────────────────┘

依赖规则:上层依赖下层,领域层不依赖任何层

目录结构:
com.example.order/
├── interfaces/         # 接口层
│   ├── controller/
│   ├── dto/
│   └── assembler/      # DTO ↔ Entity转换
├── application/        # 应用层
│   ├── service/
│   └── command/
├── domain/             # 领域层
│   ├── model/          # 聚合、实体、值对象
│   ├── repository/     # 仓储接口
│   ├── service/        # 领域服务
│   └── event/          # 领域事件
└── infrastructure/     # 基础设施
    ├── repository/     # 仓储实现
    ├── client/         # 外部服务调用
    └── mq/             # 消息队列

10. 六边形架构(端口适配器)?


        ┌──────────────────────┐
        │                      │
  HTTP ─┤  Driving Adapter     │
  gRPC ─┤  (入站适配器)         │
  CLI  ─┤                      │
        │  ┌──────────────┐   │
        │  │   Port(端口)   │   │
        │  │  ┌──────────┐ │   │
        │  │  │  Domain   │ │   │
        │  │  │  (核心)   │ │   │
        │  │  └──────────┘ │   │
        │  │  Port(端口)    │   │
        │  └──────────────┘   │
        │  Driven Adapter     │
  DB  ──┤  (出站适配器)        │
  MQ  ──┤                      │
  API ──┤                      │
        └──────────────────────┘

核心:Domain不依赖任何外部,通过端口(Port接口)与外部交互

11. CQRS(命令查询职责分离)?


// Command(写) - 通过聚合根修改
@Service
public class OrderCommandService {
    @Autowired OrderRepository orderRepo;

    public OrderId createOrder(CreateOrderCommand cmd) {
        Order order = Order.create(cmd.getUserId(), cmd.getItems());
        orderRepo.save(order);
        return order.getId();
    }
}

// Query(读) - 直接查DTO,不走聚合根
@Service
public class OrderQueryService {
    @Autowired JdbcTemplate jdbc;

    public OrderDTO getOrder(String orderId) {
        return jdbc.queryForObject("SELECT * FROM order_view WHERE id = ?",
            (rs, rowNum) -> new OrderDTO(rs.getString("id"), ...), orderId);
    }
}

// 读写分离的数据库:
// 写库:规范化(3NF),保证一致性
// 读库:反范式化(宽表/视图),优化查询性能

12. Event Sourcing(事件溯源)?


传统:存储当前状态(UPDATE orders SET status = 'PAID' WHERE id = 1)
ES:存储所有事件(INSERT INTO events (type, data) VALUES ('OrderPaid', ...))

重建状态:回放所有事件 → 得到当前状态

优势:
- 完整审计日志
- 时间旅行(恢复到任意时刻的状态)
- 天然CQRS

劣势:
- 复杂度高
- 事件不可变(不能"忘记")

Java实现:
public class OrderEventSourced {
    private List<OrderEvent> events = new ArrayList<>();
    private OrderState state = new OrderState();

    public void apply(OrderEvent event) {
        events.add(event);
        state = state.apply(event);  // 事件驱动状态变更
    }

    public static OrderEventSourced rebuild(List<OrderEvent> history) {
        OrderEventSourced order = new OrderEventSourced();
        history.forEach(order::apply);
        return order;
    }
}

四、Spring Boot DDD落地

13. 聚合的Spring Data实现?


// JPA聚合根
@Entity
@Table(name = "orders")
public class Order {
    @EmbeddedId private OrderId id;
    @Enumerated(EnumType.STRING) private OrderStatus status;
    @Embedded private Address shippingAddress;

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "order_id")
    private List<OrderItem> items = new ArrayList<>();

    @DomainEvents  // Spring Data发布领域事件
    public List<Object> domainEvents() {
        return pullEvents().stream().map(Object.class::cast).toList();
    }

    @AfterDomainEventPublication
    public void clearEvents() {
        pullEvents();
    }
}

// 值对象
@Embeddable
public record OrderId(@Column(name = "order_id") String value) {
    public OrderId { if (value == null) throw new IllegalArgumentException(); }
    public static OrderId generate() { return new OrderId(UUID.randomUUID().toString()); }
}

14. Application Service编排?


@Service
@Transactional
public class OrderApplicationService {
    @Autowired OrderRepository orderRepo;
    @Autowired PaymentGateway paymentGateway;
    @Autowired DomainEventPublisher eventPublisher;

    public OrderId createOrder(CreateOrderCommand cmd) {
        // 1. 创建聚合
        Order order = Order.create(cmd.getUserId(), cmd.toItems());

        // 2. 业务规则校验
        order.validate();

        // 3. 持久化
        orderRepo.save(order);

        // 4. 发布领域事件
        eventPublisher.publishAll(order.pullEvents());

        return order.getId();
    }
}

五、DDD与微服务

15. 限界上下文=微服务边界?


经验法则:
1. 一个限界上下文 → 一个微服务
2. 限界上下文内的聚合可部署为独立模块
3. 跨上下文通信:异步事件(最终一致性)

不适合的场景:
- 团队小(<10人)→ 模块化单体更合适
- 业务简单 → 不要过度设计

演进路径:
模块化单体 → 模块边界清晰 → 按需拆分为微服务

16. 跨上下文数据一致性?


订单上下文 → 支付上下文 → 库存上下文

方案:
1. 领域事件 + 异步消息
2. Saga编排(正向+补偿)
3. 定时对账兜底

Spring实现:
@EventListener
public void onOrderCreated(OrderCreatedEvent event) {
    // 启动Saga:扣库存 → 支付 → 确认订单
    sagaManager.start("order-process", event);
}

六、面试高频综合题

17. DDD vs MVC/三层架构?

维度三层架构DDD
核心关注技术分层业务领域
业务逻辑Service层(贫血模型)领域模型(充血模型)
复杂度简单场景复杂业务
代码组织按技术职责按业务领域
适用CRUD应用复杂业务系统

18. DDD的学习曲线?


常见问题:
1. 过度设计:简单CRUD用DDD反而复杂
2. 聚合划太大:导致性能瓶颈
3. 事件滥用:所有操作都走事件
4. 忽略业务:技术驱动而非业务驱动

建议:
1. 先从模块化包结构开始
2. 用充血模型(业务逻辑在Entity中)
3. 逐步引入值对象和聚合
4. Event Storming工作坊对齐业务

19. 如何推行DDD到团队?


步骤:
1. Event Storming工作坊:业务方+开发一起梳理
2. 划分子域和限界上下文
3. 先在一个模块试点DDD
4. 建立充血模型规范
5. Code Review强调领域模型质量
6. 渐进推广到其他模块

关键:
- 业务方参与(不是技术自嗨)
- 统一语言(代码命名与业务术语一致)
- 先战略后战术(先划清边界再设计模型)

面试速记口诀

DDD三核心:子域划分、限界上下文、统一语言

>

战术五要素:实体(有ID)、值对象(不可变)、聚合(一致性边界)、仓储(持久化)、领域事件(解耦)

>

架构三模式:分层(依赖规则)、六边形(端口适配)、CQRS(读写分离)

>

落地三步:先战略划边界→再战术建模型→最后微服务拆分