六边形架构（端口和适配器）：

         ┌──────────────┐
  REST ──│              │── Database
         │   领域核心    │
  MQ  ───│  (Entities,  │── Email
         │   Services)  │
  UI  ───│              │── External API
         └──────────────┘

端口（Port）：领域核心定义的接口
适配器（Adapter）：接口的具体实现

依赖方向：外部 → 内部（领域核心不依赖外部）

DDD 分层架构：

1. 接口层（Interface Layer）
   - REST Controller
   - 消息监听器
   - 定时任务

2. 应用层（Application Layer）
   - 应用服务
   - 命令处理
   - 事件发布

3. 领域层（Domain Layer）
   - 实体、值对象
   - 领域服务
   - 领域事件
   - 仓储接口

4. 基础设施层（Infrastructure Layer）
   - 仓储实现
   - 外部服务适配器
   - 数据库配置

依赖方向：外层 → 内层

src/main/java/com/example/order/
├── domain/                    # 领域层
│   ├── model/
│   │   ├── Order.java
│   │   ├── OrderLine.java
│   │   ├── OrderId.java
│   │   └── OrderStatus.java
│   ├── service/
│   │   └── OrderDomainService.java
│   ├── event/
│   │   ├── OrderPlaced.java
│   │   └── OrderConfirmed.java
│   └── repository/
│       └── OrderRepository.java    # 接口
│
├── application/               # 应用层
│   ├── OrderApplicationService.java
│   ├── command/
│   │   ├── PlaceOrderCommand.java
│   │   └── ConfirmOrderCommand.java
│   └── event/
│       └── OrderEventHandler.java
│
├── interfaces/                # 接口层
│   ├── rest/
│   │   └── OrderController.java
│   └── rest/dto/
│       └── OrderDTO.java
│
└── infrastructure/            # 基础设施层
    ├── persistence/
    │   ├── JpaOrderRepository.java
    │   └── OrderEntity.java
    └── messaging/
        └── KafkaOrderEventPublisher.java

DDD 和微服务的关系：
- 限界上下文 ≈ 微服务
- 每个微服务有自己的领域模型
- 微服务之间通过 API 或事件通信
- 每个微服务可以独立部署和扩展

微服务中的 DDD：
- 每个服务内部使用 DDD
- 服务之间使用上下文映射
- 共享内核 → 共享库
- 客户-供应商 → REST API
- 发布/订阅 → 消息队列

// 领域层 - 实体
@Entity
@Table(name = "orders")
public class Order {
    @EmbeddedId
    private OrderId id;
    
    @Embedded
    private CustomerId customerId;
    
    @ElementCollection
    private List<OrderLine> lines;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    // 领域逻辑
    public void confirm() {
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException();
        }
        if (lines.isEmpty()) {
            throw new IllegalStateException();
        }
        status = OrderStatus.CONFIRMED;
    }
}

// 应用层 - 服务
@Service
public class OrderApplicationService {
    private final OrderRepository orderRepo;
    private final EventPublisher eventPublisher;
    
    @Transactional
    public OrderId placeOrder(PlaceOrderCommand cmd) {
        Order order = new Order(cmd.getCustomerId());
        for (LineCommand line : cmd.getLines()) {
            order.addLine(line.getProductId(), line.getQuantity());
        }
        orderRepo.save(order);
        eventPublisher.publish(new OrderPlaced(order.getId()));
        return order.getId();
    }
}

// 接口层 - REST
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderApplicationService orderService;
    
    @PostMapping
    public ResponseEntity<OrderResponse> placeOrder(@RequestBody PlaceOrderRequest req) {
        OrderId id = orderService.placeOrder(req.toCommand());
        return ResponseEntity.created(URI.create("/api/orders/" + id)).build();
    }
}