java中的DDD思想指的是什么及在Java中的体现详解

+---------------------+
|   用户接口层（UI Layer）     |  ← HTTP、Web、RPC 接口
+---------------------+
|   应用层（Application Layer） |  ← 用例协调、事务控制
+---------------------+
|   领域层（Domain Layer）     |  ← 核心业务逻辑、实体、聚合、领域服务
+---------------------+
|   基础设施层（Infrastructure Layer）| ← 数据库、消息、外部服务调用
+---------------------+

// 值对象：金额
public class Money {
    private BigDecimal amount;
    private String currency;
 
    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }
 
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) throw new IllegalArgumentException();
        return new Money(this.amount.add(other.amount), currency);
    }
}
 
// 实体：订单项
public class OrderItem {
    private Long id;
    private String productName;
    private Money price;
    private int quantity;
}
 
// 聚合根：订单
public class Order {
    private Long id;
    private List<OrderItem> items = new ArrayList<>();
    private Money total;
    private String status;
 
    public void addItem(OrderItem item) {
        this.items.add(item);
        this.total = this.total.add(item.getPrice().multiply(item.getQuantity()));
    }
 
    public void confirm() {
        if (this.status.equals("CREATED")) {
            this.status = "CONFIRMED";
            // 发布领域事件
            DomainEventPublisher.publish(new OrderConfirmedEvent(this.id));
        }
    }
}
 
// 领域服务
@Service
public class OrderService {
    public void cancelOrder(Order order) {
        // 复杂业务逻辑
        if (order.isCancelable()) {
            order.setStatus("CANCELLED");
            orderRepository.save(order);
        }
    }
}

// 传统贫血模型 vs DDD充血模型

// ❌ 贫血模型（不推荐）
public class Order {
    private Long id;
    private BigDecimal amount;
    // 只有getter/setter
}

public class OrderService {
    public void calculateDiscount(Order order) {
        // 业务逻辑在Service中
    }
}

// ✅ DDD充血模型（推荐）
public class Order {
    private Long id;
    private BigDecimal amount;
    private List<OrderItem> items;
    
    // 业务逻辑在领域对象中
    public BigDecimal calculateDiscount() {
        // 折扣计算逻辑
        return this.amount.multiply(getDiscountRate());
    }
    
    private BigDecimal getDiscountRate() {
        // 领域规则
        if (amount.compareTo(new BigDecimal("1000")) > 0) {
            return new BigDecimal("0.9");
        }
        return BigDecimal.ONE;
    }
}

// 典型DDD分层结构
├── application/    // 应用层 - 用例协调
├── domain/         // 领域层 - 业务核心
├── infrastructure/ // 基础设施层 - 技术实现
└── interfaces/     // 接口层 - 对外暴露

public class Order implements Entity<Order> {
    private OrderId id;  // 值对象作为标识
    private Money totalAmount;
    private OrderStatus status;
    
    // 通过标识判断相等性
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Order order = (Order) obj;
        return id.equals(order.id);
    }
    
    // 业务方法
    public void cancel() {
        if (!status.canCancel()) {
            throw new IllegalStateException("订单无法取消");
        }
        this.status = OrderStatus.CANCELLED;
    }
}

public class Money implements ValueObject {
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    // 值对象基于所有属性判断相等性
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Money money = (Money) obj;
        return amount.compareTo(money.amount) == 0 && 
               currency.equals(money.currency);
    }
    
    // 不可变操作
    public Money add(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("货币类型不匹配");
        }
        return new Money(amount.add(other.amount), currency);
    }
}

public class Order implements AggregateRoot {
    private OrderId id;
    private List<OrderItem> items;  // 内部实体
    private CustomerId customerId;
    
    // 聚合根负责维护完整性
    public void addItem(Product product, int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("数量必须大于0");
        }
        
        OrderItem newItem = new OrderItem(product.getId(), quantity, product.getPrice());
        items.add(newItem);
        recalculateTotal();
    }
    
    // 外部只能通过聚合根访问内部对象
    public List<OrderItem> getItems() {
        return Collections.unmodifiableList(items);
    }
}

public class OrderCalculationService {
    
    // 处理不适合放在实体中的跨聚合业务逻辑
    public Discount calculateBestDiscount(Order order, Customer customer, List<Promotion> promotions) {
        // 复杂的折扣计算逻辑
        return promotions.stream()
            .filter(p -> p.isApplicable(order, customer))
            .map(p -> p.calculateDiscount(order))
            .max(Comparator.comparing(Discount::getAmount))
            .orElse(Discount.NONE);
    }
}

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

// 基础设施层实现
@Repository
public class OrderRepositoryImpl implements OrderRepository {
    @Autowired
    private OrderJpaRepository jpaRepository;
    
    @Override
    public Order findById(OrderId id) {
        OrderEntity entity = jpaRepository.findById(id.getValue())
            .orElseThrow(() -> new OrderNotFoundException(id));
        return orderMapper.toDomain(entity);
    }
}

com.example.ordermanagement
├── application
│   ├── command
│   ├── query
│   └── service
├── domain
│   ├── model
│   ├── service
│   ├── repository
│   └── exception
├── infrastructure
│   ├── persistence
│   ├── external
│   └── config
└── interfaces
    ├── rest
    ├── dto
    └── mapper

// 自定义注解明确DDD角色
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DomainEntity {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DomainService {
}

@DomainEntity
public class Order {
    // 领域实体
}

@DomainService  
public class OrderValidationService {
    // 领域服务
}