DDD领域驱动设计实践

夏佳怡2025-03-242025-03-24

DDD概述

领域驱动设计(Domain-Driven Design, DDD)是一种软件开发方法论，它强调以领域模型为中心的设计思想。本文将结合SpringBoot框架，探讨DDD在实际项目中的应用。

DDD核心概念

1. 战略设计

限界上下文(Bounded Context)
上下文映射(Context Mapping)
通用语言(Ubiquitous Language)
领域(Domain)与子域(Subdomain)

2. 战术设计

实体(Entity)
值对象(Value Object)
聚合(Aggregate)
领域服务(Domain Service)
领域事件(Domain Event)
仓储(Repository)
工厂(Factory)

项目结构示例

com.example.ddd
├── application         // 应用层
│   ├── dto            // 数据传输对象
│   ├── assembler      // DTO转换器
│   └── service        // 应用服务
├── domain             // 领域层
│   ├── model          // 领域模型
│   ├── service        // 领域服务
│   ├── repository     // 仓储接口
│   └── event          // 领域事件
├── infrastructure     // 基础设施层
│   ├── repository     // 仓储实现
│   ├── config         // 配置
│   └── util           // 工具类
└── interfaces         // 接口层
    ├── facade         // 外观接口
    ├── assembler      // DTO转换器
    └── dto            // 数据传输对象

代码实现示例

1. 领域模型

@Entity
@Getter
public class Order {
    @AggregateRoot
    private OrderId orderId;
    private CustomerId customerId;
    private Money totalAmount;
    private OrderStatus status;
    private List<OrderItem> items;

    // 领域行为
    public void addItem(Product product, int quantity) {
        OrderItem item = new OrderItem(product, quantity);
        items.add(item);
        recalculateTotal();
    }

    public void confirm() {
        if (status != OrderStatus.CREATED) {
            throw new IllegalStateException("Order cannot be confirmed");
        }
        status = OrderStatus.CONFIRMED;
        DomainEvents.publish(new OrderConfirmedEvent(this));
    }

    private void recalculateTotal() {
        totalAmount = items.stream()
                .map(OrderItem::getSubTotal)
                .reduce(Money.ZERO, Money::add);
    }
}

2. 值对象

@Value
public class Money {
    public static final Money ZERO = new Money(BigDecimal.ZERO);
    private final BigDecimal amount;

    public Money add(Money other) {
        return new Money(this.amount.add(other.amount));
    }

    public Money multiply(int quantity) {
        return new Money(this.amount.multiply(BigDecimal.valueOf(quantity)));
    }
}

3. 领域服务

@Service
@Transactional
public class OrderDomainService {
    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;

    public Order createOrder(CustomerId customerId, List<OrderItemCommand> items) {
        Order order = new Order(customerId);
        
        items.forEach(item -> {
            Product product = productRepository.findById(item.getProductId())
                    .orElseThrow(() -> new ProductNotFoundException(item.getProductId()));
            order.addItem(product, item.getQuantity());
        });

        return orderRepository.save(order);
    }
}

4. 应用服务

@Service
@Transactional
public class OrderApplicationService {
    private final OrderDomainService orderDomainService;
    private final OrderAssembler orderAssembler;

    public OrderDTO createOrder(CreateOrderCommand command) {
        Order order = orderDomainService.createOrder(
            new CustomerId(command.getCustomerId()),
            command.getItems()
        );
        return orderAssembler.toDTO(order);
    }

    public OrderDTO confirmOrder(String orderId) {
        Order order = orderDomainService.getOrder(new OrderId(orderId));
        order.confirm();
        return orderAssembler.toDTO(order);
    }
}

5. 仓储接口

public interface OrderRepository {
    Order save(Order order);
    Optional<Order> findById(OrderId orderId);
    void delete(Order order);
}

6. 仓储实现

@Repository
public class JpaOrderRepository implements OrderRepository {
    private final OrderJpaRepository jpaRepository;
    private final OrderMapper mapper;

    @Override
    public Order save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        entity = jpaRepository.save(entity);
        return mapper.toDomain(entity);
    }

    @Override
    public Optional<Order> findById(OrderId orderId) {
        return jpaRepository.findById(orderId.getValue())
                .map(mapper::toDomain);
    }
}

7. 领域事件

public class OrderConfirmedEvent extends DomainEvent {
    private final OrderId orderId;
    private final CustomerId customerId;

    public OrderConfirmedEvent(Order order) {
        this.orderId = order.getOrderId();
        this.customerId = order.getCustomerId();
    }
}

@Component
public class OrderConfirmedEventHandler {
    private final NotificationService notificationService;

    @EventListener
    public void handle(OrderConfirmedEvent event) {
        notificationService.notifyCustomer(
            event.getCustomerId(),
            "Your order " + event.getOrderId() + " has been confirmed"
        );
    }
}

最佳实践

1. 领域模型设计

确保领域模型的纯粹性
使用充血模型
保持领域逻辑的内聚
合理使用值对象
正确划分聚合边界

2. 分层架构

严格遵守依赖原则
保持层间清晰的边界
使用防腐层隔离外部系统
合理使用DTO进行数据传输
避免领域模型泄露

3. 领域事件

使用事件驱动实现解耦
合理设计事件的粒度
注意事件的顺序性
实现事件的幂等性
考虑事件的持久化

4. 测试策略

@SpringBootTest
public class OrderTest {
    @Test
    void should_create_order_successfully() {
        // Given
        CustomerId customerId = new CustomerId("123");
        Product product = new Product("P1", new Money("100"));
        
        // When
        Order order = new Order(customerId);
        order.addItem(product, 2);
        
        // Then
        assertEquals(new Money("200"), order.getTotalAmount());
        assertEquals(OrderStatus.CREATED, order.getStatus());
    }
}