import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
@Override
public void registerDependencyRegistrationHooks() {
	for (ZookeeperDependency zookeeperDependency : this.zookeeperDependencies.getDependencyConfigurations()) {
		String dependencyPath = zookeeperDependency.getPath();
		ServiceCache<?> serviceCache = getServiceDiscovery()
				.serviceCacheBuilder().name(dependencyPath).build();
		try {
			serviceCache.start();
		}
		catch (Exception e) {
			ReflectionUtils.rethrowRuntimeException(e);
		}
		this.dependencyPresenceOnStartupVerifier.verifyDependencyPresence(dependencyPath, serviceCache, zookeeperDependency.isRequired());
		this.dependencyRegistry.put(dependencyPath, serviceCache);
		serviceCache.addListener(new DependencyStateChangeListenerRegistry(this.listeners, dependencyPath, serviceCache));
	}
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
@Override
public Collection<ServiceInstance<MetaInfo>> queryForInstances(String name) throws Exception {
	ServiceCache<MetaInfo> serviceCache = getServiceCache(name);
	if(serviceCache != null){
		return serviceCache.getInstances();
	}
    return serviceDiscovery.queryForInstances(name);
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
private ServiceCache<MetaInfo> getServiceCache(String name) throws Exception{
	ServiceCache<MetaInfo> cache = cacheMap.get(name);
    if(cache == null){
    	final ServiceCache<MetaInfo> newCache = serviceDiscovery.serviceCacheBuilder().name(name).build();
    	newCache.start();
        cacheMap.putIfAbsent(name, newCache);
        return newCache;
    }
    return cache;
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void verifyDependencyPresence(String dependencyName, @SuppressWarnings("rawtypes") ServiceCache serviceCache, boolean required) {
	if (required) {
		MANDATORY_DEPENDENCY_CHECKER.checkPresence(dependencyName, serviceCache.getInstances());
	} else {
		this.optionalDependencyChecker.checkPresence(dependencyName, serviceCache.getInstances());
	}
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
@Test public void should_throw_exception_if_obligatory_dependencies_are_missing() {
	//given:
	DefaultDependencyPresenceOnStartupVerifier dependencyVerifier = new DefaultDependencyPresenceOnStartupVerifier();
	ServiceCache serviceCache = mock(ServiceCache.class);
	given(serviceCache.getInstances()).willReturn(Collections.emptyList());
	//when:
	try {
		dependencyVerifier.verifyDependencyPresence(SERVICE_NAME, serviceCache, true);
		Assert.fail("Should throw no instances running exception");
	} catch (Exception e) {
		//then:
		then(e).isInstanceOf(NoInstancesRunningException.class);
	}
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
@Test public void should_check_optional_dependency_using_optional_dependency_checker() {
	//given:
	PresenceChecker optionalDependencyChecker = mock(PresenceChecker.class);
	DependencyPresenceOnStartupVerifier dependencyVerifier = new DependencyPresenceOnStartupVerifier(optionalDependencyChecker) {
	};
	ServiceCache serviceCache = mock(ServiceCache.class);
	given(serviceCache.getInstances()).willReturn(Collections.emptyList());
	//when:
	dependencyVerifier.verifyDependencyPresence(SERVICE_NAME, serviceCache, false);
	//then:
	then(optionalDependencyChecker).should().checkPresence(SERVICE_NAME, serviceCache.getInstances());
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
/**
 * Return a new service cache with the current settings
 *
 * @return service cache
 */
@Override
public ServiceCache<T> build()
{
    if (executorService != null)
    {
        return new ServiceCacheImpl<T>(discovery, name, executorService);
    }
    else
    {
        return new ServiceCacheImpl<T>(discovery, name, threadFactory);
    }
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
public DependencyStateChangeListenerRegistry(List<DependencyWatcherListener> listeners, String dependencyName, ServiceCache<?> serviceCache) {
	this.listeners = listeners;
	this.dependencyName = dependencyName;
	this.serviceCache = serviceCache;
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
@Override
public void clearDependencyRegistrationHooks() throws IOException {
	for (ServiceCache<?> cache : this.dependencyRegistry.values()) {
		cache.close();
	}
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
@Override public void verifyDependencyPresence(String dependencyName,
		ServiceCache serviceCache, boolean required) {
	startupPresenceVerified = true;
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
void cacheOpened(ServiceCache<T> cache)
{
    caches.add(cache);
}
 

import org.apache.curator.x.discovery.ServiceCache; //导入依赖的package包/类
void cacheClosed(ServiceCache<T> cache)
{
    caches.remove(cache);
}