インモビインモビ

// ドメインイベントの基底クラス
public abstract class DomainEvent {
    private final UUID eventId;
    private final Instant occurredOn;
    
    protected DomainEvent() {
        this.eventId = UUID.randomUUID();
        this.occurredOn = Instant.now();
    }
    
    public UUID getEventId() {
        return eventId;
    }
    
    public Instant getOccurredOn() {
        return occurredOn;
    }
}

// 具体的なドメインイベント
public class OrderConfirmedEvent extends DomainEvent {
    private final OrderId orderId;
    private final CustomerId customerId;
    private final Money totalAmount;
    private final ListOrderItemData> items;
    
    public OrderConfirmedEvent(
        OrderId orderId,
        CustomerId customerId,
        Money totalAmount,
        ListOrderItemData> items
    ) {
        super();
        this.orderId = orderId;
        this.customerId = customerId;
        this.totalAmount = totalAmount;
        this.items = Collections.unmodifiableList(items);
    }
    
    // getterメソッド省略
}

// イベントを発行する集約
public class Order {
    private final ListDomainEvent> domainEvents = new ArrayList();
    
    // 価格情報を適用（割引、税額などを反映）
    public void applyPricing(OrderTotal total) {
        this.totalAmount = total.getFinalAmount();
        this.discountAmount = total.getDiscountAmount();
        this.taxAmount = total.getTaxAmount();
    }
    
    public void confirm() {
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException("下書き状態の注文のみ確定できます");
        }
        if (items.isEmpty()) {
            throw new IllegalStateException("商品が含まれていない注文は確定できません");
        }
        
        this.status = OrderStatus.CONFIRMED;
        
        // イベントの発行
        domainEvents.add(new OrderConfirmedEvent(
            this.id,
            this.customerId,
            this.totalAmount,
            this.items.stream()
                .map(item -> new OrderItemData(
                    item.getProductId(),
                    item.getQuantity(),
                    item.getUnitPrice()
                ))
                .collect(Collectors.toList())
        ));
    }
    
    public ListDomainEvent> pullDomainEvents() {
        ListDomainEvent> events = new ArrayList(domainEvents);
        domainEvents.clear();
        return events;
    }
}

// イベントハンドラの例
@Component
public class OrderConfirmedEventHandler {
    private final InventoryService inventoryService;
    private final EmailService emailService;
    private final PointService pointService;
    
    @EventHandler
    @Transactional
    public void handle(OrderConfirmedEvent event) {
        // 在庫の引当
        inventoryService.allocateInventory(
            event.getOrderId(),
            event.getItems()
        );
        
        // 確認メールの送信
        emailService.sendOrderConfirmation(
            event.getCustomerId(),
            event.getOrderId()
        );
        
        // ポイントの付与
        pointService.addPoints(
            event.getCustomerId(),
            calculatePoints(event.getTotalAmount())
        );
    }
    
    private int calculatePoints(Money amount) {
        // 100円につき1ポイント
        return amount.getAmount()
            .divide(BigDecimal.valueOf(100), RoundingMode.DOWN)
            .intValue();
    }
}

// イベントディスパッチャー
@Component
public class DomainEventDispatcher {
    private final ApplicationEventPublisher publisher;
    
    @Transactional
    public void dispatch(ListDomainEvent> events) {
        events.forEach(publisher::publishEvent);
    }
}

// Outboxパターンによる確実なイベント発行
@Component
public class OutboxEventDispatcher {
    private final EventOutboxRepository outboxRepository;
    private final MessagePublisher messagePublisher;
    
    @Transactional
    public void dispatch(ListDomainEvent> events) {
        // イベントをOutboxテーブルに保存（トランザクション内）
        events.forEach(event -> {
            EventOutbox outboxEntry = new EventOutbox(
                event.getEventId(),
                event.getClass().getName(),
                serialize(event),
                EventStatus.PENDING
            );
            outboxRepository.save(outboxEntry);
        });
    }
    
    // 非同期ワーカーが定期的に実行
    @Scheduled(fixedDelay = 5000)
    public void publishPendingEvents() {
        ListEventOutbox> pendingEvents = outboxRepository
            .findByStatus(EventStatus.PENDING);
            
        pendingEvents.forEach(outboxEntry -> {
            try {
                // メッセージブローカーへ発行
                messagePublisher.publish(
                    outboxEntry.getEventType(),
                    outboxEntry.getPayload()
                );
                
                // 発行済みとしてマーク
                outboxEntry.markAsPublished();
                outboxRepository.save(outboxEntry);
            } catch (Exception e) {
                // リトライ処理
                outboxEntry.incrementRetryCount();
                outboxRepository.save(outboxEntry);
            }
        });
    }
}