#CQRS 命令查询职责分离

// 写入侧 - 使用领域模型
@Service
public class OrderCommandService {

    private final OrderRepository orderRepository;

    public OrderId createOrder(CreateOrderCommand command) {
        Order order = new Order(
            OrderId.generate(),
            customerRepository.findById(command.getCustomerId()),
            toOrderLines(command.getLines())
        );
        orderRepository.save(order);
        return order.getId();
    }
}

// 读取侧 - 直接使用 DTO 和 SQL
@Service
public class OrderQueryService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public OrderDetailDTO getOrderDetail(String orderId) {
        String sql = """
            SELECT o.*, c.name as customer_name, c.phone as customer_phone,
                   GROUP_CONCAT(p.name) as product_names
            FROM orders o
            LEFT JOIN customers c ON o.customer_id = c.id
            LEFT JOIN order_items oi ON o.id = oi.order_id
            LEFT JOIN products p ON oi.product_id = p.id
            WHERE o.id = ?
            GROUP BY o.id
            """;
        return jdbcTemplate.queryForObject(sql, new OrderDetailRowMapper(), orderId);
    }
}

// 事件驱动的同步实现
@Service
public class OrderProjectionService {

    @Autowired
    private ElasticsearchTemplate esTemplate;

    @KafkaListener(topics = "order-events")
    public void handleOrderEvent(OrderEvent event) {
        if (event instanceof OrderCreatedEvent) {
            OrderCreatedEvent created = (OrderCreatedEvent) event;
            OrderSearchDocument doc = buildDocument(created);
            esTemplate.save(doc);
        } else if (event instanceof OrderCancelledEvent) {
            OrderCancelledEvent cancelled = (OrderCancelledEvent) event;
            esTemplate.update(cancelled.getOrderId(), doc -> {
                doc.setStatus("CANCELLED");
                return doc;
            });
        }
    }
}

// 写入模型 - 领域模型
public class Order {
    private OrderId id;
    private Customer customer;
    private List<OrderLine> lines;
    private Money totalAmount;
    private OrderStatus status;

    public void confirm() {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalStateException("只有待确认订单可以确认");
        }
        this.status = OrderStatus.CONFIRMED;
    }

    public void addLine(OrderLine line) {
        this.lines.add(line);
        this.totalAmount = this.totalAmount.add(line.getSubtotal());
    }
}

// 读取模型 - 反规范化的 DTO
public class OrderListItem {
    private String orderId;
    private String orderNumber;
    private String customerName;  // 反规范化，避免 JOIN
    private String customerPhone;
    private List<String> productNames;  // 存储商品名称列表
    private BigDecimal totalAmount;
    private String status;
    private LocalDateTime createdAt;

    // 这个类专门为查询优化，不包含业务逻辑
}

// Elasticsearch 文档模型
@Document(indexName = "orders")
public class OrderSearchDocument {
    @Id
    private String id;

    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String orderNumber;

    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String customerName;

    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String productNames;  // 用 IK 分词器支持商品名称搜索

    @Field(type = FieldType.Keyword)
    private String status;

    @Field(type = FieldType.Date)
    private LocalDateTime createdAt;

    // 方便的搜索方法
    public static OrderSearchDocument from(Order order) {
        OrderSearchDocument doc = new OrderSearchDocument();
        doc.setId(order.getId().getValue());
        doc.setOrderNumber(order.getOrderNumber());
        doc.setCustomerName(order.getCustomer().getName());
        doc.setProductNames(order.getLines().stream()
            .map(l -> l.getProduct().getName())
            .collect(Collectors.joining(" ")));
        return doc;
    }
}

// 如果是异步同步，会有一致性延迟
@Service
public class OrderCommandService {

    public OrderId createOrder(CreateOrderCommand command) {
        // 写入主库
        Order order = createOrderEntity(command);
        orderRepository.save(order);

        // 发布事件异步同步到读库
        eventPublisher.publish(new OrderCreatedEvent(order));

        return order.getId();
    }
}

// 客户端需要处理「写入后立即查询可能失败」的情况
@Service
public class OrderController {

    @PostMapping("/orders")
    public ResponseEntity<OrderResponse> createOrder(...) {
        OrderId orderId = commandService.createOrder(command);
        // 可能读库还没有同步，返回创建成功，让前端稍后刷新
        return ResponseEntity.accepted()
            .header("X-Order-Id", orderId.getValue())
            .build();
    }
}

// 可能需要维护审计日志
@Service
public class OrderProjectionService {

    @KafkaListener(topics = "order-events")
    public void handleEvent(DomainEvent event) {
        OrderProjection projection = loadOrCreateProjection(event.getOrderId());
        applyEvent(projection, event);
        saveProjection(projection);

        // 同时记录历史
        saveToHistory(event);
    }
}