20K Java+AI 岗位高频考点 — DDD是应对复杂业务系统的核心方法论,大厂面试常考限界上下文、聚合设计、六边形架构。覆盖战略设计、战术设计、Spring Boot落地、微服务拆分。
领域(Domain):业务知识和规则的总和
子域(Subdomain):
- 核心域(Core):企业核心竞争力(如推荐算法)
- 支撑域(Supporting):支撑核心域(如认证)
- 通用域(Generic):通用能力(如邮件)
限界上下文(Bounded Context):领域的边界
- 同一个词在不同上下文中含义不同
- 每个 Context 有自己的模型、数据库、团队
- 是微服务拆分的核心依据
统一语言(Ubiquitous Language):
- 开发和业务使用相同的术语
- 代码命名与业务概念一致
战略设计(宏观):
- 子域划分
- 限界上下文定义
- 上下文映射关系
- Event Storming
战术设计(微观):
- Entity(实体)
- Value Object(值对象)
- Aggregate(聚合)
- Repository(仓储)
- Domain Service(领域服务)
- Domain Event(领域事件)
- Factory(工厂)
合作关系( Partnership ):两个上下文协同开发
共享内核( Shared Kernel ):共享部分模型
客户-供应商( Customer-Supplier ):下游依赖上游
遵循者( Conformist ):完全遵循上游模型
防腐层( ACL ):隔离外部模型的适配层
开放主机服务( OHS ):上游提供标准协议
发布语言( Published Language ):标准的事件/DTO格式
实际应用:
订单Context → 调用 → 支付Context
→ 用ACL隔离支付接口变化
→ 通过OHS+PL发布订单事件
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);
}
}
聚合:一组相关对象的集合,作为数据修改的单元
聚合根(Aggregate Root):
- 聚合的入口对象
- 外部只能通过聚合根访问聚合内对象
- 保证聚合内的一致性
规则:
1. 聚合要小(只包含必须一起修改的对象)
2. 聚合间通过ID引用(不直接引用对象)
3. 一次事务只修改一个聚合
4. 聚合内强一致性,聚合间最终一致性
示例:
Order(聚合根) → OrderItem(内部实体) → Money(值对象)
|
├── 用户ID(引用其他聚合,只存ID)
└── 地址(值对象)
// 仓储接口定义在领域层,实现在基础设施层
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));
}
}
// 不属于任何实体的业务逻辑
@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;
}
}
// 领域事件定义
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);
}
}
┌─────────────────────────┐
│ 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/ # 消息队列
┌──────────────────────┐
│ │
HTTP ─┤ Driving Adapter │
gRPC ─┤ (入站适配器) │
CLI ─┤ │
│ ┌──────────────┐ │
│ │ Port(端口) │ │
│ │ ┌──────────┐ │ │
│ │ │ Domain │ │ │
│ │ │ (核心) │ │ │
│ │ └──────────┘ │ │
│ │ Port(端口) │ │
│ └──────────────┘ │
│ Driven Adapter │
DB ──┤ (出站适配器) │
MQ ──┤ │
API ──┤ │
└──────────────────────┘
核心:Domain不依赖任何外部,通过端口(Port接口)与外部交互
// 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),保证一致性
// 读库:反范式化(宽表/视图),优化查询性能
传统:存储当前状态(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;
}
}
// 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()); }
}
@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();
}
}
经验法则:
1. 一个限界上下文 → 一个微服务
2. 限界上下文内的聚合可部署为独立模块
3. 跨上下文通信:异步事件(最终一致性)
不适合的场景:
- 团队小(<10人)→ 模块化单体更合适
- 业务简单 → 不要过度设计
演进路径:
模块化单体 → 模块边界清晰 → 按需拆分为微服务
订单上下文 → 支付上下文 → 库存上下文
方案:
1. 领域事件 + 异步消息
2. Saga编排(正向+补偿)
3. 定时对账兜底
Spring实现:
@EventListener
public void onOrderCreated(OrderCreatedEvent event) {
// 启动Saga:扣库存 → 支付 → 确认订单
sagaManager.start("order-process", event);
}
| 维度 | 三层架构 | DDD |
|---|---|---|
| 核心关注 | 技术分层 | 业务领域 |
| 业务逻辑 | Service层(贫血模型) | 领域模型(充血模型) |
| 复杂度 | 简单场景 | 复杂业务 |
| 代码组织 | 按技术职责 | 按业务领域 |
| 适用 | CRUD应用 | 复杂业务系统 |
常见问题:
1. 过度设计:简单CRUD用DDD反而复杂
2. 聚合划太大:导致性能瓶颈
3. 事件滥用:所有操作都走事件
4. 忽略业务:技术驱动而非业务驱动
建议:
1. 先从模块化包结构开始
2. 用充血模型(业务逻辑在Entity中)
3. 逐步引入值对象和聚合
4. Event Storming工作坊对齐业务
步骤:
1. Event Storming工作坊:业务方+开发一起梳理
2. 划分子域和限界上下文
3. 先在一个模块试点DDD
4. 建立充血模型规范
5. Code Review强调领域模型质量
6. 渐进推广到其他模块
关键:
- 业务方参与(不是技术自嗨)
- 统一语言(代码命名与业务术语一致)
- 先战略后战术(先划清边界再设计模型)
DDD三核心:子域划分、限界上下文、统一语言
>
战术五要素:实体(有ID)、值对象(不可变)、聚合(一致性边界)、仓储(持久化)、领域事件(解耦)
>
架构三模式:分层(依赖规则)、六边形(端口适配)、CQRS(读写分离)
>
落地三步:先战略划边界→再战术建模型→最后微服务拆分