Java HealthIndicator类代码示例

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void testParentConnectionFactoryInheritedByDefault() {
	context = SpringApplication.run(SimpleProcessor.class, "--server.port=0");
	BinderFactory<?> binderFactory = context.getBean(BinderFactory.class);
	Binder binder = binderFactory.getBinder(null);
	assertThat(binder, instanceOf(RedisMessageChannelBinder.class));
	DirectFieldAccessor binderFieldAccessor = new DirectFieldAccessor(binder);
	RedisConnectionFactory binderConnectionFactory =
			(RedisConnectionFactory) binderFieldAccessor.getPropertyValue("connectionFactory");
	assertThat(binderConnectionFactory, instanceOf(RedisConnectionFactory.class));
	RedisConnectionFactory connectionFactory = context.getBean(RedisConnectionFactory.class);
	assertThat(binderConnectionFactory, is(connectionFactory));
	CompositeHealthIndicator bindersHealthIndicator =
			context.getBean("bindersHealthIndicator", CompositeHealthIndicator.class);
	assertNotNull(bindersHealthIndicator);
	DirectFieldAccessor directFieldAccessor = new DirectFieldAccessor(bindersHealthIndicator);
	@SuppressWarnings("unchecked")
	Map<String,HealthIndicator> healthIndicators =
			(Map<String, HealthIndicator>) directFieldAccessor.getPropertyValue("indicators");
	assertThat(healthIndicators, hasKey("redis"));
	assertThat(healthIndicators.get("redis").health().getStatus(), equalTo(Status.UP));
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void testParentConnectionFactoryInheritedIfOverridden() {
	context = new SpringApplication(SimpleProcessor.class, ConnectionFactoryConfiguration.class).run("--server.port=0");
	BinderFactory<?> binderFactory = context.getBean(BinderFactory.class);
	Binder binder = binderFactory.getBinder(null);
	assertThat(binder, instanceOf(RedisMessageChannelBinder.class));
	DirectFieldAccessor binderFieldAccessor = new DirectFieldAccessor(binder);
	RedisConnectionFactory binderConnectionFactory =
			(RedisConnectionFactory) binderFieldAccessor.getPropertyValue("connectionFactory");
	assertThat(binderConnectionFactory, is(MOCK_CONNECTION_FACTORY));
	RedisConnectionFactory connectionFactory = context.getBean(RedisConnectionFactory.class);
	assertThat(binderConnectionFactory, is(connectionFactory));
	CompositeHealthIndicator bindersHealthIndicator =
			context.getBean("bindersHealthIndicator", CompositeHealthIndicator.class);
	assertNotNull(bindersHealthIndicator);
	DirectFieldAccessor directFieldAccessor = new DirectFieldAccessor(bindersHealthIndicator);
	@SuppressWarnings("unchecked")
	Map<String,HealthIndicator> healthIndicators =
			(Map<String, HealthIndicator>) directFieldAccessor.getPropertyValue("indicators");
	assertThat(healthIndicators, hasKey("redis"));
	assertThat(healthIndicators.get("redis").health().getStatus(), equalTo(Status.UP));
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void dataSourceHealthIndicatorWithCustomValidationQuery() {
	this.context.register(PropertyPlaceholderAutoConfiguration.class,
			ManagementServerProperties.class, DataSourceProperties.class,
			DataSourceConfig.class,
			DataSourcePoolMetadataProvidersConfiguration.class,
			HealthIndicatorAutoConfiguration.class);
	EnvironmentTestUtils.addEnvironment(this.context,
			"spring.datasource.test.validation-query:SELECT from FOOBAR",
			"management.health.diskspace.enabled:false");
	this.context.refresh();
	Map<String, HealthIndicator> beans = this.context
			.getBeansOfType(HealthIndicator.class);
	assertThat(beans).hasSize(1);
	HealthIndicator healthIndicator = beans.values().iterator().next();
	assertThat(healthIndicator.getClass()).isEqualTo(DataSourceHealthIndicator.class);
	DataSourceHealthIndicator dataSourceHealthIndicator = (DataSourceHealthIndicator) healthIndicator;
	assertThat(dataSourceHealthIndicator.getQuery()).isEqualTo("SELECT from FOOBAR");
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void mailHealthIndicator() {
	EnvironmentTestUtils.addEnvironment(this.context,
			"spring.mail.host:smtp.acme.org",
			"management.health.diskspace.enabled:false");
	this.context.register(MailSenderAutoConfiguration.class,
			ManagementServerProperties.class, HealthIndicatorAutoConfiguration.class);
	this.context.refresh();

	Map<String, HealthIndicator> beans = this.context
			.getBeansOfType(HealthIndicator.class);
	assertThat(beans).hasSize(1);
	assertThat(beans.values().iterator().next().getClass())
			.isEqualTo(MailHealthIndicator.class);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void elasticsearchHealthIndicator() {
	EnvironmentTestUtils.addEnvironment(this.context,
			"spring.data.elasticsearch.properties.path.home:target",
			"management.health.diskspace.enabled:false");
	this.context.register(JestClientConfiguration.class,
			JestAutoConfiguration.class, ElasticsearchAutoConfiguration.class,
			ManagementServerProperties.class, HealthIndicatorAutoConfiguration.class);
	this.context.refresh();

	Map<String, HealthIndicator> beans = this.context
			.getBeansOfType(HealthIndicator.class);
	assertThat(beans).hasSize(1);
	assertThat(beans.values().iterator().next().getClass())
			.isEqualTo(ElasticsearchHealthIndicator.class);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void notElasticsearchHealthIndicator() {
	EnvironmentTestUtils.addEnvironment(this.context,
			"management.health.elasticsearch.enabled:false",
			"spring.data.elasticsearch.properties.path.home:target",
			"management.health.diskspace.enabled:false");
	this.context.register(JestClientConfiguration.class,
			JestAutoConfiguration.class, ElasticsearchAutoConfiguration.class,
			ManagementServerProperties.class, HealthIndicatorAutoConfiguration.class);
	this.context.refresh();

	Map<String, HealthIndicator> beans = this.context
			.getBeansOfType(HealthIndicator.class);
	assertThat(beans).hasSize(1);
	assertThat(beans.values().iterator().next().getClass())
			.isEqualTo(ApplicationHealthIndicator.class);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void testParentConnectionFactoryInheritedIfOverridden() {
	context = new SpringApplicationBuilder(SimpleProcessor.class, ConnectionFactoryConfiguration.class)
			.web(WebApplicationType.NONE)
			.run("--server.port=0");
	BinderFactory binderFactory = context.getBean(BinderFactory.class);
	Binder<?, ?, ?> binder = binderFactory.getBinder(null, MessageChannel.class);
	assertThat(binder).isInstanceOf(RabbitMessageChannelBinder.class);
	DirectFieldAccessor binderFieldAccessor = new DirectFieldAccessor(binder);
	ConnectionFactory binderConnectionFactory = (ConnectionFactory) binderFieldAccessor
			.getPropertyValue("connectionFactory");
	assertThat(binderConnectionFactory).isSameAs(MOCK_CONNECTION_FACTORY);
	ConnectionFactory connectionFactory = context.getBean(ConnectionFactory.class);
	assertThat(binderConnectionFactory).isSameAs(connectionFactory);
	CompositeHealthIndicator bindersHealthIndicator = context.getBean("bindersHealthIndicator",
			CompositeHealthIndicator.class);
	assertThat(bindersHealthIndicator).isNotNull();
	DirectFieldAccessor directFieldAccessor = new DirectFieldAccessor(bindersHealthIndicator);
	@SuppressWarnings("unchecked")
	Map<String, HealthIndicator> healthIndicators = (Map<String, HealthIndicator>) directFieldAccessor
			.getPropertyValue("indicators");
	assertThat(healthIndicators).containsKey("rabbit");
	// mock connection factory behaves as if down
	assertThat(healthIndicators.get("rabbit").health().getStatus()).isEqualTo(Status.DOWN);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Bean
public HealthIndicator taskHealthIndicator() {
    return new AbstractHealthIndicator() {
        @Override
        protected void doHealthCheck(Health.Builder builder) throws Exception {
            if (correctNumberOfInstances()) {
                builder.up();
            } else {
                builder.down();
            }
            builder.withDetail("mesos.resources.count", instanceCount.getCount());
            builder.withDetail("instances", stateRepository.allTaskInfos().size());

            for (Protos.TaskState taskState : Protos.TaskState.values()) {
                Map<String, Protos.TaskStatus> state = getTasksForState(taskState);
                builder.withDetail(taskState.name(), state.size());
            }
        }
    };
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Override
public void configure(CommandLine cli) {
    CommandLine healthCli = new CommandLine(new HelpAwareContainerPicocliCommand() {});
    for (Map.Entry<String, HealthIndicator> entry : healthIndicators.entrySet()) {
        Matcher matcher = HEALTH_PATTERN.matcher(entry.getKey());
        if (matcher.matches()) {
            String name = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, matcher.group(1));
            healthCli.addSubcommand(name, new PrintCommand(entry.getValue().health()));
        } else {
            logger.warn("Unable to determine a correct name for given indicator: \"{}\", skip it!",
                    entry.getKey());
        }
    }
    cli.addSubcommand("health", healthCli);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void jmsHealthIndicator() {
	EnvironmentTestUtils.addEnvironment(this.context,
			"management.health.diskspace.enabled:false");
	this.context.register(ActiveMQAutoConfiguration.class,
			ManagementServerProperties.class, HealthIndicatorAutoConfiguration.class);
	this.context.refresh();

	Map<String, HealthIndicator> beans = this.context
			.getBeansOfType(HealthIndicator.class);
	assertThat(beans).hasSize(1);
	assertThat(beans.values().iterator().next().getClass())
			.isEqualTo(JmsHealthIndicator.class);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
protected HealthIndicator createHealthIndicator(Map<String, S> beans) {
	if (beans.size() == 1) {
		return createHealthIndicator(beans.values().iterator().next());
	}
	CompositeHealthIndicator composite = new CompositeHealthIndicator(
			this.healthAggregator);
	for (Map.Entry<String, S> entry : beans.entrySet()) {
		composite.addHealthIndicator(entry.getKey(),
				createHealthIndicator(entry.getValue()));
	}
	return composite;
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void notJmsHealthIndicator() {
	EnvironmentTestUtils.addEnvironment(this.context,
			"management.health.jms.enabled:false",
			"management.health.diskspace.enabled:false");
	this.context.register(ActiveMQAutoConfiguration.class,
			ManagementServerProperties.class, HealthIndicatorAutoConfiguration.class);
	this.context.refresh();

	Map<String, HealthIndicator> beans = this.context
			.getBeansOfType(HealthIndicator.class);
	assertThat(beans).hasSize(1);
	assertThat(beans.values().iterator().next().getClass())
			.isEqualTo(ApplicationHealthIndicator.class);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Test
public void notMailHealthIndicator() {
	EnvironmentTestUtils.addEnvironment(this.context,
			"spring.mail.host:smtp.acme.org", "management.health.mail.enabled:false",
			"management.health.diskspace.enabled:false");
	this.context.register(MailSenderAutoConfiguration.class,
			ManagementServerProperties.class, HealthIndicatorAutoConfiguration.class);
	this.context.refresh();

	Map<String, HealthIndicator> beans = this.context
			.getBeansOfType(HealthIndicator.class);
	assertThat(beans).hasSize(1);
	assertThat(beans.values().iterator().next().getClass())
			.isEqualTo(ApplicationHealthIndicator.class);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public HealthEndpoint healthEndpoint() {
	return new HealthEndpoint(
			this.healthAggregator == null ? new OrderedHealthAggregator()
					: this.healthAggregator,
			this.healthIndicators == null
					? Collections.<String, HealthIndicator>emptyMap()
					: this.healthIndicators);
}
 

import org.springframework.boot.actuate.health.HealthIndicator; //导入依赖的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;
}