クリーンアーキテクチャ完全ガイド：SOLIDからヘキサゴナル、DDD、レイヤードまで — シニアへの設計原則

コスト
  ^
  |           /  アーキテクチャなし
  |          /
  |         /
  |        /
  |      /    ___--- 良いアーキテクチャ
  |    /  ---
  |  / --
  | /--
  +-------------------> 時間

// BAD: UserServiceがビジネスロジック、永続化、通知をすべて担当
class UserService {
  createUser(name: string, email: string) {
    // バリデーション
    if (!email.includes('@')) throw new Error('Invalid email')

    // DB保存（永続化の関心事）
    const query = `INSERT INTO users (name, email) VALUES ('${name}', '${email}')`
    database.execute(query)

    // メール送信（通知の関心事）
    const mailClient = new SmtpClient()
    mailClient.send(email, 'Welcome!', 'Thanks for joining')

    // ロギング（インフラの関心事）
    console.log(`User created: ${name}`)
  }
}

// GOOD: 各クラスが1つの変更理由のみを持つ
class UserValidator {
  validate(name: string, email: string): void {
    if (!email.includes('@')) throw new Error('Invalid email')
    if (name.length < 2) throw new Error('Name too short')
  }
}

class UserRepository {
  save(user: User): Promise<User> {
    return this.db.users.create({ data: user })
  }
}

class WelcomeEmailSender {
  send(email: string): Promise<void> {
    return this.mailService.send({
      to: email,
      subject: 'Welcome!',
      body: 'Thanks for joining',
    })
  }
}

class CreateUserUseCase {
  constructor(
    private validator: UserValidator,
    private repository: UserRepository,
    private emailSender: WelcomeEmailSender
  ) {}

  async execute(name: string, email: string): Promise<User> {
    this.validator.validate(name, email)
    const user = await this.repository.save({ name, email })
    await this.emailSender.send(email)
    return user
  }
}

// BAD: 新しい決済手段ごとにif文追加が必要
class PaymentProcessor {
  process(payment: Payment) {
    if (payment.type === 'credit_card') {
      this.processCreditCard(payment)
    } else if (payment.type === 'paypal') {
      this.processPayPal(payment)
    } else if (payment.type === 'bitcoin') {
      // 新しい決済手段追加のたびに既存コード修正！
      this.processBitcoin(payment)
    }
  }
}

// GOOD: 新しい決済手段追加時に既存コード修正不要
interface PaymentStrategy {
  process(payment: Payment): Promise<PaymentResult>
}

class CreditCardStrategy implements PaymentStrategy {
  async process(payment: Payment): Promise<PaymentResult> {
    return { success: true, transactionId: 'cc-123' }
  }
}

class PayPalStrategy implements PaymentStrategy {
  async process(payment: Payment): Promise<PaymentResult> {
    return { success: true, transactionId: 'pp-456' }
  }
}

// 新しい決済手段 = 新しいクラスを追加するだけ
class PayPayStrategy implements PaymentStrategy {
  async process(payment: Payment): Promise<PaymentResult> {
    return { success: true, transactionId: 'pp-789' }
  }
}

class PaymentProcessor {
  private strategies: Map<string, PaymentStrategy>

  constructor(strategies: Map<string, PaymentStrategy>) {
    this.strategies = strategies
  }

  async process(payment: Payment): Promise<PaymentResult> {
    const strategy = this.strategies.get(payment.type)
    if (!strategy) throw new Error(`Unknown payment type: ${payment.type}`)
    return strategy.process(payment)
  }
}

// BAD: SquareがRectangleの不変条件を違反
class Rectangle {
    protected int width;
    protected int height;

    public void setWidth(int w) { this.width = w; }
    public void setHeight(int h) { this.height = h; }
    public int getArea() { return width * height; }
}

class Square extends Rectangle {
    // LSP違反：setWidthがheightも変更
    @Override
    public void setWidth(int w) {
        this.width = w;
        this.height = w; // 親と異なる動作！
    }

    @Override
    public void setHeight(int h) {
        this.width = h;
        this.height = h;
    }
}

// クライアントコードが壊れる
void resize(Rectangle r) {
    r.setWidth(5);
    r.setHeight(10);
    assert r.getArea() == 50; // Squareだと失敗！（100）
}

// GOOD: 共通インターフェースで設計
interface Shape {
    int getArea();
}

class Rectangle implements Shape {
    private final int width;
    private final int height;

    Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public int getArea() { return width * height; }
}

class Square implements Shape {
    private final int side;

    Square(int side) { this.side = side; }

    public int getArea() { return side * side; }
}

// BAD: すべてのデバイスがすべての機能を実装しなければならない
interface SmartDevice {
  print(): void
  scan(): void
  fax(): void
  copyDocument(): void
}

// プリンターはscan、faxを実装できない
class SimplePrinter implements SmartDevice {
  print() {
    /* OK */
  }
  scan() {
    throw new Error('Not supported')
  } // 強制実装
  fax() {
    throw new Error('Not supported')
  } // 強制実装
  copyDocument() {
    throw new Error('Not supported')
  }
}

// GOOD: 役割別に分離されたインターフェース
interface Printer {
  print(): void
}

interface Scanner {
  scan(): void
}

interface FaxMachine {
  fax(): void
}

// 必要なインターフェースのみ実装
class SimplePrinter implements Printer {
  print() {
    /* 印刷処理 */
  }
}

class AllInOnePrinter implements Printer, Scanner, FaxMachine {
  print() {
    /* 印刷 */
  }
  scan() {
    /* スキャン */
  }
  fax() {
    /* ファックス */
  }
}

// BAD: ビジネスロジックが具体的な実装に依存
class OrderService {
  private mysqlDb = new MySQLDatabase() // 具象クラスに依存
  private smtpMail = new SmtpEmailClient() // 具象クラスに依存

  createOrder(order: Order) {
    this.mysqlDb.insert('orders', order)
    this.smtpMail.send(order.userEmail, 'Order confirmed')
  }
}
// MySQLをPostgreSQLに変えるにはOrderServiceの修正が必要！

// GOOD: インターフェース（抽象）に依存
interface OrderRepository {
  save(order: Order): Promise<Order>
}

interface NotificationService {
  notify(userId: string, message: string): Promise<void>
}

class OrderService {
  constructor(
    private repository: OrderRepository, // 抽象に依存
    private notification: NotificationService // 抽象に依存
  ) {}

  async createOrder(order: Order): Promise<Order> {
    const saved = await this.repository.save(order)
    await this.notification.notify(order.userId, 'Order confirmed')
    return saved
  }
}

// インフラ層で実装
class PostgresOrderRepository implements OrderRepository {
  async save(order: Order): Promise<Order> {
    return this.prisma.order.create({ data: order })
  }
}

+-----------------------------+
|   Presentation Layer        |  <- Controller, View
+-----------------------------+
|   Application Layer         |  <- Service, DTO
+-----------------------------+
|     Domain Layer            |  <- Entity, Business Logic
+-----------------------------+
|   Infrastructure Layer      |  <- Repository, External API
+-----------------------------+

依存性の方向: 上 -> 下 (Presentation -> Infrastructure)

// Presentation Layer
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final OrderService orderService;

    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(
            @RequestBody CreateOrderRequest request) {
        OrderResponse response = orderService.createOrder(request);
        return ResponseEntity.status(201).body(response);
    }
}

// Application Layer
@Service
@Transactional
public class OrderService {

    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;

    public OrderResponse createOrder(CreateOrderRequest request) {
        Product product = productRepository.findById(request.getProductId())
            .orElseThrow(() -> new NotFoundException("Product not found"));

        Order order = Order.create(
            request.getUserId(),
            product,
            request.getQuantity()
        );

        Order saved = orderRepository.save(order);
        return OrderResponse.from(saved);
    }
}

// Domain Layer
@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;
    private String userId;
    private BigDecimal totalAmount;
    private OrderStatus status;

    public static Order create(String userId, Product product, int quantity) {
        Order order = new Order();
        order.userId = userId;
        order.totalAmount = product.getPrice().multiply(BigDecimal.valueOf(quantity));
        order.status = OrderStatus.CREATED;
        return order;
    }

    public void cancel() {
        if (this.status != OrderStatus.CREATED) {
            throw new IllegalStateException("Only CREATED orders can be cancelled");
        }
        this.status = OrderStatus.CANCELLED;
    }
}

+--------------------------------------------------+
|  Frameworks & Drivers (Web, DB, External)        |
|  +------------------------------------------+    |
|  |  Interface Adapters (Controllers, GW)    |    |
|  |  +----------------------------------+    |    |
|  |  |  Application (Use Cases)         |    |    |
|  |  |  +------------------------+      |    |    |
|  |  |  |     Entities           |      |    |    |
|  |  |  |   (Domain Models)      |      |    |    |
|  |  |  +------------------------+      |    |    |
|  |  +----------------------------------+    |    |
|  +------------------------------------------+    |
+--------------------------------------------------+

依存性の方向: 外側 -> 内側 (Frameworks -> Entities)

// Entities - いかなるフレームワークにも依存しない
class Order {
  private items: OrderItem[] = []
  private status: OrderStatus = 'CREATED'

  addItem(product: Product, quantity: number): void {
    if (quantity <= 0) throw new Error('Quantity must be positive')
    if (this.status !== 'CREATED') throw new Error('Cannot modify confirmed order')
    this.items.push(new OrderItem(product, quantity))
  }

  get totalAmount(): Money {
    return this.items.reduce((sum, item) => sum.add(item.subtotal), Money.zero('KRW'))
  }

  confirm(): void {
    if (this.items.length === 0) throw new Error('Cannot confirm empty order')
    this.status = 'CONFIRMED'
  }
}

// Use Cases
interface OrderRepository {
  save(order: Order): Promise<Order>
  findById(id: string): Promise<Order | null>
}

interface PaymentGateway {
  charge(amount: Money, paymentMethod: PaymentMethod): Promise<PaymentResult>
}

class CreateOrderUseCase {
  constructor(
    private orderRepo: OrderRepository,
    private paymentGateway: PaymentGateway,
    private eventPublisher: DomainEventPublisher
  ) {}

  async execute(input: CreateOrderInput): Promise<CreateOrderOutput> {
    const order = new Order(input.userId)

    for (const item of input.items) {
      order.addItem(item.product, item.quantity)
    }

    order.confirm()

    const paymentResult = await this.paymentGateway.charge(order.totalAmount, input.paymentMethod)

    if (!paymentResult.success) {
      throw new PaymentFailedError(paymentResult.reason)
    }

    const saved = await this.orderRepo.save(order)
    await this.eventPublisher.publish(new OrderCreatedEvent(saved.id))

    return { orderId: saved.id, totalAmount: order.totalAmount.toString() }
  }
}

src/main/java/com/example/shop/
  domain/                    # Entities
    model/
      Order.java
      OrderItem.java
      Money.java
    event/
      OrderCreatedEvent.java
  application/               # Use Cases
    port/
      in/
        CreateOrderUseCase.java
      out/
        OrderRepository.java
        PaymentGateway.java
    service/
      OrderApplicationService.java
  adapter/                   # Interface Adapters + Frameworks
    in/
      web/
        OrderController.java
        CreateOrderRequest.java
    out/
      persistence/
        JpaOrderRepository.java
        OrderJpaEntity.java
      payment/
        StripePaymentGateway.java
  config/
    BeanConfiguration.java

// domain層 - 外部依存性 ZERO
// Order.tsのimport文を見ると:
// - express なし
// - prisma なし
// - typeorm なし
// 純粋なTypeScript/Javaコードのみ

class Order {
  // 純粋なビジネスロジックのみ含む
  // DBがMySQLでもMongoDBでも関係ない
  // WebフレームワークがExpressでもFastifyでも関係ない
}

              +----------+
     HTTP --> |          | --> PostgreSQL
              |   Port   |
     CLI -->  |    &     | --> Redis
              |  Domain  |
   gRPC -->  |   Core   | --> Kafka
              |          |
    Test -->  |          | --> Mock DB
              +----------+

  [Driving Adapters]  [Core]  [Driven Adapters]
    (入力側)        (ビジネス)    (出力側)

// ===== PORTS（インターフェース定義） =====

// Driving Port（インバウンド）
interface CreateOrderPort {
  createOrder(command: CreateOrderCommand): Promise<OrderId>
}

// Driven Port（アウトバウンド）
interface LoadOrderPort {
  findById(id: string): Promise<Order | null>
}

interface SaveOrderPort {
  save(order: Order): Promise<Order>
}

interface SendNotificationPort {
  sendOrderConfirmation(order: Order): Promise<void>
}

// ===== DOMAIN CORE（核心ビジネスロジック） =====

class Order {
  private readonly id: string
  private items: OrderItem[] = []
  private status: OrderStatus = 'PENDING'

  constructor(
    id: string,
    private readonly customerId: string
  ) {
    this.id = id
  }

  addItem(productId: string, price: Money, quantity: number): void {
    this.ensureModifiable()
    this.items.push(new OrderItem(productId, price, quantity))
  }

  confirm(): void {
    if (this.items.length === 0) {
      throw new DomainError('Cannot confirm empty order')
    }
    this.status = 'CONFIRMED'
  }

  cancel(): void {
    if (this.status === 'SHIPPED') {
      throw new DomainError('Cannot cancel shipped order')
    }
    this.status = 'CANCELLED'
  }

  private ensureModifiable(): void {
    if (this.status !== 'PENDING') {
      throw new DomainError('Order is not modifiable')
    }
  }

  get totalAmount(): Money {
    return this.items.reduce((sum, item) => sum.add(item.subtotal), Money.zero('KRW'))
  }
}

// ===== APPLICATION SERVICE（ユースケース実装） =====

class OrderService implements CreateOrderPort {
  constructor(
    private readonly loadOrder: LoadOrderPort,
    private readonly saveOrder: SaveOrderPort,
    private readonly notification: SendNotificationPort
  ) {}

  async createOrder(command: CreateOrderCommand): Promise<OrderId> {
    const order = new Order(generateId(), command.customerId)

    for (const item of command.items) {
      order.addItem(item.productId, new Money(item.price, 'KRW'), item.quantity)
    }

    order.confirm()
    const saved = await this.saveOrder.save(order)
    await this.notification.sendOrderConfirmation(saved)

    return saved.id
  }
}

// ===== ADAPTERS（具体的な実装） =====

// Driving Adapter - REST Controller
class OrderRestController {
  constructor(private createOrderPort: CreateOrderPort) {}

  async handlePost(req: Request, res: Response): Promise<void> {
    const command: CreateOrderCommand = {
      customerId: req.body.customerId,
      items: req.body.items,
    }
    const orderId = await this.createOrderPort.createOrder(command)
    res.status(201).json({ orderId })
  }
}

// Driven Adapter - Database
class PostgresOrderAdapter implements LoadOrderPort, SaveOrderPort {
  constructor(private prisma: PrismaClient) {}

  async findById(id: string): Promise<Order | null> {
    const data = await this.prisma.order.findUnique({
      where: { id },
      include: { items: true },
    })
    return data ? this.toDomain(data) : null
  }

  async save(order: Order): Promise<Order> {
    await this.prisma.order.upsert({
      where: { id: order.id },
      create: this.toPersistence(order),
      update: this.toPersistence(order),
    })
    return order
  }

  private toDomain(data: PrismaOrder): Order {
    /* マッピング */
  }
  private toPersistence(order: Order): PrismaOrderData {
    /* マッピング */
  }
}

ビジネス: 「顧客が注文を作成し、決済が承認されると注文が確定される」
コード:   customer.createOrder() -> payment.approve() -> order.confirm()

ビジネス: 「配送が開始されると注文をキャンセルできない」
コード:   order.cancel() -> if (status === 'SHIPPED') throw Error

+------------------+  +------------------+  +------------------+
|  Order Context   |  | Payment Context  |  | Shipping Context |
|                  |  |                  |  |                  |
|  Order           |  |  Payment         |  |  Shipment        |
|  OrderItem       |  |  Transaction     |  |  Package         |
|  Customer (id,   |  |  Customer (id,   |  |  Customer (id,   |
|   name, email)   |  |   paymentMethod) |  |   address)       |
|                  |  |                  |  |                  |
|  「Customer」=   |  |  「Customer」=   |  |  「Customer」=   |
|  注文者情報      |  |  決済者情報      |  |  受取人情報      |
+--------+---------+  +--------+---------+  +--------+---------+

public class Order {
    private final OrderId id;  // 固有識別子
    private OrderStatus status;
    private List<OrderItem> items;

    // ビジネスロジックがエンティティ内に存在（Rich Domain Model）
    public void addItem(Product product, int quantity) {
        validateModifiable();
        OrderItem item = new OrderItem(product, quantity);
        this.items.add(item);
        recalculateTotal();
    }

    public void confirm() {
        if (items.isEmpty()) {
            throw new OrderEmptyException("Cannot confirm empty order");
        }
        this.status = OrderStatus.CONFIRMED;
        registerEvent(new OrderConfirmedEvent(this.id));
    }
}

public record Money(BigDecimal amount, Currency currency) {

    public Money {
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Amount cannot be negative");
        }
        Objects.requireNonNull(currency);
    }

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

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

    public static Money zero(Currency currency) {
        return new Money(BigDecimal.ZERO, currency);
    }
}

// 使用例
Money price = new Money(BigDecimal.valueOf(15000), Currency.JPY);
Money total = price.multiply(3);  // 45000 JPY

// OrderがAggregate Root
// OrderItemはOrderを通してのみアクセス/修正可能
public class Order {  // Aggregate Root
    private final OrderId id;
    private final CustomerId customerId;
    private List<OrderItem> items = new ArrayList<>();  // 内部エンティティ
    private ShippingAddress address;  // 値オブジェクト
    private Money totalAmount;        // 値オブジェクト

    // 外部からOrderItemを直接生成/修正不可
    // 必ずOrderを通して操作
    public void addItem(ProductId productId, Money price, int qty) {
        OrderItem item = new OrderItem(productId, price, qty);
        this.items.add(item);
        recalculateTotal();
    }
}

public record OrderConfirmedEvent(
    OrderId orderId,
    CustomerId customerId,
    Money totalAmount,
    Instant occurredAt
) implements DomainEvent {}

// Aggregate Rootでイベント登録
public class Order extends AbstractAggregateRoot<Order> {

    public void confirm() {
        this.status = OrderStatus.CONFIRMED;
        registerEvent(new OrderConfirmedEvent(this.id, this.customerId, this.totalAmount));
    }
}

// イベントハンドラー
@Component
public class OrderConfirmedEventHandler {

    @EventListener
    public void handleOrderConfirmed(OrderConfirmedEvent event) {
        // 決済処理トリガー
        // 在庫差し引きトリガー
        // 確認メール送信
    }
}

1. Domain Events（オレンジの付箋） - 過去形で記述
   「注文が作成された」 「決済が承認された」 「商品が配送された」

2. Commands（青の付箋） - イベントを発生させる行為
   「注文作成」 「決済承認」 「配送開始」

3. Aggregates（黄色の付箋） - コマンドを処理する主体
   「Order」 「Payment」 「Shipment」

4. Bounded Contexts発見 - 関連するものをグルーピング
   Order Context | Payment Context | Shipping Context

src/
  order/                          # Bounded Context
    domain/                       # ヘキサゴナルのCore
      model/
        Order.java                # Aggregate Root
        OrderItem.java            # Entity
        Money.java                # Value Object
      event/
        OrderConfirmedEvent.java  # Domain Event
    application/                  # ポート定義 + Use Case
      port/
        in/
          CreateOrderUseCase.java    # Driving Port
        out/
          LoadOrderPort.java         # Driven Port
          SaveOrderPort.java
      service/
        OrderApplicationService.java # Use Case実装
    infrastructure/               # アダプター
      adapter/
        in/
          web/
            OrderController.java     # Driving Adapter
        out/
          persistence/
            JpaOrderRepository.java  # Driven Adapter
          payment/
            StripePaymentAdapter.java

プロジェクト開始
  |
  +-- ビジネスロジックが単純？ --YES--> レイヤードアーキテクチャ
  |
  NO
  |
  +-- 外部システム統合が多い？ --YES--> ヘキサゴナルアーキテクチャ
  |
  NO
  |
  +-- ドメイン専門家との協業可能？ --YES--+
  |                                       |
  NO                                      v
  |                        ビジネスロジックが非常に複雑？
  |                            |           |
  |                           YES          NO
  |                            |           |
  |                            v           v
  |                     DDD + Hexagonal  クリーンアーキテクチャ
  |
  +--> クリーンアーキテクチャ（安全なデフォルト選択）

public record Money(BigDecimal amount, String currency) {

    public Money {
        Objects.requireNonNull(amount, "Amount must not be null");
        Objects.requireNonNull(currency, "Currency must not be null");
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Amount cannot be negative");
        }
    }

    public static Money of(long amount, String currency) {
        return new Money(BigDecimal.valueOf(amount), currency);
    }

    public static Money zero(String currency) {
        return new Money(BigDecimal.ZERO, currency);
    }

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

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

    private void assertSameCurrency(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException(
                "Currency mismatch: " + this.currency + " vs " + other.currency
            );
        }
    }
}

public class Order {
    private final String id;
    private final String customerId;
    private final List<OrderItem> items = new ArrayList<>();
    private OrderStatus status;
    private Money totalAmount;
    private final List<DomainEvent> domainEvents = new ArrayList<>();

    public Order(String id, String customerId) {
        this.id = id;
        this.customerId = customerId;
        this.status = OrderStatus.PENDING;
        this.totalAmount = Money.zero("JPY");
    }

    public void addItem(String productId, String productName, Money price, int quantity) {
        ensureModifiable();
        this.items.add(new OrderItem(productId, productName, price, quantity));
        recalculateTotal();
    }

    public void confirm() {
        if (items.isEmpty()) {
            throw new OrderDomainException("Cannot confirm empty order");
        }
        if (status != OrderStatus.PENDING) {
            throw new OrderDomainException("Only pending orders can be confirmed");
        }
        this.status = OrderStatus.CONFIRMED;
        domainEvents.add(new OrderConfirmedEvent(this.id, this.customerId, this.totalAmount));
    }

    public void cancel() {
        if (status == OrderStatus.SHIPPED || status == OrderStatus.DELIVERED) {
            throw new OrderDomainException("Cannot cancel order in status: " + status);
        }
        this.status = OrderStatus.CANCELLED;
        domainEvents.add(new OrderCancelledEvent(this.id, this.customerId));
    }

    public void markAsShipped(String trackingNumber) {
        if (status != OrderStatus.CONFIRMED) {
            throw new OrderDomainException("Only confirmed orders can be shipped");
        }
        this.status = OrderStatus.SHIPPED;
        domainEvents.add(new OrderShippedEvent(this.id, trackingNumber));
    }

    private void ensureModifiable() {
        if (status != OrderStatus.PENDING) {
            throw new OrderDomainException("Order is not modifiable");
        }
    }

    private void recalculateTotal() {
        this.totalAmount = items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.zero("JPY"), Money::add);
    }
}

// Driving Port
public interface CreateOrderUseCase {
    CreateOrderResult execute(CreateOrderCommand command);
}

// Driven Ports
public interface OrderRepository {
    Optional<Order> findById(String id);
    Order save(Order order);
}

public interface EventPublisher {
    void publish(List<DomainEvent> events);
}

// Use Case実装
@Service
@Transactional
public class CreateOrderService implements CreateOrderUseCase {

    private final OrderRepository orderRepository;
    private final EventPublisher eventPublisher;
    private final IdGenerator idGenerator;

    @Override
    public CreateOrderResult execute(CreateOrderCommand command) {
        Order order = new Order(idGenerator.generate(), command.customerId());

        for (OrderItemCommand item : command.items()) {
            order.addItem(
                item.productId(),
                item.productName(),
                Money.of(item.price(), "JPY"),
                item.quantity()
            );
        }

        order.confirm();
        Order saved = orderRepository.save(order);
        eventPublisher.publish(saved.getDomainEvents());
        saved.clearDomainEvents();

        return new CreateOrderResult(saved.getId(), saved.getTotalAmount().toString());
    }
}

// Driven Adapter - JPA Repository
@Repository
public class JpaOrderRepositoryAdapter implements OrderRepository {

    private final SpringDataOrderRepository jpaRepo;
    private final OrderPersistenceMapper mapper;

    @Override
    public Optional<Order> findById(String id) {
        return jpaRepo.findById(id).map(mapper::toDomain);
    }

    @Override
    public Order save(Order order) {
        OrderJpaEntity entity = mapper.toJpaEntity(order);
        OrderJpaEntity saved = jpaRepo.save(entity);
        return mapper.toDomain(saved);
    }
}

// Driven Adapter - Kafka Event Publisher
@Component
public class KafkaEventPublisher implements EventPublisher {

    private final KafkaTemplate<String, String> kafkaTemplate;
    private final ObjectMapper objectMapper;

    @Override
    public void publish(List<DomainEvent> events) {
        for (DomainEvent event : events) {
            String topic = resolveTopic(event);
            String payload = serialize(event);
            kafkaTemplate.send(topic, event.getAggregateId(), payload);
        }
    }

    private String resolveTopic(DomainEvent event) {
        if (event instanceof OrderConfirmedEvent) return "order.confirmed";
        if (event instanceof OrderCancelledEvent) return "order.cancelled";
        if (event instanceof OrderShippedEvent) return "order.shipped";
        return "order.unknown";
    }
}

// Driving Adapter - REST Controller
@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {

    private final CreateOrderUseCase createOrderUseCase;
    private final CancelOrderUseCase cancelOrderUseCase;

    @PostMapping
    public ResponseEntity<CreateOrderResponse> createOrder(
            @Valid @RequestBody CreateOrderRequest request) {
        CreateOrderCommand command = request.toCommand();
        CreateOrderResult result = createOrderUseCase.execute(command);
        return ResponseEntity.status(201).body(CreateOrderResponse.from(result));
    }

    @DeleteMapping("/{orderId}")
    public ResponseEntity<Void> cancelOrder(@PathVariable String orderId) {
        cancelOrderUseCase.execute(orderId);
        return ResponseEntity.noContent().build();
    }
}