设计一个分布式系统中获取用户可用的支付方式列表接口

package com.orde.service.demo;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * 功能描述: 

 * 1。 设计一个分布式系统中获取用户可用的支付方式列表接口
 * 2。 场景描述：用户在支付宝拥有多种支付方式（红包，余额，余额宝，每种工具分布在不同系统上）
 * 3。 每种支付方式通过，远程调用方式，获取可用性，在外部资源不变的情况下，设计一个最短响应（50ms）尽可能设计多的支付方式列表。
 */
public class Alipay {

    /**
     * 支付枚举
     */
    enum PayMethod {
        BALANCE, // 余额
        RED_PACKET, // 红包
        YUEBAO, // 余额宝
    }

    /**
     * 可用性 枚举
     */
    enum Availability {
        AVAILABLE,
        NOT_AVAILABLE
    }

    /**
     * 支付宝可用性检查结果
     */
    @Data
    @AllArgsConstructor
    static class PaymentResult {
        private final PayMethod method;
        private final Availability availability;


    }

    /**
     * 模拟检查余额支付方式可用性的远程调用方法
     *
     * @return 可用性枚举
     */
    private static Availability checkBalanceAvailability() {
        // 这里模拟远程调用，实际应用中可能会涉及网络通信和远程服务调用
        try {
            // 模拟耗时操作，例如网络延迟、服务响应时间等，实际调用可能是通过 HTTP 或 RPC 等方式
            Thread.sleep(10);
            return Availability.AVAILABLE;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return Availability.NOT_AVAILABLE;
        }
    }

    /**
     * 模拟检查红包支付方式可用性的远程调用方法
     *
     * @return 可用性枚举
     */
    private static Availability checkRedPacketAvailability() {
        try {
            Thread.sleep(15);
            return Availability.AVAILABLE;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return Availability.NOT_AVAILABLE;
        }
    }

    /**
     * 模拟检查余额宝支付方式可用性的远程调用方法
     *
     * @return 可用性枚举
     */
    private static Availability checkYueBaoAvailability() {
        try {
            Thread.sleep(80);
            return Availability.AVAILABLE;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return Availability.NOT_AVAILABLE;
        }
    }

    /**
     * 获取用户可用的支付方式列表接口
     *
     * @return 可用支付方式列表
     */
    public static List<PaymentResult> getUserPaymentMethods() {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        List<CompletableFuture<PaymentResult>> futures = new ArrayList<>();

        // 异步检查余额支付方式可用性
        CompletableFuture<PaymentResult> balanceFuture = CompletableFuture.supplyAsync(() -> {
            Availability balanceAvailability = checkBalanceAvailability();
            return new PaymentResult(PayMethod.BALANCE, balanceAvailability);
        }, executorService);
        futures.add(balanceFuture);

        // 异步检查红包支付方式可用性
        CompletableFuture<PaymentResult> redPacketFuture = CompletableFuture.supplyAsync(() -> {
            Availability redPacketAvailability = checkRedPacketAvailability();
            return new PaymentResult(PayMethod.RED_PACKET, redPacketAvailability);
        }, executorService);
        futures.add(redPacketFuture);

        // 异步检查余额宝支付方式可用性
        CompletableFuture<PaymentResult> yueBaoFuture = CompletableFuture.supplyAsync(() -> {
            Availability yueBaoAvailability = checkYueBaoAvailability();
            return new PaymentResult(PayMethod.YUEBAO, yueBaoAvailability);
        }, executorService);
        futures.add(yueBaoFuture);


        List<PaymentResult> resultList = new ArrayList<>();
        try {
            // 等待所有异步任务完成，设置超时时间为 50ms
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get(50, TimeUnit.MILLISECONDS);

            for (CompletableFuture<PaymentResult> future : futures) {
                try {
                    PaymentResult result = future.get();
                    resultList.add(result);
                } catch (InterruptedException | ExecutionException e) {
                    // 异常处理，可以根据实际情况进行日志记录或其他操作
                    e.printStackTrace();
                }
            }
        } catch (TimeoutException e) {
            // 超时处理，将已完成的结果添加到结果列表
            for (CompletableFuture<PaymentResult> future : futures) {
                PaymentResult result = future.getNow(null);
                if (result != null) {
                    resultList.add(result);
                }
            }
            System.out.println("部分任务超时，仅返回已完成的结果");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

        return resultList;
    }


    public static void main(String[] args) {

        List<PaymentResult> paymentResults = getUserPaymentMethods();
        for (PaymentResult result : paymentResults) {
            System.out.println("支付方式: " + result.getMethod() + ", 可用性: " + result.getAvailability());
        }
    }
}