spring boot的健康检查HealthIndicators实战

import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
@Component
public class MyHealth implements HealthIndicator {
@Override
public Health health() {
int errorCode = check(); // perform some specific health check
if (errorCode != 0) {
return Health.down().withDetail("Error Code", errorCode).build();
} r
eturn Health.up().build();
}
}

management.health.status.order: DOWN, OUT_OF_SERVICE, UNKNOWN, UP

{
  "status": "UP",
  "discoveryComposite": {
    "description": "Spring Cloud Eureka Discovery Client",
    "status": "UP",
    "discoveryClient": {
      "description": "Spring Cloud Eureka Discovery Client",
      "status": "UP",
      "services": [
        "..."
      ]
    },
    "eureka": {
      "description": "Remote status from Eureka server",
      "status": "UP",
      "applications": {
        "AOMS-MOBILE": 1,
        "DATA-EXCHANGE": 1,
        "CLOUD-GATEWAY": 2,
        "AOMS": 1,
        "AOMS-AIIS": 0,
        "AOMS-EUREKA": 2
      }
    }
  },
  "diskSpace": {
    "status": "UP",
    "total": 313759301632,
    "free": 291947081728,
    "threshold": 10485760
  },
  "refreshScope": {
    "status": "UP"
  },
  "hystrix": {
    "status": "UP"
  }
}

management.endpoint.health.group.<name>
//demo:
management.endpoint.health.group.mysys.include=db,redis,mail
management.endpoint.health.group.custom.exclude=rabbit

management.health.db.enabled=true

management.health.db.enabled=false

//RedisHealthIndicator.java
public class RedisHealthIndicator extends AbstractHealthIndicator {
	static final String VERSION = "version";
	static final String REDIS_VERSION = "redis_version";
	private final RedisConnectionFactory redisConnectionFactory;
	public RedisHealthIndicator(RedisConnectionFactory connectionFactory) {
		super("Redis health check failed");
		Assert.notNull(connectionFactory, "ConnectionFactory must not be null");
		this.redisConnectionFactory = connectionFactory;
	}
	@Override
	protected void doHealthCheck(Health.Builder builder) throws Exception {
		RedisConnection connection = RedisConnectionUtils
				.getConnection(this.redisConnectionFactory);
		try {
			if (connection instanceof RedisClusterConnection) {
				ClusterInfo clusterInfo = ((RedisClusterConnection) connection)
						.clusterGetClusterInfo();
				builder.up().withDetail("cluster_size", clusterInfo.getClusterSize())
						.withDetail("slots_up", clusterInfo.getSlotsOk())
						.withDetail("slots_fail", clusterInfo.getSlotsFail());
			}
			else {
				Properties info = connection.info();
				builder.up().withDetail(VERSION, info.getProperty(REDIS_VERSION));
			}
		}
		finally {
			RedisConnectionUtils.releaseConnection(connection,
					this.redisConnectionFactory);
		}
	}
}

 //AbstractHealthIndicator.java
 @Override
 public final Health health() {
  Health.Builder builder = new Health.Builder();
  try {
   doHealthCheck(builder);
  }
  catch (Exception ex) {
   if (this.logger.isWarnEnabled()) {
    String message = this.healthCheckFailedMessage.apply(ex);
    this.logger.warn(StringUtils.hasText(message) ? message : DEFAULT_MESSAGE,
      ex);
   }
   builder.down(ex);
  }
  return builder.build();
 }

@Configuration
@ConditionalOnClass(RedisConnectionFactory.class)
@ConditionalOnBean(RedisConnectionFactory.class)
@ConditionalOnEnabledHealthIndicator("redis")
@AutoConfigureBefore(HealthIndicatorAutoConfiguration.class)
@AutoConfigureAfter({ RedisAutoConfiguration.class,
  RedisReactiveHealthIndicatorAutoConfiguration.class })
public class RedisHealthIndicatorAutoConfiguration extends
  CompositeHealthIndicatorConfiguration<RedisHealthIndicator, RedisConnectionFactory> {
 private final Map<String, RedisConnectionFactory> redisConnectionFactories;
 public RedisHealthIndicatorAutoConfiguration(
   Map<String, RedisConnectionFactory> redisConnectionFactories) {
  this.redisConnectionFactories = redisConnectionFactories;
 }
 @Bean
 @ConditionalOnMissingBean(name = "redisHealthIndicator")
 public HealthIndicator redisHealthIndicator() {
  return createHealthIndicator(this.redisConnectionFactories);
 }
}

@Component
@ConditionalOnProperty(name="spring.dfs.http.send-url")
@Slf4j
public class DfsHealthIndicator implements HealthIndicator {
    @Value("${spring.dfs.http.send-url}")
    private String dsfSendUrl;
    @Override
    public Health health() {
        log.debug("正在检查dfs配置项...");
        log.debug("dfs 请求地址：{}",dsfSendUrl);
        Health.Builder up = Health.up().withDetail("url", dsfSendUrl);
        try {
            HttpUtils.telnet(StringUtils.getIpFromUrl(dsfSendUrl),StringUtils.getPortFromUrl(dsfSendUrl));
            return up.build();
        } catch (IOException e) {
            e.printStackTrace();
            log.error("DFS配置项错误或网络超时");
            return up.withException(e).build();
        }
    }
}

{
    "dfs": {
    "status": "UP",
    "url": "10.254.131.197:8088",
    "error": "java.net.ConnectException: Connection refused (Connection refused)"
    }
}