import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Test
public void single_discovery_for_same_heartbeat() {
    Object heartbeat = new Object();
    listener.onParentHeartbeat(new ParentHeartbeatEvent(new Object(), heartbeat));

    when(discovery.getServices()).thenReturn(singletonList("service"));
    when(discovery.getInstances("service")).thenReturn(
            singletonList(new DefaultServiceInstance("service", "localhost", 80, false)));

    listener.onApplicationEvent(new HeartbeatEvent(new Object(), heartbeat));
    StepVerifier.create(registry.getInstances()).verifyComplete();

    listener.onApplicationEvent(new HeartbeatEvent(new Object(), new Object()));
    StepVerifier.create(registry.getInstances())
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("service"))
                .verifyComplete();
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Test
public void shouldRetryAndSucceedGetConfigServerInstanceFromDiscoveryClient()
		throws Exception {
	givenDiscoveryClientReturnsInfoOnThirdTry();

	setup("spring.cloud.config.discovery.enabled=true",
			"spring.cloud.config.retry.maxAttempts=3",
			"spring.cloud.config.retry.initialInterval=10",
			"spring.cloud.config.fail-fast=true");

	expectDiscoveryClientConfigServiceBootstrapConfigurationIsSetup();
	verifyDiscoveryClientCalledThreeTimes();

	context.publishEvent(new HeartbeatEvent(context, "new"));

	expectConfigClientPropertiesHasConfigurationFromEureka();
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Scheduled(fixedDelayString = "${spring.cloud.consul.discovery.catalogServicesWatchDelay:30000}")
public void catalogServicesWatch() {
	try {
		long index = -1;
		if (catalogServicesIndex.get() != null) {
			index = catalogServicesIndex.get().longValue();
		}

		Response<Map<String, List<String>>> response = consul
				.getCatalogServices(new QueryParams(properties
						.getCatalogServicesWatchTimeout(), index));
		Long consulIndex = response.getConsulIndex();
		if (consulIndex != null) {
			catalogServicesIndex.set(BigInteger.valueOf(consulIndex));
		}

		log.trace("Received services update from consul: {}, index: {}",
				response.getValue(), consulIndex);
		publisher.publishEvent(new HeartbeatEvent(this, consulIndex));
	}
	catch (Exception e) {
		log.error("Error watching Consul CatalogServices", e);
	}
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Override
public void onApplicationEvent(ApplicationEvent event) {
	if (event instanceof ContextRefreshedEvent) {
		refresh();
	}
	else if (event instanceof HeartbeatEvent) {
		if (this.monitor.update(((HeartbeatEvent) event).getValue())) {
			refresh();
		}
	}
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Override
public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {
	if (event.getType().equals(TreeCacheEvent.Type.NODE_ADDED)
			|| event.getType().equals(TreeCacheEvent.Type.NODE_REMOVED)
			|| event.getType().equals(TreeCacheEvent.Type.NODE_UPDATED)) {
		long newCacheChange = this.cacheChange.incrementAndGet();
		this.publisher.publishEvent(new HeartbeatEvent(this, newCacheChange));
	}
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Override
public void onApplicationEvent(ApplicationEvent event) {
	if (event instanceof ContextRefreshedEvent
			|| event instanceof RefreshScopeRefreshedEvent
			|| event instanceof RoutesRefreshedEvent) {
		this.zuulHandlerMapping.setDirty(true);
	}
	else if (event instanceof HeartbeatEvent) {
		if (this.heartbeatMonitor.update(((HeartbeatEvent) event).getValue())) {
			this.zuulHandlerMapping.setDirty(true);
		}
	}
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Override
protected void onCacheRefreshed() {
	super.onCacheRefreshed();

	if (this.cacheRefreshedCount != null) { //might be called during construction and will be null
		long newCount = this.cacheRefreshedCount.incrementAndGet();
		log.trace("onCacheRefreshed called with count: " + newCount);
		this.publisher.publishEvent(new HeartbeatEvent(this, newCount));
	}
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Scheduled(fixedDelayString = "${spring.cloud.cloudfoundry.discovery.heartbeatFrequency:5000}")
public void poll() {
	if (this.publisher != null) {
		List<String> services = this.client.getServices();
		this.publisher.publishEvent(new HeartbeatEvent(this.client, services));
	}
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Override
public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
	return ContextRefreshedEvent.class.isAssignableFrom(eventType)
			|| HeartbeatEvent.class.isAssignableFrom(eventType);
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@EventListener
public void discoveryHeartbeat(HeartbeatEvent event) {
	if (this.enabled && this.monitor.update(event.getValue())) {
		this.adapter.rebind();
	}
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@EventListener
public void onApplicationEvent(HeartbeatEvent event) {
    discoverIfNeeded(event.getValue());
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Test
public void deregister_removed_app() {
    StepVerifier.create(registry.register(Registration.create("ignored", "http://health").build()))
                .consumeNextWith((id) -> {})
                .verifyComplete();
    StepVerifier.create(
            registry.register(Registration.create("different-source", "http://health2").source("http-api").build()))
                .consumeNextWith((id) -> {})
                .verifyComplete();
    listener.setIgnoredServices(singleton("ignored"));

    List<ServiceInstance> instances = new ArrayList<>();
    instances.add(new DefaultServiceInstance("service", "localhost", 80, false));
    instances.add(new DefaultServiceInstance("service", "example.net", 80, false));

    when(discovery.getServices()).thenReturn(singletonList("service"));
    when(discovery.getInstances("service")).thenReturn(instances);

    listener.onApplicationEvent(new HeartbeatEvent(new Object(), new Object()));

    StepVerifier.create(registry.getInstances("service"))
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("service"))
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("service"))
                .verifyComplete();

    StepVerifier.create(registry.getInstances("ignored"))
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("ignored"))
                .verifyComplete();

    StepVerifier.create(registry.getInstances("different-source"))
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("different-source"))
                .verifyComplete();


    instances.remove(0);

    listener.onApplicationEvent(new HeartbeatEvent(new Object(), new Object()));
    StepVerifier.create(registry.getInstances("service"))
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("service"))
                .verifyComplete();

    StepVerifier.create(registry.getInstances("ignored"))
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("ignored"))
                .verifyComplete();

    StepVerifier.create(registry.getInstances("different-source"))
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("different-source"))
                .verifyComplete();
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@EventListener(HeartbeatEvent.class)
public void heartbeat(HeartbeatEvent event) {
	if (monitor.update(event.getValue())) {
		refresh();
	}
}
 

import org.springframework.cloud.client.discovery.event.HeartbeatEvent; //导入依赖的package包/类
@Test
public void onWhenHeartbeat() throws Exception {
	setup("spring.cloud.config.discovery.enabled=true");

	expectDiscoveryClientConfigServiceBootstrapConfigurationIsSetup();

	givenDiscoveryClientReturnsInfo();
	verifyDiscoveryClientCalledOnce();

	context.publishEvent(new HeartbeatEvent(context, "new"));

	expectConfigClientPropertiesHasConfigurationFromEureka();
}