ProducerRecord<String, OrderCreatedEvent> record =
        new ProducerRecord<>("order-created", event.orderNo(), event);
kafkaTemplate.send(record);

@Transactional
public void handle(OrderCreatedEvent event) {
    // event_id 上有唯一索引；插入成功才获得本次处理权。
    if (!eventRepository.tryInsert(event.eventId())) {
        return;
    }

    inventoryService.reserve(event.orderNo(), event.warehouseId());
    eventRepository.markSucceeded(event.eventId());
}

public void quickSort(int[] arr, int left, int right) {
    if (left >= right) {
        return;
    }

    int pivotIndex = partition(arr, left, right);
    quickSort(arr, left, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, right);
}

private int partition(int[] arr, int left, int right) {
    int pivot = arr[right];
    int storeIndex = left;

    for (int i = left; i < right; i++) {
        if (arr[i] <= pivot) {
            swap(arr, storeIndex, i);
            storeIndex++;
        }
    }
    swap(arr, storeIndex, right);
    return storeIndex;
}

private void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

private int randomizedPartition(int[] arr, int left, int right) {
    int pivotIndex = ThreadLocalRandom.current().nextInt(left, right + 1);
    swap(arr, pivotIndex, right);
    return partition(arr, left, right);
}

orders.sort(Comparator
        .comparing(OrderCandidate::getCustomerLevel).reversed()
        .thenComparing(OrderCandidate::getPromiseTime)
        .thenComparing(OrderCandidate::getCreatedAt));

for (OrderShard shard : shards) {
    executor.submit(() -> fulfillmentService.process(shard));
}

int[] priorities = {8, 3, 2, 6, 7, 9};

public void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

public void bubbleSortWithBreak(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        boolean swapped = false;
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        if (!swapped) {
            break;
        }
    }
}

public static void main(String[] args) {
    int[][] cases = {
            {},
            {1},
            {1, 2, 3},
            {5, 4, 3, 2, 1},
            {3, 1, 3, 2}
    };

    for (int[] item : cases) {
        bubbleSortWithBreak(item);
        System.out.println(Arrays.toString(item));
    }
}

public class PickTask {
    private String taskNo;
    private int priority;
    private LocalDateTime createdAt;
}

tasks.sort(Comparator
        .comparingInt(PickTask::getPriority)
        .thenComparing(PickTask::getCreatedAt));

public int factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

public class BomNode {
    private String materialCode;
    private int quantity;
    private List<BomNode> children;
}

public void collectMaterial(BomNode node, int multiplier, Map<String, Integer> result) {
    int requiredQty = node.getQuantity() * multiplier;

    if (node.getChildren() == null || node.getChildren().isEmpty()) {
        result.merge(node.getMaterialCode(), requiredQty, Integer::sum);
        return;
    }

    for (BomNode child : node.getChildren()) {
        collectMaterial(child, requiredQty, result);
    }
}

public void collectMaterial(BomNode node,
                            int multiplier,
                            Map<String, Integer> result,
                            Set<String> path) {
    if (!path.add(node.getMaterialCode())) {
        throw new BizException("BOM存在循环依赖: " + node.getMaterialCode());
    }

    int requiredQty = node.getQuantity() * multiplier;
    if (node.getChildren() == null || node.getChildren().isEmpty()) {
        result.merge(node.getMaterialCode(), requiredQty, Integer::sum);
    } else {
        for (BomNode child : node.getChildren()) {
            collectMaterial(child, requiredQty, result, path);
        }
    }

    path.remove(node.getMaterialCode());
}

record BomFrame(BomNode node, long multiplier) {}

Map<String, Long> result = new HashMap<>();
Deque<BomFrame> stack = new ArrayDeque<>();
stack.push(new BomFrame(root, 1L));
while (!stack.isEmpty()) {
    BomFrame frame = stack.pop();
    BomNode current = frame.node();
    long requiredQty = Math.multiplyExact(current.getQuantity(), frame.multiplier());

    if (current.getChildren() == null || current.getChildren().isEmpty()) {
        result.merge(current.getMaterialCode(), requiredQty, Math::addExact);
        continue;
    }

    for (BomNode child : current.getChildren()) {
        stack.push(new BomFrame(child, requiredQty));
    }
}

@SpringBootApplication
@MapperScan("com.example.scm.**.mapper")
public class ScmApplication {
    public static void main(String[] args) {
        SpringApplication.run(ScmApplication.class, args);
    }
}

@Service
public class StockReserveService {
    private final InventoryMapper inventoryMapper;
    private final InventoryLogMapper inventoryLogMapper;

    public StockReserveService(InventoryMapper inventoryMapper,
                               InventoryLogMapper inventoryLogMapper) {
        this.inventoryMapper = inventoryMapper;
        this.inventoryLogMapper = inventoryLogMapper;
    }

    @Transactional(rollbackFor = Exception.class)
    public void reserve(ReserveStockCommand command) {
        int affectedRows = inventoryMapper.reserve(
                command.warehouseId(),
                command.skuId(),
                command.quantity()
        );
        if (affectedRows != 1) {
            throw new BizException("库存不足，无法预占");
        }

        inventoryLogMapper.insertReserveLog(command);
    }
}

@Transactional
public void reserveAndNotify(ReserveStockCommand command) {
    inventoryMapper.reserve(command.warehouseId(), command.skuId(), command.quantity());
    wmsClient.notifyReserve(command.orderNo());
    inventoryLogMapper.insertReserveLog(command);
}

@Transactional(rollbackFor = Exception.class)
public void reserve(ReserveStockCommand command) {
    int affectedRows = inventoryMapper.reserve(command.warehouseId(), command.skuId(), command.quantity());
    if (affectedRows != 1) {
        throw new BizException("库存不足，无法预占");
    }
    inventoryLogMapper.insertReserveLog(command);
    eventPublisher.publish(new StockReservedEvent(command.orderNo()));
}