Spring Boot 健康检查配置与自定义策略

Spring Boot 健康检查：让你的应用像医生一样自我诊断

各位看官，欢迎来到本期“Spring Boot 健康检查：让你的应用像医生一样自我诊断”的专栏。今天，咱们不聊虚的，就来聊聊如何让你的 Spring Boot 应用拥有“未卜先知”的能力，能够在身体不适时，主动发出求救信号，而不是等到用户反馈“哎呀，这个网站怎么打不开了！”才手忙脚乱地去排查。

想象一下，你的应用就像一个人，辛辛苦苦地在服务器上跑着，处理着各种请求。但时间久了，难免会遇到一些“小毛病”，比如数据库连接超时、磁盘空间不足、外部服务响应缓慢等等。如果这些问题得不到及时处理，就会像滚雪球一样，越滚越大，最终导致整个应用崩溃。

那么，如何才能让你的应用像一个经验丰富的医生一样，能够定期检查自己的“身体状况”，及时发现潜在的问题呢？答案就是 Spring Boot 的健康检查功能。

Spring Boot Actuator：自带的“体检中心”

Spring Boot Actuator 模块就像一个自带的“体检中心”，它提供了一系列开箱即用的健康检查端点，可以帮助你监控应用的各种指标。要使用它，只需要在你的 pom.xml 文件中添加以下依赖：

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

添加完依赖后，重启你的应用。默认情况下，Actuator 的端点是关闭的，你需要手动开启。可以在 application.properties 或 application.yml 文件中添加以下配置：

management.endpoints.web.exposure.include=*

或者，如果你只想暴露 health 端点，可以这样配置：

management.endpoints.web.exposure.include=health

这样，你就可以通过访问 http://localhost:8080/actuator/health (假设你的应用运行在 8080 端口) 来查看应用的健康状况了。

你会看到类似以下的 JSON 响应：

{
  "status": "UP"
}

status 字段表示应用的总体健康状况，UP 表示一切正常。

但仅仅是这样，显然是不够的。你肯定想知道，除了应用“活着”之外，还有哪些指标需要关注？比如，数据库连接是否正常？磁盘空间是否充足？

深入了解 health 端点：更详细的“体检报告”

health 端点不仅仅返回一个简单的 UP 或 DOWN 状态，它还可以提供更详细的健康信息。要开启更详细的信息，需要在配置中添加 management.endpoint.health.show-details=always。

management.endpoint.health.show-details=always
management.endpoints.web.exposure.include=health

现在，再次访问 http://localhost:8080/actuator/health，你会看到类似以下的 JSON 响应：

{
  "status": "UP",
  "components": {
    "db": {
      "status": "UP",
      "details": {
        "database": "H2",
        "hello": 1
      }
    },
    "diskSpace": {
      "status": "UP",
      "details": {
        "total": 499963191296,
        "free": 490325938176,
        "threshold": 10485760,
        "exists": true
      }
    },
    "ping": {
      "status": "UP"
    }
  }
}

可以看到，components 字段包含了各种组件的健康信息，比如 db (数据库), diskSpace (磁盘空间), ping 等等。每个组件都有一个 status 字段，表示该组件的健康状况，以及一个 details 字段，包含该组件的详细信息。

• db: 检查数据库连接是否正常。database 字段表示数据库类型，hello 字段表示一个简单的查询是否成功（默认情况下，Actuator 会执行一个简单的 SELECT 1 查询）。
• diskSpace: 检查磁盘空间是否充足。total 字段表示总磁盘空间，free 字段表示可用磁盘空间，threshold 字段表示警告阈值 (当可用磁盘空间低于该值时，状态会变为 DOWN)，exists 字段表示磁盘是否存在。
• ping: 一个简单的健康检查，通常用于测试应用是否能够响应请求。

如果任何一个组件的状态为 DOWN，那么整个应用的总体状态也会变为 DOWN。

自定义健康检查：打造专属的“体检套餐”

虽然 Actuator 提供了许多开箱即用的健康检查，但在实际应用中，你可能需要根据自己的业务需求，自定义一些健康检查。比如，检查外部服务的可用性，或者检查消息队列是否正常工作。

Spring Boot 提供了非常灵活的方式来定义自定义健康检查。你需要做的就是创建一个实现了 HealthIndicator 接口的类，并将其注册为 Spring Bean。

让我们来看一个简单的例子，假设你需要检查一个外部服务的可用性。你可以创建一个名为 ExternalServiceHealthIndicator 的类：

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
import java.net.URL;
import java.net.HttpURLConnection;

@Component("externalService") // 指定组件的名称，以便在 health 端点中显示
public class ExternalServiceHealthIndicator implements HealthIndicator {

    private static final String EXTERNAL_SERVICE_URL = "https://www.example.com"; // 替换为你的外部服务 URL

    @Override
    public Health health() {
        try {
            URL url = new URL(EXTERNAL_SERVICE_URL);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            int responseCode = connection.getResponseCode();

            if (responseCode >= 200 && responseCode < 300) {
                return Health.up().withDetail("message", "External service is available").build();
            } else {
                return Health.down().withDetail("error", "External service returned status code: " + responseCode).build();
            }
        } catch (Exception e) {
            return Health.down(e).withDetail("error", "Exception occurred: " + e.getMessage()).build();
        }
    }
}

在这个例子中，ExternalServiceHealthIndicator 类实现了 HealthIndicator 接口，并重写了 health() 方法。health() 方法尝试连接到外部服务，并根据响应状态码来判断服务的可用性。

• 如果连接成功且响应状态码在 200-299 之间，则返回 Health.up()，表示服务可用，并添加一个 message 字段，包含一些附加信息。
• 如果连接失败或响应状态码不在 200-299 之间，则返回 Health.down()，表示服务不可用，并添加一个 error 字段，包含错误信息。
• 如果发生异常，则返回 Health.down(e)，表示服务不可用，并将异常信息添加到 details 中。

@Component("externalService") 注解将该类注册为一个 Spring Bean，并指定了组件的名称为 externalService。这样，在 health 端点中，你就可以看到一个名为 externalService 的组件，包含该外部服务的健康信息。

现在，再次访问 http://localhost:8080/actuator/health，你会看到类似以下的 JSON 响应：

{
  "status": "UP",
  "components": {
    "db": {
      "status": "UP",
      "details": {
        "database": "H2",
        "hello": 1
      }
    },
    "diskSpace": {
      "status": "UP",
      "details": {
        "total": 499963191296,
        "free": 490325938176,
        "threshold": 10485760,
        "exists": true
      }
    },
    "externalService": {
      "status": "UP",
      "details": {
        "message": "External service is available"
      }
    },
    "ping": {
      "status": "UP"
    }
  }
}

可以看到，components 字段中多了一个 externalService 组件，它包含了外部服务的健康信息。

自定义 HealthContributor：批量注册健康检查

如果你的应用需要大量的自定义健康检查，手动创建和注册 HealthIndicator 可能会变得非常繁琐。Spring Boot 提供了 HealthContributor 接口，可以让你批量注册健康检查。

要使用 HealthContributor，你需要创建一个实现了 HealthContributor 接口的类，并将其注册为 Spring Bean。HealthContributor 接口只有一个方法 getHealthIndicators()，该方法返回一个 Map<String, HealthIndicator>，其中 key 是组件的名称，value 是对应的 HealthIndicator。

让我们来看一个例子，假设你需要同时检查多个外部服务的可用性。你可以创建一个名为 ExternalServicesHealthContributor 的类：

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

import java.util.HashMap;
import java.util.Map;

@Component("externalServices") // 指定组件的名称，以便在 health 端点中显示
public class ExternalServicesHealthContributor implements HealthContributor {

    private final Map<String, HealthIndicator> healthIndicators = new HashMap<>();

    public ExternalServicesHealthContributor(
            ExternalServiceHealthIndicator service1,
            AnotherExternalServiceHealthIndicator service2
    ) {
        healthIndicators.put("service1", service1);
        healthIndicators.put("service2", service2);
    }

    @Override
    public Map<String, HealthIndicator> getHealthIndicators() {
        return healthIndicators;
    }
}

// 模拟第二个外部服务健康检查
@Component
class AnotherExternalServiceHealthIndicator implements HealthIndicator {

    @Override
    public org.springframework.boot.actuate.health.Health health() {
        // 模拟检查逻辑
        boolean isHealthy = true; // 假设服务是健康的
        if (isHealthy) {
            return org.springframework.boot.actuate.health.Health.up().withDetail("message", "Another external service is available").build();
        } else {
            return org.springframework.boot.actuate.health.Health.down().withDetail("error", "Another external service is unavailable").build();
        }
    }
}

在这个例子中，ExternalServicesHealthContributor 类实现了 HealthContributor 接口，并在构造函数中注入了多个 HealthIndicator 实例 (这里假设你有 ExternalServiceHealthIndicator 和 AnotherExternalServiceHealthIndicator 两个自定义的健康检查)。getHealthIndicators() 方法返回一个包含所有 HealthIndicator 的 Map。

@Component("externalServices") 注解将该类注册为一个 Spring Bean，并指定了组件的名称为 externalServices。这样，在 health 端点中，你就可以看到一个名为 externalServices 的组件，它包含了多个外部服务的健康信息。

现在，再次访问 http://localhost:8080/actuator/health，你会看到类似以下的 JSON 响应：

{
  "status": "UP",
  "components": {
    "db": {
      "status": "UP",
      "details": {
        "database": "H2",
        "hello": 1
      }
    },
    "diskSpace": {
      "status": "UP",
      "details": {
        "total": 499963191296,
        "free": 490325938176,
        "threshold": 10485760,
        "exists": true
      }
    },
    "externalServices": {
      "status": "UP",
      "components": {
        "service1": {
          "status": "UP",
          "details": {
            "message": "External service is available"
          }
        },
        "service2": {
          "status": "UP",
          "details": {
            "message": "Another external service is available"
          }
        }
      }
    },
    "ping": {
      "status": "UP"
    }
  }
}

可以看到，components 字段中多了一个 externalServices 组件，它包含了 service1 和 service2 两个子组件，分别对应两个外部服务的健康信息。

健康状态聚合策略：更智能的“病情诊断”

默认情况下，Spring Boot 使用 StatusAggregator 接口的默认实现来聚合所有组件的健康状态。这意味着，只要有一个组件的状态为 DOWN，整个应用的总体状态就会变为 DOWN。

但在某些情况下，你可能希望使用不同的聚合策略。比如，你可能希望忽略某些组件的健康状态，或者根据不同的组件状态来设置不同的总体状态。

Spring Boot 允许你自定义聚合策略。你需要做的就是创建一个实现了 StatusAggregator 接口的类，并将其注册为 Spring Bean。

让我们来看一个例子，假设你希望忽略 ping 组件的健康状态，只有当 db 或 diskSpace 组件的状态为 DOWN 时，整个应用的总体状态才变为 DOWN。你可以创建一个名为 CustomStatusAggregator 的类：

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.Status;
import org.springframework.boot.actuate.health.StatusAggregator;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class CustomStatusAggregator implements StatusAggregator {

    @Override
    public Status getAggregateStatus(List<Status> statuses) {
        // 如果 db 或 diskSpace 组件的状态为 DOWN，则返回 DOWN
        if (statuses.stream().anyMatch(status -> status.equals(Status.DOWN))) {
            return Status.DOWN;
        }

        // 否则，返回 UP
        return Status.UP;
    }
}

在这个例子中，CustomStatusAggregator 类实现了 StatusAggregator 接口，并重写了 getAggregateStatus() 方法。getAggregateStatus() 方法接收一个包含所有组件状态的 List，并根据自定义的逻辑来判断总体状态。

在这个例子中，我们简单地判断是否存在 DOWN 状态的组件。更复杂的场景下，你可以根据组件的名称来判断是否需要忽略该组件的状态，或者根据不同的组件状态来设置不同的总体状态。

现在，Spring Boot 将会使用你自定义的 CustomStatusAggregator 来聚合所有组件的健康状态。

总结：让健康检查成为你的应用守护神

Spring Boot 的健康检查功能是一个非常强大的工具，可以帮助你监控应用的各种指标，及时发现潜在的问题，并采取相应的措施。通过自定义健康检查和聚合策略，你可以根据自己的业务需求，打造专属的“体检套餐”，让你的应用拥有更强大的自我诊断能力。

记住，健康检查不仅仅是一个技术细节，更是一种责任和担当。只有当你真正关注应用的健康状况，才能为用户提供更稳定、更可靠的服务。

希望本文能够帮助你更好地理解和使用 Spring Boot 的健康检查功能，让你的应用像一个健康的运动员一样，充满活力，勇往直前！