和外部机构API交互如何防止外部机构服务不可用拖垮调用服务

🕗 发布于 2024-10-13 10:04 交互 microsoft 服务器

引言

在现代的分布式系统和微服务架构中，服务之间的通信往往通过API进行，尤其是在与外部机构或第三方服务进行交互时，更需要通过API实现功能的集成。然而，由于外部服务的可控性较差，其服务的不可用性（如响应缓慢或服务宕机）可能会影响我们自己的服务调用，甚至会导致系统整体性能下降或崩溃。

为了避免外部机构的API不可用时拖垮我们的系统，我们需要设计合理的防护机制，包括熔断机制、限流机制、超时设置、重试机制、服务降级等手段。本文将深入探讨如何通过这些技术，构建一个高可用、健壮的服务交互系统，并结合代码示例详细讲解实现方案。

第一部分：外部API不可用的常见问题分析

1.1 API调用的挑战

当我们与外部服务或API进行交互时，可能会遇到如下问题：

网络问题：网络不稳定可能会导致请求延迟、超时等问题。
外部服务不可用：外部服务可能因为内部故障或流量过大而不可用，导致服务不可用。
响应时间过长：外部服务响应过慢会导致我们调用的系统阻塞，进而拖慢整个服务的响应时间。
服务负载过高：如果外部服务请求过多，而服务没有进行限流，会使得系统无法处理并导致崩溃。
不一致的错误处理：外部服务返回的错误可能并没有标准化处理，增加了对接的复杂性。

1.2 风险评估

与外部API的交互问题如果不加以控制，可能引发以下严重后果：

系统响应延迟：外部服务响应过慢，导致调用服务的响应时间也被拉长，进而影响用户体验。
系统崩溃：如果外部服务不可用，而我们的系统没有及时进行降级处理，可能会导致整个系统崩溃。
资源耗尽：不断重试或等待外部服务可能会导致系统资源耗尽，如线程、连接池等。

第二部分：设计原则与防护机制

为了避免外部服务不可用时拖垮我们的调用服务，我们需要建立多种防护机制。这些机制应遵循以下设计原则：

故障隔离：确保外部服务故障时，影响范围被隔离，不影响其他功能或模块。
容错机制：确保在外部服务失败时，系统能够有降级处理或重试机制，不至于完全不可用。
快速失败：在外部服务出现问题时，尽量快速失败，避免长时间阻塞调用线程。

2.1 超时设置

超时是避免外部服务响应过慢影响我们系统的基础措施。通过设置合理的超时，可以避免外部服务长时间不响应时导致调用服务的线程长时间等待，进而拖慢系统性能。

2.1.1 实现超时的示例

我们可以在进行HTTP请求时通过设置超时来控制请求的最大等待时间。

Java代码示例（使用HttpURLConnection）

import java.net.HttpURLConnection;
import java.net.URL;

public class ApiService {

    public String callExternalApi(String apiUrl) throws Exception {
        URL url = new URL(apiUrl);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        // 设置连接超时和读取超时
        connection.setConnectTimeout(5000); // 5秒连接超时
        connection.setReadTimeout(5000); // 5秒读取超时

        if (connection.getResponseCode() == 200) {
            // 处理响应
            return "Success";
        } else {
            return "Error";
        }
    }
}

2.1.2 设置超时的意义

避免线程阻塞：在等待外部服务响应时，设置超时可以避免线程长时间阻塞，提高系统资源利用率。
快速失败：当外部服务未能在规定时间内响应时，系统能够快速返回失败结果，避免影响整体服务质量。

2.2 熔断机制

熔断机制是微服务架构中非常重要的容错机制。熔断器的核心思想是：当外部服务连续多次失败时，暂时停止对其的调用，避免系统资源继续浪费。

熔断器类似电路中的保险丝，它能防止系统因持续的错误调用而陷入崩溃状态。当某个服务出现大量调用失败时，熔断器会进入打开状态，短时间内拒绝所有请求，等到外部服务恢复正常时，再关闭熔断器，恢复调用。

2.2.1 熔断机制的核心流程

监控外部服务的调用情况。
设定失败阈值：当调用外部服务的失败率超过阈值时，熔断器开启。
熔断器开启后，快速失败：不再向外部服务发起调用，直接返回失败结果。
熔断器关闭：经过一段时间后，检测外部服务恢复正常，再继续调用。

2.2.2 实现熔断器的示例

我们可以使用Hystrix或者Resilience4j等库来实现熔断器机制。以下是使用Resilience4j实现熔断的代码示例。

Java代码示例（使用Resilience4j）

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;

import java.time.Duration;

public class ApiServiceWithCircuitBreaker {

    private CircuitBreaker circuitBreaker;

    public ApiServiceWithCircuitBreaker() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50) // 失败率达到50%触发熔断
            .waitDurationInOpenState(Duration.ofSeconds(5)) // 熔断器打开状态保持5秒
            .slidingWindowSize(10) // 统计窗口大小
            .build();

        circuitBreaker = CircuitBreakerRegistry.of(config).circuitBreaker("externalService");
    }

    public String callExternalApi(String apiUrl) {
        return CircuitBreaker.decorateSupplier(circuitBreaker, () -> {
            // 调用外部API逻辑
            return "Success";
        }).get();
    }
}

2.2.3 熔断机制的优势

保护系统资源：当外部服务长时间不可用时，避免系统不断调用导致资源浪费。
快速失败，提升系统响应速度：当服务不可用时，熔断器能够及时拒绝请求，避免影响系统性能。
自动恢复：当外部服务恢复后，熔断器能够自动关闭，恢复正常调用。

2.3 限流机制

在高并发场景下，外部服务可能无法处理大量的并发请求。为了防止过载，我们可以在系统内部对外部API的调用进行限流，确保外部服务不会被拖垮。

常见的限流算法有：

令牌桶算法：通过发放令牌的方式控制请求的速率，只有拿到令牌的请求才能进行API调用。
漏桶算法：通过将请求排队进入漏桶中，按照固定的速率处理。

2.3.1 令牌桶限流的实现

以下是基于Guava库的令牌桶限流示例：

Java代码示例（使用Guava限流）

import com.google.common.util.concurrent.RateLimiter;

public class ApiServiceWithRateLimiter {

    // 每秒钟允许5个请求
    private RateLimiter rateLimiter = RateLimiter.create(5.0);

    public String callExternalApi(String apiUrl) {
        // 请求前进行限流
        if (rateLimiter.tryAcquire()) {
            // 调用外部API
            return "Success";
        } else {
            return "Rate limit exceeded";
        }
    }
}

2.3.2 限流机制的优势

避免外部服务过载：通过限流，能够确保在高并发场景下，外部服务不会因为请求过多而崩溃。
系统自我保护：在外部服务无法响应时，通过限流机制可以减少对外部服务的依赖，提升系统的稳定性。

2.4 重试机制

当外部API偶尔出现短暂的故障时，重试机制能够帮助系统

在一定范围内恢复。合理的重试策略能够提高系统的健壮性，减少瞬时故障的影响。

2.4.1 重试策略设计

重试机制需要慎重设计，以避免导致更多的问题：

重试次数：避免无限重试，一般限制在3次左右。
重试间隔：每次重试的间隔时间可以逐渐增加（指数退避策略），避免给外部服务造成更大的压力。
重试条件：只对某些特定的错误类型进行重试，如网络超时或502错误，而对于业务逻辑错误不应重试。

2.4.2 实现重试机制的示例

Java代码示例（使用Resilience4j实现重试）

import io.github.resilience4j.retry.Retry;
import io.github.resilience4j.retry.RetryConfig;
import io.github.resilience4j.retry.RetryRegistry;

import java.time.Duration;

public class ApiServiceWithRetry {

    private Retry retry;

    public ApiServiceWithRetry() {
        RetryConfig config = RetryConfig.custom()
            .maxAttempts(3) // 最大重试次数3次
            .waitDuration(Duration.ofSeconds(2)) // 每次重试间隔2秒
            .build();

        retry = RetryRegistry.of(config).retry("externalService");
    }

    public String callExternalApi(String apiUrl) {
        return Retry.decorateSupplier(retry, () -> {
            // 调用外部API
            return "Success";
        }).get();
    }
}

2.4.3 重试机制的优势

提升系统健壮性：短暂的网络故障或服务不可用可以通过重试机制自动恢复。
减少人为干预：当外部服务恢复正常时，重试机制可以自动重发请求，无需人为干预。

2.5 服务降级

当外部服务长期不可用或不稳定时，服务降级可以帮助系统减少对外部服务的依赖，保证核心功能的可用性。在服务降级中，系统会提供一个默认的响应或简化的功能，以应对外部服务故障带来的影响。

2.5.1 服务降级的场景

外部服务不可用：当外部服务宕机或长时间无响应时，调用本地的降级策略。
请求超时：当请求超时时，提供一个默认的响应结果，而不是直接失败。

2.5.2 实现服务降级的示例

我们可以使用Hystrix或Resilience4j来实现服务降级。以下是一个使用Resilience4j实现服务降级的示例：

Java代码示例（服务降级）

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;

import java.util.function.Supplier;

public class ApiServiceWithFallback {

    private CircuitBreaker circuitBreaker;

    public ApiServiceWithFallback() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .build();

        circuitBreaker = CircuitBreakerRegistry.of(config).circuitBreaker("externalService");
    }

    public String callExternalApi(String apiUrl) {
        Supplier<String> apiCall = CircuitBreaker.decorateSupplier(circuitBreaker, () -> {
            // 调用外部API
            return "Success";
        });

        return apiCall.getOrDefault("Fallback response");
    }
}

2.5.3 服务降级的优势

保持系统可用性：即使外部服务不可用，服务降级能够保证系统的核心功能正常运行。
提升用户体验：用户不会因为外部服务不可用而无法继续使用系统。

第三部分：图文结合的架构设计

3.1 系统整体架构图

为了更好地说明上述各项机制的结合应用，下面是一个完整的系统架构图，展示了在高并发场景下如何保护系统免受外部服务故障的影响。

+-----------------------------------------------+
|                                               |
|            负载均衡器/网关                     |
|                                               |
+-----------------------------------------------+
                |                       |
                v                       v
      +-------------------+   +-------------------+
      |   调用服务A（限流）  |   |   调用服务B（限流）  |
      +-------------------+   +-------------------+
                |                       |
                v                       v
+--------------------------------------------------------+
|  超时设置  |  熔断器  |  重试机制  |  服务降级 |        |
|--------------------------------------------------------|
|    外部服务1    |    外部服务2    |    外部服务3        |
+--------------------------------------------------------+

第四部分：实战示例——外部支付接口的防护设计

以支付系统为例，我们可以假设系统需要调用第三方支付接口。在高并发下，支付接口可能会出现不可用或超时的情况，因此我们需要为其设置完善的防护机制。

4.1 支付接口调用流程

订单生成：用户发起订单后，系统生成支付订单。
调用支付接口：系统调用外部支付服务接口。
超时与重试：若支付接口响应超时，进行重试，重试次数限制为3次。
熔断与降级：若支付接口不可用或响应错误次数过多，系统进入熔断状态，调用本地降级处理，提示用户稍后再试。

4.2 支付接口调用代码实现

public class PaymentService {

    private CircuitBreaker circuitBreaker;
    private Retry retry;
    private RateLimiter rateLimiter;

    public PaymentService() {
        // 初始化熔断器
        CircuitBreakerConfig breakerConfig = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .waitDurationInOpenState(Duration.ofSeconds(10))
            .build();
        circuitBreaker = CircuitBreakerRegistry.of(breakerConfig).circuitBreaker("paymentService");

        // 初始化重试机制
        RetryConfig retryConfig = RetryConfig.custom()
            .maxAttempts(3)
            .waitDuration(Duration.ofSeconds(2))
            .build();
        retry = RetryRegistry.of(retryConfig).retry("paymentService");

        // 初始化限流器
        rateLimiter = RateLimiter.create(5.0); // 每秒5个请求
    }

    public String processPayment(String paymentRequest) {
        if (rateLimiter.tryAcquire()) {
            return Retry.decorateSupplier(retry, CircuitBreaker.decorateSupplier(circuitBreaker, () -> {
                // 调用外部支付API
                return callPaymentApi(paymentRequest);
            })).get();
        } else {
            return "Rate limit exceeded. Please try again later.";
        }
    }

    private String callPaymentApi(String paymentRequest) {
        // 模拟外部支付API调用
        return "Payment Success";
    }
}

第五部分：总结与最佳实践

5.1 关键技术点回顾

超时设置：快速失败，避免长时间等待外部服务响应。
熔断机制：通过熔断器保护系统资源，防止外部服务故障时的连锁反应。
限流机制：防止高并发场景下对外部服务的过载调用。
重试机制：在短暂网络故障或偶发错误时，自动进行请求重试，提高系统健壮性。
服务降级：当外部服务不可用时，提供替代方案或默认响应，保持系统的核心功能可用。

5.2 最佳实践

分层防护：将限流、熔断、重试等机制分层应用，从网络层到应用层，确保每一层都能对外部服务故障进行处理。
合理配置：根据业务需求合理设置超时时间、熔断阈值、重试次数等参数，避免设置过度或不足。
监控与预警：通过监控系统对外部服务的调用状态进行监控，及时发现问题，并设置预警机制，防止问题扩大。

通过本文的详细讲解与代码示例，希望开发者能够深入理解与外部机构API交互时的防护设计原则与实现方法，构建出更具韧性、更加稳定的系统。

原文地址：https://blog.csdn.net/lssffy/article/details/142618890

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：“八股文”面试：助力、阻力还是空谈？
下一篇：胤娲科技：AI绘梦师——一键复刻梵高《星空》

开发指南072-图片热点
/处理跳转： area.getAttribute('href');平台支持使用图像导航界面，例如展示如下一张图，用户点击对应位置触发对应动作。热点数据通过后台接口获取（注意处理权限，没有权限的热点不生
阅读更多2024-10-13
使用机器学习边缘设备的快速目标检测
这项机器学习研究探讨了一种低成本的边缘设备，该设备与具有计算机视觉功能的嵌入式系统集成，以提高目标检测和分类的推理时间和精度。研究的主要目标是减少推理时间并降低功耗，以支持一个竞技型类人机器人的嵌入式
阅读更多2024-10-13
【Windows】【DevOps】Windows Server 2022 安装ansible，基于powershell实现远程自动化运维部署入门到放弃！
文件URL：https://www.python.org/ftp/python/3.13.0/python-3.13.0-amd64.exe。直接拿linux主机测试ansible连接windows
阅读更多2024-10-13
C# 中循环的应用说明
一循环的概念说明二、循环类型三、循环控制语句四、无限循环
阅读更多2024-10-13
Linux `vmstat` 命令详解
vmstat（Virtual Memory Statistics）是 Linux 系统中的一个监控工具，用于报告系统的虚拟内存、进程、CPU 活动等信息。它能帮助用户了解系统的整体性能状况，尤其是内存
阅读更多2024-10-13
Linux下多任务编程（网络编程2）
本文介绍解决accpet和recv相互阻塞的问题，可以用多线程并发外也可以用epoll I/O多路复用的方式解决。
阅读更多2024-10-13
[单master节点k8s部署]37.微服务（一)springCloud 微服务
微服务架构的一个重要特点是，它与开发中使用的具体或无关。每个微服务都可以使用最适合其功能需求的语言或技术来实现。例如，一个微服务可以用Java编写，另一个微服务可以用Python、Go、Node.js
阅读更多2024-10-13
Zynq(3)使用外设MIO/EMIO
使用MIO/EMIO实现流水灯，着重介绍Zynq IP核的配置，解读vitis中的c语言程序，介绍MIO与EMIO的区别。
阅读更多2024-10-13
笔试算法总结
思路很简单，但是当时做题提交的时候，通过率总是18%。不知道为啥，后面我改成了Long类型，然后就通过了全部用例。（易错1：第一次提交没考虑0的情况）使用 StringBuilder 模拟栈的行为，通
阅读更多2024-10-13
快速学习一个算法，Transformer模型架构
它的主要思想是在同一时间通过多个独立的注意力头（Attention Head）来关注序列中不同部分的信息，然后将这些信息综合起来，生成更丰富的表示。自注意力机制的目的是对输入序列中的每个元素计算一个输
阅读更多2024-10-13