括展actuator health check

方式一：

为了定制 Spring Boot 的 Actuator 来实现你所描述的功能，即在调用自己的 /actuator/health 时，服务端能够自动调用 4 个下游 API 的 /actuator/health，并将其检查结果与自己的健康状态一起返回，可以按照以下步骤进行操作：

实现思路：

  1. 创建自定义的 HealthIndicator：Spring Boot 提供了 HealthIndicator 接口，允许你自定义健康检查逻辑。我们可以通过实现该接口来定制对外部 API 的健康检查。

  2. 集成多个 API 的健康状态：在自定义的 HealthIndicator 实现中，我们可以发起 HTTP 请求调用 4 个下游 API 的健康检查接口，获取它们的健康状态。

  3. 将各 API 的状态与自身服务的健康状态合并：通过 Health.Builder 将自身服务的健康状态和 4 个下游 API 的健康检查结果合并，返回给调用方。

详细实现步骤：

1. 引入必要的依赖

确保你的 pom.xml 中包含以下依赖项，特别是用于发起 HTTP 请求的 spring-boot-starter-web 和 spring-boot-starter-actuator：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2. 创建自定义的 HealthIndicator

首先，需要实现 HealthIndicator 接口，用于检查下游 API 的健康状态。可以使用 Spring 的 RestTemplate 来发起 HTTP 请求。

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

@Component
public class DownstreamApiHealthIndicator implements HealthIndicator {

    private final RestTemplate restTemplate;

    public DownstreamApiHealthIndicator(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Override
    public Health health() {
        // 假设下游 API 的健康检查地址
        String[] urls = {
            "http://api1/actuator/health",
            "http://api2/actuator/health",
            "http://api3/actuator/health",
            "http://api4/actuator/health"
        };

        // 构建健康状态
        Health.Builder builder = Health.up();

        for (String url : urls) {
            try {
                // 发起 GET 请求获取健康状态
                Health response = restTemplate.getForObject(url, Health.class);
                if (response != null && response.getStatus().equals(Health.up().getStatus())) {
                    builder.withDetail(url, "UP");
                } else {
                    builder.withDetail(url, "DOWN");
                }
            } catch (Exception e) {
                // 如果请求失败，认为该服务不可达
                builder.withDetail(url, "DOWN").down();
            }
        }

        return builder.build();
    }
}

在这里，我们实现了 DownstreamApiHealthIndicator，用于对 4 个下游 API 进行健康检查，并将结果整合到健康状态中。

3. 创建 RestTemplate Bean

为了发起 HTTP 请求，需要创建一个 RestTemplate Bean。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

4. 将自定义 HealthIndicator 与 Spring Boot 的 /actuator/health 结合

Spring Boot 会自动发现实现了 HealthIndicator 接口的 Bean，并将其集成到 /actuator/health 的响应中。因此，你只需要将自定义的 DownstreamApiHealthIndicator 实现放入 Spring 的上下文中即可。

5. 调整返回健康信息的格式（可选）

如果你想控制健康信息的返回格式，可以通过修改 application.properties 中的配置来实现。比如，可以通过下面的配置展示详细的健康状态信息：

management.endpoint.health.show-details=always
management.endpoint.health.show-components=always

6. 运行结果

当你访问 /actuator/health 时，将会得到如下类似的响应，包含自身服务的健康状态以及 4 个下游 API 的健康状态：

{
    "status": "UP",
    "details": {
        "http://api1/actuator/health": "UP",
        "http://api2/actuator/health": "UP",
        "http://api3/actuator/health": "DOWN",
        "http://api4/actuator/health": "UP"
    }
}

这里，status 表示你的服务的整体健康状态，details 部分包含了各下游 API 的健康检查结果。

7. 其他可选配置

如果下游 API 的健康检查比较耗时，或者你想避免同步调用带来的阻塞，可以考虑使用异步调用来并发检查下游服务的状态。你可以使用 CompletableFuture 或者其他异步处理方式来并发发起 HTTP 请求，从而减少整体健康检查的响应时间。

使用 CompletableFuture 实现异步健康检查

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

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

@Component
public class DownstreamApiHealthIndicator implements HealthIndicator {

    private final RestTemplate restTemplate;

    public DownstreamApiHealthIndicator(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Override
    public Health health() {
        String[] urls = {
            "http://api1/actuator/health",
            "http://api2/actuator/health",
            "http://api3/actuator/health",
            "http://api4/actuator/health"
        };

        Health.Builder builder = Health.up();

        // 异步检查下游 API 的健康状态
        CompletableFuture[] futures = new CompletableFuture[urls.length];
        for (int i = 0; i < urls.length; i++) {
            String url = urls[i];
            futures[i] = CompletableFuture.runAsync(() -> {
                try {
                    Health response = restTemplate.getForObject(url, Health.class);
                    if (response != null && response.getStatus().equals(Health.up().getStatus())) {
                        builder.withDetail(url, "UP");
                    } else {
                        builder.withDetail(url, "DOWN");
                    }
                } catch (Exception e) {
                    builder.withDetail(url, "DOWN").down();
                }
            });
        }

        // 等待所有任务完成
        CompletableFuture.allOf(futures).join();

        return builder.build();
    }
}

通过这种方式，你可以大大减少等待时间，从而提高整体的响应效率。

总结

  1. 通过实现自定义的 HealthIndicator，你可以将下游 API 的健康检查集成到自身服务的健康检查中。
  2. 可以使用 RestTemplate 发起同步或异步的 HTTP 请求，获取下游 API 的健康状态。
  3. 利用 Spring Boot 的自动发现机制，你的自定义 HealthIndicator 会被自动整合到 /actuator/health 的输出中。

方式二：

在 Spring Boot 中，你可以使用 组合多个 HealthIndicator 来执行多个健康检查，并将它们的结果组合起来。Spring Boot 提供了一种方式来组合多个健康检查，叫做 CompositeHealthContributor。你可以通过实现多个 HealthIndicator 并将它们组合到一个 CompositeHealthContributor 中。

这里是详细步骤和示例代码来展示如何组合多个健康检查：

实现步骤

  1. 实现多个 HealthIndicator：首先，你需要为每个要检查的下游 API 或其他资源实现各自的 HealthIndicator。

  2. 组合多个 HealthIndicator：通过实现 CompositeHealthContributor，你可以将多个 HealthIndicator 组合到一起。

  3. 整合到 Spring Boot Actuator：Spring Boot 会自动发现 HealthIndicator 和 CompositeHealthContributor，并将它们集成到 /actuator/health。

示例代码

1. 实现多个 HealthIndicator

这里我们创建两个简单的健康检查类，分别检查两个下游 API 的健康状态。

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

@Component
public class DownstreamApi1HealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        // 这里是对第一个下游 API 的健康检查逻辑
        // 假设调用 API 成功就返回 UP，否则返回 DOWN
        boolean api1IsUp = checkApi1Health();
        if (api1IsUp) {
            return Health.up().withDetail("API 1", "Available").build();
        } else {
            return Health.down().withDetail("API 1", "Unavailable").build();
        }
    }

    private boolean checkApi1Health() {
        // 模拟健康检查的逻辑，可以是实际的 HTTP 请求
        return true; // 假设 API 1 是可用的
    }
}

@Component
public class DownstreamApi2HealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        // 这里是对第二个下游 API 的健康检查逻辑
        boolean api2IsUp = checkApi2Health();
        if (api2IsUp) {
            return Health.up().withDetail("API 2", "Available").build();
        } else {
            return Health.down().withDetail("API 2", "Unavailable").build();
        }
    }

    private boolean checkApi2Health() {
        // 模拟健康检查的逻辑
        return false; // 假设 API 2 是不可用的
    }
}

2. 组合多个 HealthIndicator（使用 CompositeHealthContributor）

接下来，我们需要将这两个健康检查类组合在一起。CompositeHealthContributor 可以帮助我们组合多个 HealthIndicator。

import org.springframework.boot.actuate.health.CompositeHealthContributor;
import org.springframework.boot.actuate.health.HealthContributor;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;

@Configuration
public class CompositeHealthConfig {

    @Bean
    public HealthContributor combinedHealthIndicator(
            DownstreamApi1HealthIndicator api1HealthIndicator, 
            DownstreamApi2HealthIndicator api2HealthIndicator) {

        // 将多个 HealthIndicator 放入 Map 中
        Map<String, HealthIndicator> indicators = new LinkedHashMap<>();
        indicators.put("api1", api1HealthIndicator);
        indicators.put("api2", api2HealthIndicator);

        // 返回 CompositeHealthContributor 来组合它们
        return CompositeHealthContributor.fromMap(indicators);
    }
}
  • CompositeHealthContributor.fromMap() 方法允许你将多个健康检查类组合在一起，并将它们以 Map 的形式注册。Map 的键（例如 "api1" 和 "api2"）会出现在 /actuator/health 的输出中。

3. 访问 /actuator/health

在启动服务后，访问 /actuator/health，你将看到组合后的健康状态，类似如下的输出：

{
    "status": "DOWN",
    "components": {
        "api1": {
            "status": "UP",
            "details": {
                "API 1": "Available"
            }
        },
        "api2": {
            "status": "DOWN",
            "details": {
                "API 2": "Unavailable"
            }
        }
    }
}

  • status 显示的是组合后的状态。因为其中一个下游 API (api2) 是 DOWN，所以整体的状态是 DOWN。

  • components 中列出了各个健康检查类的具体状态。

总结

  • 你可以通过 CompositeHealthContributor 组合多个健康检查类（HealthIndicator），从而在 /actuator/health 中展示多个下游 API 或其他资源的健康状况。
  • Spring Boot 会自动合并所有 HealthIndicator 和 CompositeHealthContributor，并将结果整合到健康检查的输出中。
posted @   gongchengship  阅读(72)  评论(0)  编辑  收藏  举报
相关博文：
· 在springboot 中使用Apache HttpClient 4的详细示例
· 在springboot 中使用Apache HttpClient 5的详细示例
· Spring Boot Actuator:健康检查、审计、统计和监控
· Spring Boot Actuator-Java快速入门教程
· Spring Boot & Actuator 监控
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
点击右上角即可分享
微信分享提示