CQRSパターン：読み取り・書き込み分離によるパフォーマンスとスケーラビリティ向上

CreateOrderCommand
UpdateCustomerAddressCommand
CancelSubscriptionCommand

GetOrderDetailsQuery
FindCustomersByRegionQuery
ListProductsWithStockLevelQuery

// コマンドインターフェース
public interface OrderCommandService {
    void createOrder(CreateOrderCommand command);
    void updateOrderStatus(UpdateOrderStatusCommand command);
    void cancelOrder(CancelOrderCommand command);
}

// クエリインターフェース
public interface OrderQueryService {
    OrderDetailsDto getOrderById(Long orderId);
    List<OrderSummaryDto> getOrdersByCustomer(Long customerId);
    OrderStatisticsDto getOrderStatistics(DateRange range);
}

// コマンドオブジェクト
public class CreateOrderCommand {
    private final String customerId;
    private final List<OrderItemDto> items;
    private final ShippingAddressDto shippingAddress;
    private final PaymentMethodDto paymentMethod;
    
    // コンストラクタ、ゲッターなど
}

// コマンドハンドラインターフェース
public interface CommandHandler<T> {
    void handle(T command);
}

// 具体的なコマンドハンドラ
@Service
public class CreateOrderCommandHandler implements CommandHandler<CreateOrderCommand> {
    
    private final OrderRepository orderRepository;
    private final CustomerRepository customerRepository;
    private final DomainEventPublisher eventPublisher;
    
    // コンストラクタによる依存性注入
    
    @Transactional
    public void handle(CreateOrderCommand command) {
        // 顧客の存在確認
        Customer customer = customerRepository.findById(command.getCustomerId())
            .orElseThrow(() -> new CustomerNotFoundException(command.getCustomerId()));
        
        // 注文ドメインオブジェクトの作成
        Order order = new Order(customer);
        
        // 注文項目の追加
        command.getItems().forEach(item -> {
            order.addItem(new OrderItem(item.getProductId(), item.getQuantity(), item.getPrice()));
        });
        
        // 配送先と支払い方法の設定
        order.setShippingAddress(map(command.getShippingAddress()));
        order.setPaymentMethod(map(command.getPaymentMethod()));
        
        // ビジネスルールのチェック
        order.validate();
        
        // 永続化
        orderRepository.save(order);
        
        // イベントの発行（オプション、イベントソーシングと組み合わせる場合）
        eventPublisher.publish(new OrderCreatedEvent(order.getId(), order));
    }
}

// クエリオブジェクト
public class GetOrderDetailsQuery {
    private final String orderId;
    
    public GetOrderDetailsQuery(String orderId) {
        this.orderId = orderId;
    }
    
    public String getOrderId() {
        return orderId;
    }
}

// レスポンスDTO
public class OrderDetailsDto {
    private String orderId;
    private String customerName;
    private List<OrderItemDto> items;
    private BigDecimal totalAmount;
    private String status;
    private LocalDateTime createdAt;
    private AddressDto shippingAddress;
    private String paymentMethod;
    
    // ゲッター、セッターなど
}

// クエリハンドラインターフェース
public interface QueryHandler<Q, R> {
    R handle(Q query);
}

// 具体的なクエリハンドラ
@Service
public class GetOrderDetailsQueryHandler implements QueryHandler<GetOrderDetailsQuery, OrderDetailsDto> {
    
    private final OrderReadRepository orderReadRepository;
    
    // コンストラクタによる依存性注入
    
    public OrderDetailsDto handle(GetOrderDetailsQuery query) {
        // 読み取り専用リポジトリからデータを取得
        // これは非正規化されたビューやテーブルから効率的に取得することが多い
        OrderReadModel order = orderReadRepository.findDetailedOrderById(query.getOrderId())
            .orElseThrow(() -> new OrderNotFoundException(query.getOrderId()));
        
        // レスポンスDTOへのマッピング
        OrderDetailsDto dto = new OrderDetailsDto();
        dto.setOrderId(order.getId());
        dto.setCustomerName(order.getCustomerName());
        dto.setItems(mapToItemDtos(order.getItems()));
        dto.setTotalAmount(order.getTotalAmount());
        dto.setStatus(order.getStatus());
        dto.setCreatedAt(order.getCreatedAt());
        dto.setShippingAddress(mapToAddressDto(order.getShippingAddress()));
        dto.setPaymentMethod(order.getPaymentMethod());
        
        return dto;
    }
}

// ドメインイベント
public class OrderCreatedEvent implements DomainEvent {
    private final String orderId;
    private final Order orderData;
    private final LocalDateTime occurredAt;
    
    // コンストラクタ、ゲッターなど
}

// イベントハンドラ
@Component
public class OrderCreatedEventHandler {
    
    private final OrderReadModelRepository readModelRepository;
    
    @EventListener
    public void handle(OrderCreatedEvent event) {
        // 読み取りモデル用のデータを作成
        OrderReadModel readModel = new OrderReadModel();
        readModel.setId(event.getOrderId());
        readModel.setCustomerName(event.getOrderData().getCustomer().getName());
        readModel.setTotalAmount(event.getOrderData().calculateTotalAmount());
        readModel.setStatus("CREATED");
        readModel.setCreatedAt(event.getOccurredAt());
        
        // 読み取りモデルに項目を追加
        event.getOrderData().getItems().forEach(item -> {
            OrderItemReadModel itemReadModel = new OrderItemReadModel();
            itemReadModel.setProductId(item.getProductId());
            itemReadModel.setProductName(fetchProductName(item.getProductId())); // 非正規化
            itemReadModel.setQuantity(item.getQuantity());
            itemReadModel.setPrice(item.getPrice());
            readModel.getItems().add(itemReadModel);
        });
        
        // 配送先や支払い方法など他の情報も設定
        
        // 読み取りモデルの保存
        readModelRepository.save(readModel);
    }
}

@Service
public class OrderReadModelSynchronizer {
    
    private final OrderRepository writeRepository;
    private final OrderReadModelRepository readRepository;
    
    @Scheduled(fixedRate = 60000) // 1分ごとに実行
    public void synchronizeOrders() {
        // 最後の同期以降に変更された注文を取得
        LocalDateTime lastSyncTime = getLastSynchronizationTime();
        List<Order> updatedOrders = writeRepository.findOrdersUpdatedSince(lastSyncTime);
        
        for (Order order : updatedOrders) {
            // 読み取りモデルの更新または作成
            OrderReadModel readModel = readRepository.findById(order.getId())
                .orElse(new OrderReadModel());
            
            // データのマッピング
            updateReadModel(readModel, order);
            
            // 保存
            readRepository.save(readModel);
        }
        
        // 同期時間の更新
        updateLastSynchronizationTime(LocalDateTime.now());
    }
}

┌─────────────────┐         ┌─────────────────┐
│   アプリケーション   │────────▶│ メッセージブローカー │
└─────────┬───────┘         └────────┬────────┘
          │                          │
          │                          │
┌─────────▼───────┐         ┌───────▼─────────┐
│  コマンドモデル   │         │   イベントハンドラ   │
└─────────┬───────┘         └───────┬─────────┘
          │                          │
          │                          │
┌─────────▼───────┐         ┌───────▼─────────┐
│   PostgreSQL    │         │  ElasticSearch   │
│ (書き込みDB)    │         │  (読み取りDB)    │
└─────────────────┘         └─────────────────┘

// イベント
public class OrderPlacedEvent {
    private final String orderId;
    private final String customerId;
    private final List<OrderItem> items;
    private final LocalDateTime timestamp;
    
    // コンストラクタ、ゲッターなど
}

// 集約ルート
public class Order {
    private String id;
    private String customerId;
    private List<OrderItem> items = new ArrayList<>();
    private OrderStatus status;
    private List<DomainEvent> uncommittedEvents = new ArrayList<>();
    
    // コマンドを処理するメソッド
    public void placeOrder(String customerId, List<OrderItem> items) {
        validateOrder(customerId, items);
        
        // イベント生成
        OrderPlacedEvent event = new OrderPlacedEvent(
            this.id, customerId, items, LocalDateTime.now());
        
        // イベント適用と記録
        applyEvent(event);
        uncommittedEvents.add(event);
    }
    
    // イベントを適用してオブジェクトの状態を更新
    private void applyEvent(OrderPlacedEvent event) {
        this.id = event.getOrderId();
        this.customerId = event.getCustomerId();
        this.items = new ArrayList<>(event.getItems());
        this.status = OrderStatus.PLACED;
    }
    
    // 未コミットのイベントを取得
    public List<DomainEvent> getUncommittedEvents() {
        return new ArrayList<>(uncommittedEvents);
    }
    
    // イベントをコミット済みとしてマーク
    public void markEventsAsCommitted() {
        uncommittedEvents.clear();
    }
}

// イベントストア
@Service
public class EventStore {
    
    private final EventRepository repository;
    private final EventBus eventBus;
    
    public void saveEvents(String aggregateId, List<DomainEvent> events, int expectedVersion) {
        // バージョンの検証（楽観的ロック）
        int currentVersion = repository.getAggregateVersion(aggregateId);
        if (expectedVersion != currentVersion) {
            throw new ConcurrencyException();
        }
        
        int newVersion = expectedVersion;
        for (DomainEvent event : events) {
            newVersion++;
            event.setVersion(newVersion);
            
            // イベントの永続化
            repository.save(new EventDescriptor(aggregateId, event, newVersion));
            
            // イベントのパブリッシュ（読み取りモデル更新のため）
            eventBus.publish(event);
        }
    }
    
    public List<DomainEvent> getEvents(String aggregateId) {
        return repository.findByAggregateId(aggregateId).stream()
            .map(EventDescriptor::getEvent)
            .collect(Collectors.toList());
    }
}

@Service
public class OrderSummaryProjection {
    
    private final OrderSummaryRepository repository;
    
    @EventHandler
    public void on(OrderPlacedEvent event) {
        OrderSummary summary = new OrderSummary();
        summary.setOrderId(event.getOrderId());
        summary.setCustomerId(event.getCustomerId());
        summary.setTotalItems(event.getItems().size());
        summary.setTotalAmount(calculateTotal(event.getItems()));
        summary.setStatus("PLACED");
        summary.setCreatedAt(event.getTimestamp());
        
        repository.save(summary);
    }
    
    @EventHandler
    public void on(OrderShippedEvent event) {
        OrderSummary summary = repository.findById(event.getOrderId())
            .orElseThrow(() -> new ProjectionNotFoundException(event.getOrderId()));
        
        summary.setStatus("SHIPPED");
        summary.setShippedAt(event.getTimestamp());
        
        repository.save(summary);
    }
    
    @EventHandler
    public void on(OrderDeliveredEvent event) {
        OrderSummary summary = repository.findById(event.getOrderId())
            .orElseThrow(() -> new ProjectionNotFoundException(event.getOrderId()));
        
        summary.setStatus("DELIVERED");
        summary.setDeliveredAt(event.getTimestamp());
        
        repository.save(summary);
    }
}