CompletableFuture加速查询单商品信息

在查询单商品信息返回的接口中，如商品信息分布在多个数据表，需要各自查询再汇总商品信息，且查询没有先后依赖关系，各自独立。

这种场景下，不建议使用连表查询，MySQL下单表并通过索引的查询效率更高。建议使用多线程（CompletableFuture）+单表查询（Entity）实现，最后再通过 BeanUtil.copyProperties 汇总数据。

@Override
    public Result selectOwnerGoodsDetails(String userId, String goodsId) {

        // 返回实体
        GetOwnerGoodsDetailsResp getOwnerGoodsDetailsResp = null;

        // 查询特定Goods
        QueryWrapper<MarketGoodsEntity> wrapper = new QueryWrapper<MarketGoodsEntity>();
        wrapper.eq("goods_id", goodsId);
        MarketGoodsEntity marketGoodsEntity = marketGoodsMapper.selectOne(wrapper);
        // 查询到商品，convert
        if (marketGoodsEntity != null) {
          	// 实体转返回体
            getOwnerGoodsDetailsResp =
                    marketGoodsEntity2GetOwnerGoodsDetailsResp(marketGoodsEntity);
        }

        if (getOwnerGoodsDetailsResp != null) {

            // 设置Goods状态信息
            // Goods状态，0：不可出售 1：可上架 2：倒计时上架 3：可下架 4：锁定中不允许下架
            switch (marketGoodsEntity.getGoodsStatus()) {
                case 0:
                case 3:
                    // 判断可出售，可上架，倒计时上架

                    // 不可售出
                    QueryWrapper<MarketNftBizEntity> nftBizEntityExamineQueryWrapper =
                            new QueryWrapper<>();
                    nftBizEntityExamineQueryWrapper.eq(
                            "nft_template_id", marketGoodsEntity.getNftTemplateId());
                    MarketNftBizEntity nftBizEntity =
                            marketNftBizMapper.selectOne(nftBizEntityExamineQueryWrapper);
                    if (nftBizEntity != null) {
                        if (nftBizEntity.getSecExamineStatus() == 0
                                || nftBizEntity.getSecExamineStatus() == 2) {
                            getOwnerGoodsDetailsResp.setGoodsStatus(0);
                        }

                        // 可上架
                        if (nftBizEntity.getSecExamineStatus() == 1) {
                            // 非倒计时上架
                            if (marketGoodsEntity.getGoodsStatus() == 3) {
                                getOwnerGoodsDetailsResp.setGoodsStatus(2);
                            } else {
                                // 倒计时上架
                                getOwnerGoodsDetailsResp.setGoodsStatus(1);
                            }
                        }
                    }

                    break;

                case 1:
                case 2:
                    // 判断可下架
                    //                    if (marketGoodsEntity.getGoodsStatus() == 2) {
                    //                        getOwnerGoodsDetailsResp.setGoodsStatus(4);
                    //                    } else {
                    getOwnerGoodsDetailsResp.setGoodsStatus(3);
                    //                    }
                    break;

                default:
                    break;
            }

            // 异步编程获取数据

            CompletableFuture<GetOwnerGoodsDetailsResp> circuitAndStatusFuture =
                    CompletableFuture.supplyAsync(
                            () -> {
                                GetOwnerGoodsDetailsResp circuitAndStatusFutureResult =
                                        new GetOwnerGoodsDetailsResp();

                                // 获取熔断级别数据
                                QueryWrapper<NftCircuitBreakerEntity>
                                        nftCircuitBreakerEntityQueryWrapper = new QueryWrapper<>();
                                nftCircuitBreakerEntityQueryWrapper.eq("data_id", goodsId);
                                nftCircuitBreakerEntityQueryWrapper.orderByDesc("id");
                                nftCircuitBreakerEntityQueryWrapper.last("LIMIT 1");
                                NftCircuitBreakerEntity nftCircuitBreakerEntity =
                                        nftCircuitBreakerMapper.selectOne(
                                                nftCircuitBreakerEntityQueryWrapper);
                                // 返回体增加熔断信息
                                if (nftCircuitBreakerEntity != null) {
                                    circuitAndStatusFutureResult.setCircuitLevel(
                                            nftCircuitBreakerEntity.getLevel());
                                } else {
                                    circuitAndStatusFutureResult.setCircuitLevel(0);
                                }

                                return circuitAndStatusFutureResult;
                            },
                            threadPoolExecutor);

            // 记录返回体临时使用值
            GetOwnerGoodsDetailsResp finalGetOwnerGoodsDetailsResp = getOwnerGoodsDetailsResp;

          	// 下文查询信息有严格的依赖关系，所以放在一个CompletableFuture实现
            CompletableFuture<GetOwnerGoodsDetailsResp> nftInfoFuture =
                    CompletableFuture.supplyAsync(
                            () -> {
                                GetOwnerGoodsDetailsResp nftInfoFutureResult =
                                        new GetOwnerGoodsDetailsResp();

                                // 查询NFT信息
                                QueryWrapper<MarketNftBaseEntity> nftBaseEntityQueryWrapper =
                                        new QueryWrapper<>();
                                nftBaseEntityQueryWrapper.eq(
                                        "nft_template_id",
                                        finalGetOwnerGoodsDetailsResp.getNftTemplateId());
                                MarketNftBaseEntity nftBaseEntity =
                                        marketNftBaseMapper.selectOne(nftBaseEntityQueryWrapper);
                                // 返回体增加Nft名称，内容hash，NFT合约地址，Nft介绍，Nft详情
                                if (nftBaseEntity != null) {
                                    nftInfoFutureResult.setNftName(nftBaseEntity.getNftName());
                                    nftInfoFutureResult.setNftContent(
                                            nftBaseEntity.getNftContent());
                                    nftInfoFutureResult.setNftContactAddress(
                                            nftBaseEntity.getNftAddress());
                                    nftInfoFutureResult.setNftIntroduce(
                                            nftBaseEntity.getNftIntroduce());
                                    nftInfoFutureResult.setNftDescription(
                                            nftBaseEntity.getNftDescription());
                                    nftInfoFutureResult.setNftCover(nftBaseEntity.getNftCover());
                                    nftInfoFutureResult.setNftRealFileType(
                                            nftBaseEntity.getNftContentType());
                                    nftInfoFutureResult.setSeriesId(
                                            String.valueOf(nftBaseEntity.getSeriesId()));

                                    // 查询预览文件
                                    QueryWrapper<IpfsFileEntity> ipfsFileEntityQueryWrapper =
                                            new QueryWrapper<>();
                                    ipfsFileEntityQueryWrapper.eq(
                                            "file_hash", nftBaseEntity.getNftContent());
                                    IpfsFileEntity ipfsFileEntity =
                                            ipfsFileMapper.selectOne(ipfsFileEntityQueryWrapper);
                                    // 返回体增加宝贝文件预览链接
                                    if (ipfsFileEntity != null) {
                                        nftInfoFutureResult.setNftRealFileUrl(
                                                ipfsFileEntity.getFileUrl());
                                    }

                                    // 查询系列信息
                                    QueryWrapper<MarketSeriesEntity> seriesEntityQueryWrapper =
                                            new QueryWrapper<>();
                                    seriesEntityQueryWrapper.eq("id", nftBaseEntity.getSeriesId());
                                    MarketSeriesEntity seriesEntity =
                                            marketSeriesMapper.selectOne(seriesEntityQueryWrapper);
                                    // 返回体增加系列名称，系列头像
                                    if (seriesEntity != null) {
                                        nftInfoFutureResult.setSeriesName(
                                                seriesEntity.getSeriesName());
                                        nftInfoFutureResult.setSeriesAvatar(
                                                seriesEntity.getCoverImg());
                                    }

                                    // 查询作者信息
                                    QueryWrapper<OldUserEntity> oldUserEntityQueryWrapper =
                                            new QueryWrapper<>();
                                    oldUserEntityQueryWrapper.eq(
                                            "user_id", nftBaseEntity.getPublisherId());
                                    OldUserEntity oldUserEntity =
                                            oldUserMapper.selectOne(oldUserEntityQueryWrapper);
                                    // 返回体增加作者昵称，作者头像
                                    if (oldUserEntity != null) {
                                        nftInfoFutureResult.setAuthorNickName(
                                                oldUserEntity.getNickName());
                                        nftInfoFutureResult.setAuthorAvatar(
                                                oldUserEntity.getUserAvatar());
                                    }
                                }

                                return nftInfoFutureResult;
                            },
                            threadPoolExecutor);

            CompletableFuture<GetOwnerGoodsDetailsResp> addressAvatarFuture =
                    CompletableFuture.supplyAsync(
                            () -> {
                                GetOwnerGoodsDetailsResp addressAvatarFutureResult =
                                        new GetOwnerGoodsDetailsResp();

                                // 查询地址头像
                                QueryWrapper<UserAddressEntity> addressEntityQueryWrapper =
                                        new QueryWrapper<>();
                                addressEntityQueryWrapper.eq(
                                        "user_address",
                                        finalGetOwnerGoodsDetailsResp.getOwnerAddress());
                                UserAddressEntity addressEntity =
                                        userAddressMapper.selectOne(addressEntityQueryWrapper);
                                // 返回体增加地址头像
                                if (addressEntity != null) {
                                    addressAvatarFutureResult.setOwnerAddressAvatar(
                                            addressEntity.getAddressAvatar());
                                }

                                return addressAvatarFutureResult;
                            },
                            threadPoolExecutor);

            CompletableFuture<GetOwnerGoodsDetailsResp> guidePriceFuture =
                    CompletableFuture.supplyAsync(
                            () -> {
                                GetOwnerGoodsDetailsResp guidePriceFutureResult =
                                        new GetOwnerGoodsDetailsResp();

                                // 查询指导价格
                                // 查询NFT指导价格信息——前一天价格price
                                QueryWrapper<MarketNftPriceHistoryEntity>
                                        priceHistoryEntityQueryWrapper = new QueryWrapper<>();
                                priceHistoryEntityQueryWrapper.eq(
                                        "nft_template_id",
                                        finalGetOwnerGoodsDetailsResp.getNftTemplateId());
                                priceHistoryEntityQueryWrapper.orderByDesc("id");
                                priceHistoryEntityQueryWrapper.last("LIMIT 1");
                                MarketNftPriceHistoryEntity priceHistoryEntity =
                                        marketNftPriceHistoryMapper.selectOne(
                                                priceHistoryEntityQueryWrapper);
                                // 返回体增加指导价格
                                if (priceHistoryEntity != null) {
                                    guidePriceFutureResult.setGuidingPrice(
                                            priceHistoryEntity.getPrice());
                                }

                                return guidePriceFutureResult;
                            },
                            threadPoolExecutor);

            CompletableFuture<GetOwnerGoodsDetailsResp> transactionFuture =
                    CompletableFuture.supplyAsync(
                            () -> {
                                GetOwnerGoodsDetailsResp transactionFutureResult =
                                        new GetOwnerGoodsDetailsResp();

                                // 查询goods对于用户的最后一次交易hash
                                transactionFutureResult.setTransactionHash(
                                        marketGoodsService.getGoodsTransactionHashByGoodsId(
                                                finalGetOwnerGoodsDetailsResp.getGoodsId(),
                                                finalGetOwnerGoodsDetailsResp.getOwnerAddress()));

                                return transactionFutureResult;
                            },
                            threadPoolExecutor);

            // allOf方式并行
          	// 异步，全部完成才完成
            CompletableFuture.allOf(
                    circuitAndStatusFuture,
                    nftInfoFuture,
                    addressAvatarFuture,
                    guidePriceFuture,
                    transactionFuture);

            // 使用 join 方法手动获取结果
          	// 获取返回结果的数组，顺序与CompletableFuture顺序一致
            List<GetOwnerGoodsDetailsResp> getOwnerGoodsDetailsRespList =
                    Stream.of(
                                    circuitAndStatusFuture,
                                    nftInfoFuture,
                                    addressAvatarFuture,
                                    guidePriceFuture,
                                    transactionFuture)
                            .map(CompletableFuture::join)
                            .collect(Collectors.toList());

            // 赋值到返回实体
            // 后一次set是对前一次set的补充，忽略空值
            for (GetOwnerGoodsDetailsResp getOwnerGoodsDetailsRespTemp :
                    getOwnerGoodsDetailsRespList) {
              	// 依赖：cn.hutool.core.bean.BeanUtil
                BeanUtil.copyProperties(
                        getOwnerGoodsDetailsRespTemp,
                        getOwnerGoodsDetailsResp,
                  			// 设置set忽略null值，源的null值不处理，不覆盖目的源
                        CopyOptions.create().setIgnoreNullValue(true).setIgnoreError(true));
            }
        }

        log.info(
                "Goods信息：{}",
                getOwnerGoodsDetailsResp == null ? "" : getOwnerGoodsDetailsResp.toString());
        return Result.success(getOwnerGoodsDetailsResp);
    }