20K Java+AI 岗位高频考点 — DDD是复杂业务系统的架构利器,大厂面试必问。覆盖战略设计(限界上下文/上下文映射)、战术设计(聚合/实体/值对象/领域事件)、六边形架构、CQRS、与Spring Boot落地实践。
DDD(Domain-Driven Design)是Eric Evans提出的软件设计方法论,核心思想是以业务领域为中心驱动软件设计。
解决的痛点:
DDD的核心价值:
1. 统一语言(Ubiquitous Language):开发与业务用相同的术语
2. 领域建模:将业务知识转化为软件模型
3. 边界划分:通过限界上下文划分系统边界
战略设计(Strategic Design):宏观层面
战术设计(Tactical Design):微观层面
面试答题:优先投入核心域,通用域可采购SaaS,支撑域可简化。
限界上下文是DDD中最重要的概念,是语言的边界。同一个词在不同上下文中含义不同。
示例:电商系统中的"商品"
限界上下文 = 微服务边界:每个限界上下文通常对应一个独立的微服务。
| 关系 | 说明 | 示例 |
|---|---|---|
| 共享内核(Shared Kernel) | 两个上下文共享部分模型 | 共用的Address值对象 |
| 遵循者(Conformist) | 下游完全遵循上游模型 | 使用第三方支付API |
| 开放主机服务(OHS) | 上游提供标准API | 支付平台对外API |
| 防腐层(ACL) | 下游做适配,隔离上游变化 | 适配第三方物流接口 |
| 分道扬镳(Separate Ways) | 完全独立,不集成 | 各自实现通知功能 |
防腐层(Anti-Corruption Layer)最重要:在集成外部系统时,用ACL隔离外部模型对内部领域的侵蚀。
| 维度 | Entity | Value 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) {}
聚合:一组相关实体的集合,作为一个整体操作。
聚合根:聚合的入口实体,外部只能通过聚合根访问聚合内的对象。
设计原则:
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);
}
}
当业务逻辑不属于任何实体或值对象时,放在领域服务中。
// 领域服务:转账
@DomainService
public class TransferService {
public void transfer(Account from, Account to, Money amount) {
from.debit(amount); // 扣款
to.credit(amount); // 入账
// 跨聚合的业务逻辑
}
}
判断标准:
领域事件表示领域中发生的有业务意义的事情,用于解耦聚合之间的通信。
// 领域事件
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());
}
}
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);
}
}
┌─────────────────────────┐
│ 接口层(Interface) │ Controller / DTO / 转换
├─────────────────────────┤
│ 应用层(Application) │ ApplicationService / 编排
├─────────────────────────┤
│ 领域层(Domain) │ Entity / VO / Aggregate / DomainService / Repository接口
├─────────────────────────┤
│ 基础设施层(Infrastructure)│ Repository实现 / MQ / 外部API
└─────────────────────────┘
依赖原则:上层依赖下层,领域层不依赖任何其他层。
也叫端口-适配器架构,核心思想是领域在中心,所有外部交互通过端口和适配器。
┌──────┐
│ 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 { ... }
将读操作和写操作分离到不同的模型:
写模型(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或读库
}
}
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客户端
应用服务是业务用例的编排层,不包含业务逻辑:
@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();
}
}
通过领域事件 + 消息队列:
// 订单聚合 → 发布事件
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());
}
贫血模型(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;
}
}
1. 小聚合:每个聚合只包含必要的实体,理想情况只有聚合根
2. 通过ID引用:聚合之间用ID引用,不直接持有其他聚合的引用
3. 一次事务一个聚合:跨聚合通过最终一致性
4. 聚合根是唯一入口:外部只能通过聚合根操作聚合内的对象
步骤:
1. 事件风暴(Event Storming):识别领域事件
2. 找出命令(Command):什么操作触发了事件
3. 识别聚合(Aggregate):命令作用的对象
4. 划定限界上下文:聚合的边界就是服务的边界
示例:电商系统:
场景:促销规则引擎
// 促销策略(值对象或实体)
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);
}
}
// 规格:判断是否满足某个条件
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();
}
}
// 自定义领域事件基类
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) {
// 异步处理,事务已提交
}
}
传统方式:存储对象的当前状态
事件溯源:存储对象的所有变更事件,通过回放事件恢复状态
// 事件存储
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配合
当事件太多时,回放会很慢。定期保存快照加速恢复:
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;
}
"我在电商订单系统重构中引入了DDD。首先通过事件风暴识别出5个核心聚合:订单、商品、库存、支付、物流。将原来的'大Service'拆分为独立的聚合根,业务逻辑从Service下沉到领域对象。比如Order聚合根包含了cancel()、pay()、ship()等业务方法,而不是在外部修改状态。聚合之间通过领域事件实现最终一致性,比如订单支付成功后发布OrderPaidEvent,库存服务监听并扣减库存。重构后,核心业务逻辑集中在领域层,可读性和可维护性大幅提升。"
适用:
不适用:
Clean Architecture是Robert Martin提出的架构模式,与DDD六边形架构理念一致:
组合使用:DDD提供领域建模方法,Clean Architecture提供代码组织方式。
1. 从小开始:选一个核心子域试点
2. 事件风暴:拉上业务人员一起建模
3. Code Review:通过CR确保领域模型的正确性
4. 技术分享:定期分享DDD实践心得
5. 不要教条:根据实际情况裁剪DDD,不是所有概念都要用
| 维度 | 三层架构 | DDD |
|---|---|---|
| 组织方式 | 按技术分层 | 按业务领域分 |
| 业务逻辑 | Service层(贫血) | 领域对象(充血) |
| 数据模型 | 表驱动 | 领域驱动 |
| 耦合度 | Service互相调用 | 聚合间事件驱动 |
| 可测试性 | 需要Mock大量依赖 | 领域对象独立测试 |
DDD三板斧:限界上下文定边界、聚合根守不变量、领域事件解耦聚合
>
四层架构:接口层→应用层→领域层→基础设施层,依赖方向单向
>
充血模型核心:业务逻辑在领域对象中,Service只做编排
>
选型原则:复杂业务用DDD,简单CRUD不要过度设计