多线程最佳实践之使用completablefuture在电商项目中的应用发票信息的数据组合 主要思想 把发票的每一块数据

发票信息的数据组合

主要思想

把发票的每一块数据分别进行异步查询，最终阻塞等待完成所有模块的查询后，进行数据的最终组装。

使用注意

一定要使用get()方法来阻塞所有异步操作，否则数据会直接返回null。因为CompletableFuture是异步执行的，所以thenRun里面的代码在方法返回时可能还没有执行，导致goodsOrderInvoiceNewVO的属性没有被正确设置。

代码展示

同步写法的代码

public GoodsOrderInvoiceNewVO getInvoiceByOrderCode(String orderCode) {
    GoodsOrderInvoiceNewVO goodsOrderInvoiceNewVO = new GoodsOrderInvoiceNewVO();

    // 1.直接调用方法查询发票的基本信息
    GoodsOrderInvoiceNewVO invoiceInfo = goodsOrderInvoiceMapper.getInvoiceByOrderCode(orderCode);

    // 2.直接调用方法获取发票资料
    List<GoodsOrderInvoiceHistoryDTO> invoiceHistoryList = getInvoiceHistoryByOrderCode(orderCode);

    // 3.直接调用方法获取操作信息
    List<GoodsOrderInvoiceLifecycle> invoiceLifecycleList = getInvoiceLifecycleByOrderCode(orderCode);

    // 4.组合数据
    if (invoiceInfo != null) {
        BeanUtils.copyProperties(invoiceInfo, goodsOrderInvoiceNewVO);
    }
    goodsOrderInvoiceNewVO.setOrderInvoiceHistoryDTOList(invoiceHistoryList);
    goodsOrderInvoiceNewVO.setOrderInvoiceLifecycleList(invoiceLifecycleList);

    return goodsOrderInvoiceNewVO;
}

异步写法的代码

 /**
* 根据订单编号获取发票信息(异步写法)
*
*  @param  orderCode
*  @return
 */
@Override
public GoodsOrderInvoiceNewVO getInvoiceByOrderCodeAsync(String orderCode) {
    
    GoodsOrderInvoiceNewVO goodsOrderInvoiceNewVO = new GoodsOrderInvoiceNewVO();
    
    // 打算采用异步组合式写法      CompletableFuture
    CompletableFuture<GoodsOrderInvoiceNewVO> future1 = CompletableFuture.supplyAsync(() -> {
        //1.异步 先查询发票的基本信息（开票资料、订单资料）
        return goodsOrderInvoiceMapper.getInvoiceByOrderCode(orderCode);
    });
    
    // 2.异步调用获取发票资料
    CompletableFuture<List<GoodsOrderInvoiceHistoryDTO>> future2 = CompletableFuture.supplyAsync(
            () -> getInvoiceHistoryByOrderCode(orderCode));
    
    // 3.异步调用获取操作信息
    CompletableFuture<List<GoodsOrderInvoiceLifecycle>> future3 = CompletableFuture.supplyAsync(
            () -> getInvoiceLifecycleByOrderCode(orderCode));
    
    //4. 组合数据返回
    CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);
    
    allFutures.thenRun(() -> {
        try {
            GoodsOrderInvoiceNewVO goodsOrderInvoiceNewVOTemp = future1.get();
            List<GoodsOrderInvoiceHistoryDTO> invoiceHistoryDTOList = future2.get();
            List<GoodsOrderInvoiceLifecycle> invoiceLifecycleList = future3.get();
            BeanUtils.copyProperties(goodsOrderInvoiceNewVOTemp, goodsOrderInvoiceNewVO);
            goodsOrderInvoiceNewVO.setOrderInvoiceHistoryDTOList(invoiceHistoryDTOList);
            goodsOrderInvoiceNewVO.setOrderInvoiceLifecycleList(invoiceLifecycleList);
            
        } catch (InterruptedException | ExecutionException e) {
            log.error("组合用户发票信息异常");
            throw new RuntimeException(e);
        }
    });
    
    // 等待所有的future完成
    try {
        allFutures.get();
    } catch (InterruptedException | ExecutionException e) {
        log.error("等待异步任务完成时发生异常", e);
        throw new RuntimeException(e);
    }
    
    return goodsOrderInvoiceNewVO;
}

效率提升

同步情况下rt在（70+，110+）的范围内，异步的情况下RT在（50,70+）之间，平均提升效率40%以上

组装商品详情页数据

主要思想

将串行化处理转变化并行化处理，提升数据的加载性能

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class ProductDetailLoader {


 0.假设的类，需要你根据实际情况定义
    class ProductDetail {
        // 产品详情字段
    }

    class InventoryStatus {
        // 库存状态字段
    }

    class UserReview {
        // 用户评论字段
    }
    
    

  1.声明所有的子调用方法
    // 假设的方法，这些通常会在服务层中实现
    CompletableFuture<ProductDetail> getProductDetails(String productId) {
        // 异步获取产品详细信息
        return CompletableFuture.supplyAsync(() -> {
            // 模拟远程服务调用
            return new ProductDetail(productId, "Product Description", "Product Category");
        });
    }

    CompletableFuture<InventoryStatus> getInventoryStatus(String productId) {
        // 异步获取库存状态
        return CompletableFuture.supplyAsync(() -> {
            // 模拟远程服务调用
            return new InventoryStatus(productId, true); // 假设库存可用
        });
    }

    CompletableFuture<Double> getPrice(String productId) {
        // 异步获取价格
        return CompletableFuture.supplyAsync(() -> {
            // 模拟远程服务调用
            return 99.99; // 假设价格
        });
    }

    CompletableFuture<List<UserReview>> getUserReviews(String productId) {
        // 异步获取用户评论
        return CompletableFuture.supplyAsync(() -> {
            // 模拟远程服务调用
            return Arrays.asList(new UserReview(productId, "Review 1", 5),
                                 new UserReview(productId, "Review 2", 4));
        });
    }
    
    
    
    2.组合所有的子调用方法

    // 加载产品详情页面的方法
    public void loadProductDetailsPage(String productId) throws ExecutionException, InterruptedException {
        CompletableFuture<ProductDetail> productDetailsFuture = getProductDetails(productId);
        CompletableFuture<InventoryStatus> inventoryStatusFuture = getInventoryStatus(productId);
        CompletableFuture<Double> priceFuture = getPrice(productId);
        CompletableFuture<List<UserReview>> reviewsFuture = getUserReviews(productId);

        // 等待所有 CompletableFuture 完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(
                productDetailsFuture,
                inventoryStatusFuture,
                priceFuture,
                reviewsFuture
        );

        // 当所有的 CompletableFuture 完成后执行
        allFutures.thenRun(() -> {
            try {
                // 获取并使用结果
                ProductDetail productDetails = productDetailsFuture.get();
                InventoryStatus inventoryStatus = inventoryStatusFuture.get();
                Double price = priceFuture.get();
                List<UserReview> reviews = reviewsFuture.get();

                3. 在这里，你可以组合并显示这些信息
                // 例如，发送给前端或处理其他业务逻辑
                displayProductPage(productDetails, inventoryStatus, price, reviews);

            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }).get(); // 阻塞等待所有任务完成
    }

    // 假设的显示方法
    void displayProductPage(ProductDetail productDetails, InventoryStatus inventoryStatus, Double price, List<UserReview> reviews) {
        // 实现展示逻辑
        System.out.println("Product Details: " + productDetails);
        System.out.println("Inventory Status: " + inventoryStatus);
        System.out.println("Price: " + price);
        System.out.println("User Reviews: " + reviews);
    }
    

   

    // 示例使用
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new ProductDetailLoader().loadProductDetailsPage("product123");
    }
}

使用注意

异常处理

如果不做特殊的处理，在CompletableFuture 的调用链中出现的错误，会一直保留到链路调用结束才会最后抛出异常，导致整个调用都无法继续执行thenAccept, thenApply的后续执行方法；且也导致中间链路被多余调用，浪费了资源。

可以使用exceptionally，来在调用的链路中间提前处理异常。示例如下：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExceptionHandlingIntermediate {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个抛出异常的操作
            throw new RuntimeException("任务失败了");
        });

        CompletableFuture<Integer> handledFuture = future.exceptionally(ex -> {
            System.err.println("任务发生异常: " + ex.getMessage());
            return 0; // 处理异常并返回默认值
        });

        handledFuture.thenAccept(result -> {
            System.out.println("处理异常后的结果：" + result);
        });

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，exceptionally 方法捕获了前一个阶段中的异常，并返回了一个默认值，然后继续执行后续操作。

线程池的使用

completableFuture在执行时，容易出现长时间的阻塞情况，会出现对线程资源的占用，所以要谨慎选择使用其装配的线程池，尽量不要使用默认的线程池，forkJoinPool，而是通过executer来创建自定义的线程池。