← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共9章,点击直达)
一、DDD基础概念二、战术设计三、架构模式四、Spring Boot落地实践五、常见面试题六、DDD与设计模式七、事件溯源(Event Sourcing)八、综合实战面试速记口诀

Q98 DDD领域驱动设计落地实战

20K Java+AI 岗位高频考点 — DDD是复杂业务系统的架构利器,大厂面试必问。覆盖战略设计(限界上下文/上下文映射)、战术设计(聚合/实体/值对象/领域事件)、六边形架构、CQRS、与Spring Boot落地实践。

一、DDD基础概念

1. 什么是DDD?为什么需要DDD?

DDD(Domain-Driven Design)是Eric Evans提出的软件设计方法论,核心思想是以业务领域为中心驱动软件设计。

解决的痛点:

DDD的核心价值:

1. 统一语言(Ubiquitous Language):开发与业务用相同的术语

2. 领域建模:将业务知识转化为软件模型

3. 边界划分:通过限界上下文划分系统边界

2. DDD的战略设计和战术设计分别是什么?

战略设计(Strategic Design):宏观层面

战术设计(Tactical Design):微观层面

3. 核心域、支撑域、通用域的区别?

面试答题:优先投入核心域,通用域可采购SaaS,支撑域可简化。

4. 限界上下文(Bounded Context)是什么?

限界上下文是DDD中最重要的概念,是语言的边界。同一个词在不同上下文中含义不同。

示例:电商系统中的"商品"

限界上下文 = 微服务边界:每个限界上下文通常对应一个独立的微服务。

5. 上下文映射(Context Map)的几种关系?

关系说明示例
共享内核(Shared Kernel)两个上下文共享部分模型共用的Address值对象
遵循者(Conformist)下游完全遵循上游模型使用第三方支付API
开放主机服务(OHS)上游提供标准API支付平台对外API
防腐层(ACL)下游做适配,隔离上游变化适配第三方物流接口
分道扬镳(Separate Ways)完全独立,不集成各自实现通知功能

防腐层(Anti-Corruption Layer)最重要:在集成外部系统时,用ACL隔离外部模型对内部领域的侵蚀。


二、战术设计

6. 实体(Entity)和值对象(Value Object)的区别?

维度EntityValue Object
标识有唯一ID无独立ID
可变性可变不可变
相等性ID相等即相等所有属性相等即相等
生命周期独立生命周期依附于实体

// Entity - 有ID,可变
public class Order {
    private OrderId id;           // 唯一标识
    private OrderStatus status;   // 可变状态
    private List<OrderItem> items;

    public void addItem(Product product, int quantity) {
        items.add(new OrderItem(product.getId(), product.getPrice(), quantity));
    }

    public void cancel() {
        if (status != OrderStatus.CREATED) {
            throw new DomainException("只能取消待支付的订单");
        }
        status = OrderStatus.CANCELLED;
    }
}

// Value Object - 无ID,不可变
public record Money(BigDecimal amount, Currency currency) {
    public Money {
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new DomainException("金额不能为负");
        }
    }
    public Money add(Money other) {
        return new Money(amount.add(other.amount), currency);
    }
}

public record Address(String province, String city, String detail) {}

7. 聚合(Aggregate)和聚合根(Aggregate Root)?

聚合:一组相关实体的集合,作为一个整体操作。

聚合根:聚合的入口实体,外部只能通过聚合根访问聚合内的对象。

设计原则:

1. 聚合要小:只包含必须一起一致的实体

2. 聚合根负责维护聚合内的不变量(Invariant)

3. 聚合之间通过ID引用,不直接引用对象

4. 一个事务只修改一个聚合


// 聚合根:Order
public class Order extends BaseAggregateRoot<OrderId> {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderItem> items;      // 聚合内实体
    private Money totalAmount;
    private OrderStatus status;
    private Address shippingAddress;    // 值对象

    // 业务方法 - 维护不变量
    public void addItem(ProductId productId, Money price, int quantity) {
        // 规则:不能超过100种商品
        if (items.size() >= 100) {
            throw new DomainException("订单最多100种商品");
        }
        items.add(new OrderItem(productId, price, quantity));
        recalculateTotal();
    }

    public void pay(Money paymentAmount) {
        // 规则:支付金额必须等于订单金额
        if (!paymentAmount.equals(totalAmount)) {
            throw new DomainException("支付金额不匹配");
        }
        status = OrderStatus.PAID;
        // 发布领域事件
        registerEvent(new OrderPaidEvent(this.id, this.customerId, this.totalAmount));
    }

    private void recalculateTotal() {
        totalAmount = items.stream()
            .map(i -> i.getPrice().multiply(i.getQuantity()))
            .reduce(Money.ZERO, Money::add);
    }
}

8. 领域服务(Domain Service)是什么?

当业务逻辑不属于任何实体或值对象时,放在领域服务中。


// 领域服务:转账
@DomainService
public class TransferService {
    public void transfer(Account from, Account to, Money amount) {
        from.debit(amount);   // 扣款
        to.credit(amount);    // 入账
        // 跨聚合的业务逻辑
    }
}

判断标准:

9. 领域事件(Domain Event)是什么?

领域事件表示领域中发生的有业务意义的事情,用于解耦聚合之间的通信。


// 领域事件
public record OrderCreatedEvent(
    OrderId orderId,
    CustomerId customerId,
    Money totalAmount,
    Instant occurredOn
) implements DomainEvent {}

// 在聚合根中发布
public class Order extends BaseAggregateRoot<OrderId> {
    public void create() {
        // ...创建逻辑
        registerEvent(new OrderCreatedEvent(this.id, this.customerId, this.totalAmount, Instant.now()));
    }
}

// 事件处理器
@Component
public class OrderCreatedHandler {
    @Autowired InventoryService inventoryService;

    @EventListener
    public void handle(OrderCreatedEvent event) {
        inventoryService.reserve(event.orderId());
    }
}

10. 仓库(Repository)的职责?

Repository是聚合的持久化接口,只针对聚合根定义。


// 领域层 - 接口
public interface OrderRepository {
    Order findById(OrderId id);
    void save(Order order);
    List<Order> findByCustomerId(CustomerId customerId);
}

// 基础设施层 - 实现
@Repository
public class JpaOrderRepository implements OrderRepository {
    @Autowired JpaOrderDao jpaDao;

    @Override
    public Order findById(OrderId id) {
        OrderPO po = jpaDao.findById(id.getValue()).orElse(null);
        return OrderConverter.toDomain(po);  // PO → 领域对象
    }

    @Override
    public void save(Order order) {
        OrderPO po = OrderConverter.toPO(order);  // 领域对象 → PO
        jpaDao.save(po);
    }
}

三、架构模式

11. DDD的分层架构?


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

依赖原则:上层依赖下层,领域层不依赖任何其他层。

12. 六边形架构(Hexagonal Architecture)?

也叫端口-适配器架构,核心思想是领域在中心,所有外部交互通过端口和适配器。


            ┌──────┐
            │ Web  │ ← 入站适配器
            │ API  │
            └──┬───┘
               │ 入站端口
         ┌─────▼─────┐
         │            │
入站端口 ←  应用/领域  → 出站端口
         │            │
         └─────┬─────┘
               │ 出站端口
         ┌─────▼──────┐
         │   MySQL    │ ← 出站适配器
         │   Redis    │
         │   Kafka    │
         └────────────┘

Java实现:


// 入站端口(接口)
public interface OrderUseCase {
    OrderDTO createOrder(CreateOrderCommand cmd);
    OrderDTO getOrder(Long id);
}

// 出站端口(接口)
public interface OrderRepository {
    Order save(Order order);
    Order findById(OrderId id);
}

// 入站适配器
@RestController
public class OrderController {
    @Autowired OrderUseCase orderUseCase;

    @PostMapping("/orders")
    public OrderDTO create(@RequestBody CreateOrderRequest req) {
        return orderUseCase.createOrder(toCommand(req));
    }
}

// 出站适配器
@Repository
public class JpaOrderRepository implements OrderRepository { ... }

13. CQRS(命令查询职责分离)是什么?

将读操作和写操作分离到不同的模型:


写模型(Command):
Controller → CommandService → 领域模型 → Repository → DB(写库)

读模型(Query):
Controller → QueryService → DAO → DB(读库)/ ES / Redis

优势:

劣势:


// Command - 写操作
@Service
public class OrderCommandService {
    @Autowired OrderRepository orderRepository;

    @Transactional
    public OrderId createOrder(CreateOrderCommand cmd) {
        Order order = Order.create(cmd.getCustomerId(), cmd.getItems());
        orderRepository.save(order);
        return order.getId();
    }
}

// Query - 读操作
@Service
public class OrderQueryService {
    @Autowired JpaOrderDao orderDao;

    @Transactional(readOnly = true)
    public OrderDTO getOrder(Long id) {
        return orderDao.findById(id)
            .map(this::toDTO)
            .orElseThrow(() -> new NotFoundException("订单不存在"));
    }

    public Page<OrderDTO> search(OrderSearchCriteria criteria) {
        // 直接走ES或读库
    }
}

四、Spring Boot落地实践

14. DDD在Spring Boot中的项目结构?


src/main/java/com/example/order/
├── interfaces/              # 接口层
│   ├── controller/
│   ├── dto/
│   ├── assembler/          # DTO ↔ 领域对象转换
│   └── facade/             # 外部服务门面
├── application/             # 应用层
│   ├── service/            # 应用服务(编排)
│   ├── command/            # 命令对象
│   ├── query/              # 查询对象
│   └── event/              # 事件处理
├── domain/                  # 领域层
│   ├── model/
│   │   ├── order/          # 订单聚合
│   │   │   ├── Order.java          # 聚合根
│   │   │   ├── OrderItem.java      # 实体
│   │   │   ├── OrderStatus.java    # 枚举
│   │   │   └── OrderFactory.java   # 工厂
│   │   ├── shared/         # 共享值对象
│   │   │   ├── Money.java
│   │   │   └── Address.java
│   │   └── event/          # 领域事件
│   ├── service/            # 领域服务
│   └── repository/         # Repository接口
└── infrastructure/          # 基础设施层
    ├── persistence/        # 持久化
    │   ├── po/             # 持久化对象
    │   ├── converter/      # 领域对象 ↔ PO
    │   └── JpaOrderRepository.java
    ├── messaging/          # 消息
    └── client/             # 外部API客户端

15. 应用服务(Application Service)的职责?

应用服务是业务用例的编排层,不包含业务逻辑:


@Service
@Transactional
public class OrderApplicationService {
    @Autowired OrderRepository orderRepository;
    @Autowired PaymentService paymentService;
    @Autowired DomainEventPublisher eventPublisher;

    public OrderId createOrder(CreateOrderCommand cmd) {
        // 1. 创建领域对象
        Order order = Order.create(
            new CustomerId(cmd.getCustomerId()),
            cmd.getItems().stream()
                .map(i -> new OrderItem(new ProductId(i.getProductId()),
                    new Money(i.getPrice()), i.getQuantity()))
                .toList()
        );
        // 2. 持久化
        orderRepository.save(order);
        // 3. 发布事件
        order.getEvents().forEach(eventPublisher::publish);
        return order.getId();
    }
}

16. 如何实现聚合间的最终一致性?

通过领域事件 + 消息队列:


// 订单聚合 → 发布事件
order.pay(amount);
orderRepository.save(order);

// 事件发布器(事务提交后)
@Component
public class DomainEventPublisher {
    @Autowired KafkaTemplate<String, String> kafkaTemplate;
    @Autowired ObjectMapper objectMapper;

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void publish(DomainEvent event) {
        kafkaTemplate.send("domain-events", event.topic(), toJson(event));
    }
}

// 库存聚合 → 消费事件
@KafkaListener(topics = "domain-events")
public void handleOrderPaid(OrderPaidEvent event) {
    inventoryService.reserveStock(event.orderId());
}

五、常见面试题

17. 贫血模型 vs 充血模型?

贫血模型(Anemic Model):


// 只有getter/setter,业务逻辑在Service中
public class Order {
    private Long id;
    private String status;
    // 只有getter/setter
}
public class OrderService {
    public void cancelOrder(Order order) {
        order.setStatus("CANCELLED");
        orderRepository.save(order);
    }
}

充血模型(Rich Model,DDD推荐):


// 业务逻辑在领域对象中
public class Order {
    private OrderId id;
    private OrderStatus status;

    public void cancel() {
        if (status != OrderStatus.CREATED) {
            throw new DomainException("只能取消待支付订单");
        }
        status = OrderStatus.CANCELLED;
    }
}

18. DDD的聚合设计原则?

1. 小聚合:每个聚合只包含必要的实体,理想情况只有聚合根

2. 通过ID引用:聚合之间用ID引用,不直接持有其他聚合的引用

3. 一次事务一个聚合:跨聚合通过最终一致性

4. 聚合根是唯一入口:外部只能通过聚合根操作聚合内的对象

19. 如何用DDD指导微服务拆分?

步骤:

1. 事件风暴(Event Storming):识别领域事件

2. 找出命令(Command):什么操作触发了事件

3. 识别聚合(Aggregate):命令作用的对象

4. 划定限界上下文:聚合的边界就是服务的边界

示例:电商系统:

20. DDD在复杂业务中的价值?

场景:促销规则引擎


// 促销策略(值对象或实体)
public interface PromotionRule {
    Money calculateDiscount(Order order);
}

public class FullReductionRule implements PromotionRule {
    private Money threshold;
    private Money reduction;

    public Money calculateDiscount(Order order) {
        if (order.getTotalAmount().isGreaterThanOrEqual(threshold)) {
            return reduction;
        }
        return Money.ZERO;
    }
}

// 促销聚合根
public class Promotion extends BaseAggregateRoot<PromotionId> {
    private List<PromotionRule> rules;

    public Money apply(Order order) {
        return rules.stream()
            .map(r -> r.calculateDiscount(order))
            .reduce(Money.ZERO, Money::add);
    }
}

六、DDD与设计模式

21. DDD中常用的设计模式?

22. 规格模式(Specification Pattern)怎么用?


// 规格:判断是否满足某个条件
public interface Specification<T> {
    boolean isSatisfiedBy(T candidate);
    Specification<T> and(Specification<T> other);
}

// 示例:订单可发货规格
public class OrderShippableSpec implements Specification<Order> {
    @Override
    public boolean isSatisfiedBy(Order order) {
        return order.getStatus() == OrderStatus.PAID
            && order.hasShippingAddress()
            && !order.getItems().isEmpty();
    }
}

23. 领域事件与Spring Event如何结合?


// 自定义领域事件基类
public abstract class DomainEvent {
    private final Instant occurredOn = Instant.now();
    private String eventId = UUID.randomUUID().toString();
}

// Spring事件发布
@Component
public class SpringDomainEventPublisher {
    @Autowired ApplicationEventPublisher publisher;

    public void publish(DomainEvent event) {
        publisher.publishEvent(event);
    }
}

// 事件处理器
@Component
public class OrderEventProcessor {
    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 异步处理,事务已提交
    }
}

七、事件溯源(Event Sourcing)

24. 事件溯源是什么?

传统方式:存储对象的当前状态

事件溯源:存储对象的所有变更事件,通过回放事件恢复状态


// 事件存储
public class EventStore {
    public void append(String aggregateId, DomainEvent event) { ... }
    public List<DomainEvent> load(String aggregateId) { ... }
}

// 通过事件重建聚合
public class Order {
    public static Order rebuild(List<DomainEvent> events) {
        Order order = new Order();
        for (DomainEvent event : events) {
            order.apply(event);
        }
        return order;
    }

    private void apply(DomainEvent event) {
        switch (event) {
            case OrderCreatedEvent e -> { this.id = e.orderId(); this.status = CREATED; }
            case OrderPaidEvent e -> this.status = PAID;
            case OrderShippedEvent e -> this.status = SHIPPED;
        }
    }
}

优势:完整的审计日志、可回溯、可重放

劣势:复杂、事件膨胀、查询需要CQRS配合

25. 事件溯源的快照(Snapshot)机制?

当事件太多时,回放会很慢。定期保存快照加速恢复:


public class OrderSnapshot {
    OrderId id;
    OrderStatus status;
    List<OrderItem> items;
    long version;
}

// 恢复时:从最近的快照 + 快照之后的事件
public Order load(OrderId id) {
    OrderSnapshot snapshot = snapshotStore.getLatest(id);
    List<DomainEvent> events = eventStore.loadAfter(id, snapshot.getVersion());
    Order order = Order.fromSnapshot(snapshot);
    events.forEach(order::apply);
    return order;
}

八、综合实战

26. 如何向面试官介绍DDD经验?

"我在电商订单系统重构中引入了DDD。首先通过事件风暴识别出5个核心聚合:订单、商品、库存、支付、物流。将原来的'大Service'拆分为独立的聚合根,业务逻辑从Service下沉到领域对象。比如Order聚合根包含了cancel()、pay()、ship()等业务方法,而不是在外部修改状态。聚合之间通过领域事件实现最终一致性,比如订单支付成功后发布OrderPaidEvent,库存服务监听并扣减库存。重构后,核心业务逻辑集中在领域层,可读性和可维护性大幅提升。"

27. DDD的适用和不适用场景?

适用:

不适用:

28. DDD与Clean Architecture的关系?

Clean Architecture是Robert Martin提出的架构模式,与DDD六边形架构理念一致:

组合使用:DDD提供领域建模方法,Clean Architecture提供代码组织方式。

29. 如何在团队中推广DDD?

1. 从小开始:选一个核心子域试点

2. 事件风暴:拉上业务人员一起建模

3. Code Review:通过CR确保领域模型的正确性

4. 技术分享:定期分享DDD实践心得

5. 不要教条:根据实际情况裁剪DDD,不是所有概念都要用

30. DDD和传统三层架构的核心区别?

维度三层架构DDD
组织方式按技术分层按业务领域分
业务逻辑Service层(贫血)领域对象(充血)
数据模型表驱动领域驱动
耦合度Service互相调用聚合间事件驱动
可测试性需要Mock大量依赖领域对象独立测试

面试速记口诀

DDD三板斧:限界上下文定边界、聚合根守不变量、领域事件解耦聚合

>

四层架构:接口层→应用层→领域层→基础设施层,依赖方向单向

>

充血模型核心:业务逻辑在领域对象中,Service只做编排

>

选型原则:复杂业务用DDD,简单CRUD不要过度设计