单声道与磁通相结合

Question

我有一个简单的任务。我想在订单中添加产品。

public Mono<OrderDTO> addProductsToOrder(String orderId, String[] productIds)
{

    final List<String> productIdsList = Arrays.asList(productIds);

    final Mono<Order> order = orderRepository.findById(orderId)
                                             .switchIfEmpty(orderShouldExists(orderId));

    final Flux<BaseProductInfo> products = fromIterable(productIdsList)
        .flatMap(productId -> productRepository.findById(productId)
                                               .switchIfEmpty(productShouldExists(productId)));

    return order.then(combineLatest(order, products, Tuples::of)
                          .map(objects -> objects.getT1().addProduct(objects.getT2()))
                          .take(productIdsList.size())
                          .last()
                          .flatMap(orderRepository::save)
                          .map(orderMapper::mapToDTO));
}

我还想实现的是返回更新的订单。下面的代码不能像我希望的那样工作。有时所有的产品都被保存，有时一个也没有。我使用的数据库是被动mongo。

Answer 1

从您的代码中，看起来您正试图将BaseProductInfo的列表添加到订单中并保存。您可以通过执行以下操作来实现这一点：

    public Mono<OrderDTO> addProductsToOrder(String orderId, String[] productIds) {

    final List<String> productIdsList = Arrays.asList(productIds);

    final Mono<Order> order = orderRepository.findById(orderId)
                                             .switchIfEmpty(orderShouldExists(orderId));

    final Mono<List<BaseProductInfo>> products = fromIterable(productIdsList)
        .flatMap(productId -> productRepository.findById(productId)
                                               .switchIfEmpty(productShouldExists(productId)))
.collectList();

    return order.zipWith(products).map(tuple -> tuple.getT1().addProducts(tuple.getT2)).flatMap(orderRepository::save)
                          .map(orderMapper::mapToDTO));
}

Answer 2

我用这种方法解决了这个问题。

public Mono<OrderDTO> addProductsToOrder(String orderId, String[] productIds)
{
    return orderRepository.findById(orderId)
                          .switchIfEmpty(orderShouldExists(orderId))
                          .flatMap(order -> Flux
                                       .fromArray(productIds)
                                       .flatMap(productId -> productRepository.findById(productId)
                                                                              .switchIfEmpty(productShouldExists(productId))
                                               )
                                       .doOnNext(order::addProduct)
                                       .then(Mono.just(order))
                                  )
                          .flatMap(orderRepository::save)
                          .map(orderMapper::mapToDTO);
}