Java HealthAggregator类代码示例

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Test
public void downWithExceptionHandling() throws Exception {

    HealthAggregator healthAggregator = mock(HealthAggregator.class);
    ApplicationAliveIndicator healthIndicator = mock(ApplicationAliveIndicator.class);
    when(healthIndicator.health()).thenThrow(new RuntimeException("fooException"));
    Map<String, ApplicationAliveIndicator> healthIndicators = new LinkedHashMap<>();
    healthIndicators.put("foo", healthIndicator);

    when(applicationContext.getBeansOfType(ApplicationAliveIndicator.class)).thenReturn(healthIndicators);


    extendedHealthEndpoint = new AliveHealthEndpoint("healthIndicatorfoo", healthAggregator);
    extendedHealthEndpoint.setApplicationContext(applicationContext);

    this.extendedHealthMvcEndpoint = new ExtendedHealthMvcEndpoint(this.extendedHealthEndpoint);

    ResponseEntity<Health> result = (ResponseEntity<Health>) this.extendedHealthMvcEndpoint.invoke(null);

    Map<String, Object> expectedHealthDetails = new LinkedHashMap<>();
    expectedHealthDetails.put("error", "java.lang.RuntimeException: fooException");
    assertThat(result.getBody().getDetails(), is(expectedHealthDetails));
    assertThat(result.getStatusCode(), is(HttpStatus.SERVICE_UNAVAILABLE));
    assertThat(result.getBody().getStatus(), is(Status.DOWN));
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
public HealthService(HealthAggregator healthAggregator, Map<String, org.springframework.boot.actuate.health.HealthIndicator> healthIndicators) {
    Assert.notNull(healthAggregator, "HealthAggregator must not be null");
    Assert.notNull(healthIndicators, "HealthIndicators must not be null");
    CompositeHealthIndicator healthIndicator = new CompositeHealthIndicator(
        healthAggregator);
    for (Map.Entry<String, org.springframework.boot.actuate.health.HealthIndicator> entry : healthIndicators.entrySet()) {
        healthIndicator.addHealthIndicator(getKey(entry.getKey()), entry.getValue());
    }
    this.healthIndicators = healthIndicators;
    this.healthIndicator = healthIndicator;
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
public EndpointAutoConfiguration(
		ObjectProvider<HealthAggregator> healthAggregatorProvider,
		ObjectProvider<Map<String, HealthIndicator>> healthIndicatorsProvider,
		ObjectProvider<List<InfoContributor>> infoContributorsProvider,
		ObjectProvider<Collection<PublicMetrics>> publicMetricsProvider,
		ObjectProvider<TraceRepository> traceRepositoryProvider) {
	this.healthAggregator = healthAggregatorProvider.getIfAvailable();
	this.healthIndicators = healthIndicatorsProvider.getIfAvailable();
	this.infoContributors = infoContributorsProvider.getIfAvailable();
	this.publicMetrics = publicMetricsProvider.getIfAvailable();
	this.traceRepository = traceRepositoryProvider.getIfAvailable();
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
/**
 * Create a new {@link HealthIndicator} instance.
 * @param healthAggregator the health aggregator
 * @param healthIndicators the health indicators
 */
public HealthEndpoint(HealthAggregator healthAggregator,
		Map<String, HealthIndicator> healthIndicators) {
	super("health", false);
	Assert.notNull(healthAggregator, "HealthAggregator must not be null");
	Assert.notNull(healthIndicators, "HealthIndicators must not be null");
	CompositeHealthIndicator healthIndicator = new CompositeHealthIndicator(
			healthAggregator);
	for (Map.Entry<String, HealthIndicator> entry : healthIndicators.entrySet()) {
		healthIndicator.addHealthIndicator(getKey(entry.getKey()), entry.getValue());
	}
	this.healthIndicator = healthIndicator;
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
public PrometheusEndpoint(Collection<PublicMetrics> publicMetrics,
		PrometeusMetricNameConverter prometeusMetricNameConverter, Map<String, HealthIndicator> healthIndicators,
		HealthAggregator healthAggregator) {
	super("prometheus", false, true);
	this.publicMetrics = publicMetrics;
	this.prometeusMetricNameConverter = prometeusMetricNameConverter;
	this.healthIndicators = healthIndicators;
	this.healthAggregator = healthAggregator;

}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
@Autowired
public PrometheusEndpoint prometheusEndpoint(Collection<PublicMetrics> publicMetrics,
		PrometeusMetricNameConverter prometeusMetricNameConverter, Map<String, HealthIndicator> healthIndicators,
		HealthAggregator healthAggregator) {

	return new PrometheusEndpoint(publicMetrics, prometeusMetricNameConverter, healthIndicators, healthAggregator);
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Autowired
public DiscoveryCompositeHealthIndicator(HealthAggregator healthAggregator,
		List<DiscoveryHealthIndicator> indicators) {
	super(healthAggregator);
	for (DiscoveryHealthIndicator indicator : indicators) {
		Holder holder = new Holder(indicator);
		addHealthIndicator(indicator.getName(), holder);
		healthIndicators.add(holder);
	}
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Bean
@ConditionalOnProperty(value = "spring.cloud.discovery.client.composite-indicator.enabled", matchIfMissing = true)
@ConditionalOnBean(DiscoveryHealthIndicator.class)
public DiscoveryCompositeHealthIndicator discoveryCompositeHealthIndicator(
		HealthAggregator aggregator, List<DiscoveryHealthIndicator> indicators) {
	return new DiscoveryCompositeHealthIndicator(aggregator, indicators);
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Autowired
public SVNHealthIndicator(ConfigurationService<SVNConfiguration> configurationService, SecurityService securityService, HealthAggregator healthAggregator, SVNService svnService, TransactionService transactionService, SVNClient svnClient) {
    super(configurationService, securityService, healthAggregator);
    this.svnService = svnService;
    this.transactionService = transactionService;
    this.svnClient = svnClient;
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Autowired
public GitHubHealthIndicator(
        ConfigurationService<GitHubEngineConfiguration> configurationService,
        SecurityService securityService,
        HealthAggregator healthAggregator,
        OntrackGitHubClientFactory gitHubClientFactory) {
    super(configurationService, securityService, healthAggregator);
    this.gitHubClientFactory = gitHubClientFactory;
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Autowired
public GitLabHealthIndicator(
        ConfigurationService<GitLabConfiguration> configurationService,
        SecurityService securityService,
        HealthAggregator healthAggregator,
        OntrackGitLabClientFactory gitLabClientFactory) {
    super(configurationService, securityService, healthAggregator);
    this.gitLabClientFactory = gitLabClientFactory;
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
/** Registers health for any components, even those not in this jar. */
@Bean ZipkinHealthIndicator zipkinHealthIndicator(HealthAggregator healthAggregator) {
  return new ZipkinHealthIndicator(healthAggregator);
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
ZipkinHealthIndicator(HealthAggregator healthAggregator) {
  super(healthAggregator);
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Bean
public HealthEndpoint endpoint(HealthAggregator healthAggregator,
		Map<String, HealthIndicator> healthIndicators) {
	return new HealthEndpoint(healthAggregator, healthIndicators);
}
 

import org.springframework.boot.actuate.health.HealthAggregator; //导入依赖的package包/类
@Bean
public HealthAggregator healthAggregator() {
	return new OrderedHealthAggregator();
}