import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
public static TransportClientFactory newTransportClientFactory(final EurekaClientConfig clientConfig,
															   final Collection<ClientFilter> additionalFilters
															   ) {
	final TransportClientFactory jerseyFactory = JerseyEurekaHttpClientFactory.create(
			clientConfig, additionalFilters, null, null);
	final TransportClientFactory metricsFactory = MetricsCollectingEurekaHttpClient.createFactory(jerseyFactory);

	return new TransportClientFactory() {
		@Override
		public EurekaHttpClient newClient(EurekaEndpoint serviceUrl) {
			return metricsFactory.newClient(serviceUrl);
		}

		@Override
		public void shutdown() {
			metricsFactory.shutdown();
			jerseyFactory.shutdown();
		}
	};
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Before
public void beforeMethod() {
    eurekaIsDisabledPropertySupplierMock = mock(Supplier.class);
    datacenterTypePropertySupplierMock = mock(Supplier.class);
    cloudInstanceConfigMock = mock(CloudInstanceConfig.class);

    doReturn(false).when(eurekaIsDisabledPropertySupplierMock).get();
    doReturn(MyOwn.name()).when(datacenterTypePropertySupplierMock).get();

    handlerSpy = spy(new EurekaHandler(eurekaIsDisabledPropertySupplierMock, datacenterTypePropertySupplierMock));

    doNothing().when(handlerSpy).initDiscoveryManager(any(EurekaInstanceConfig.class),
                                                      any(EurekaClientConfig.class));
    doNothing().when(handlerSpy).shutdownDiscoveryManager();
    doNothing().when(handlerSpy).setEurekaInstanceStatus(any(InstanceStatus.class));
    doReturn(cloudInstanceConfigMock).when(handlerSpy).createCloudInstanceConfig(anyString());
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Test
public void register_uses_createEurekaInstanceConfig_then_calls_initDiscoveryManager_with_it_and_sets_instance_status_UP() {
    // given
    EurekaInstanceConfig instanceConfigMock = mock(EurekaInstanceConfig.class);
    doReturn(instanceConfigMock).when(handlerSpy).createEurekaInstanceConfig();
    assertThat(handlerSpy.registered.get()).isFalse();

    // when
    handlerSpy.register();

    // then
    assertThat(handlerSpy.registered.get()).isTrue();
    verify(handlerSpy).createEurekaInstanceConfig();

    ArgumentCaptor<EurekaClientConfig> clientConfigCaptor = ArgumentCaptor.forClass(EurekaClientConfig.class);
    verify(handlerSpy).initDiscoveryManager(eq(instanceConfigMock),
                                            clientConfigCaptor.capture());
    EurekaClientConfig clientConfigUsed = clientConfigCaptor.getValue();
    assertThat(clientConfigUsed).isInstanceOf(DefaultEurekaClientConfig.class);
    assertThat(Whitebox.getInternalState(clientConfigUsed, "namespace")).isEqualTo(handlerSpy.eurekaClientNamespace);

    verify(handlerSpy).setEurekaInstanceStatus(InstanceStatus.UP);
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
public EurekaServerBootstrap(ApplicationInfoManager applicationInfoManager,
		EurekaClientConfig eurekaClientConfig, EurekaServerConfig eurekaServerConfig,
		PeerAwareInstanceRegistry registry, EurekaServerContext serverContext) {
	this.applicationInfoManager = applicationInfoManager;
	this.eurekaClientConfig = eurekaClientConfig;
	this.eurekaServerConfig = eurekaServerConfig;
	this.registry = registry;
	this.serverContext = serverContext;
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
public InstanceRegistry(EurekaServerConfig serverConfig,
		EurekaClientConfig clientConfig, ServerCodecs serverCodecs,
		EurekaClient eurekaClient, int expectedNumberOfRenewsPerMin,
		int defaultOpenForTrafficCount) {
	super(serverConfig, clientConfig, serverCodecs, eurekaClient);

	this.expectedNumberOfRenewsPerMin = expectedNumberOfRenewsPerMin;
	this.defaultOpenForTrafficCount = defaultOpenForTrafficCount;
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public EurekaServerConfig eurekaServerConfig(EurekaClientConfig clientConfig) {
	EurekaServerConfigBean server = new EurekaServerConfigBean();
	if (clientConfig.shouldRegisterWithEureka()) {
		// Set a sensible default if we are supposed to replicate
		server.setRegistrySyncRetries(5);
	}
	return server;
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Bean
public PeerEurekaNodes myPeerEurekaNodes(PeerAwareInstanceRegistry registry,
		EurekaServerConfig eurekaServerConfig,
		EurekaClientConfig eurekaClientConfig, ServerCodecs serverCodecs,
		ApplicationInfoManager applicationInfoManager) {
	return new CustomEurekaPeerNodes(registry, eurekaServerConfig,
			eurekaClientConfig, serverCodecs, applicationInfoManager);
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
public CustomEurekaPeerNodes(PeerAwareInstanceRegistry registry,
		EurekaServerConfig serverConfig, EurekaClientConfig clientConfig,
		ServerCodecs serverCodecs,
		ApplicationInfoManager applicationInfoManager) {
	super(registry, serverConfig, clientConfig, serverCodecs,
			applicationInfoManager);
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Test
public void register_does_nothing_if_eureka_is_disabled() {
    // given
    doReturn(true).when(eurekaIsDisabledPropertySupplierMock).get();

    // when
    handlerSpy.register();

    // then
    verify(handlerSpy, never()).createEurekaInstanceConfig();
    verify(handlerSpy, never()).initDiscoveryManager(any(EurekaInstanceConfig.class),
                                                     any(EurekaClientConfig.class));
    verify(handlerSpy, never()).setEurekaInstanceStatus(any(InstanceStatus.class));
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Test
public void register_does_nothing_if_already_registered() {
    // given
    handlerSpy.registered.set(true);

    // when
    handlerSpy.register();

    // then
    verify(handlerSpy, never()).createEurekaInstanceConfig();
    verify(handlerSpy, never()).initDiscoveryManager(any(EurekaInstanceConfig.class),
                                                     any(EurekaClientConfig.class));
    verify(handlerSpy, never()).setEurekaInstanceStatus(any(InstanceStatus.class));
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Override
protected void configure() {
    bind(ApplicationInfoManager.class).in(Scopes.SINGLETON);
    bind(EurekaClientConfig.class).in(Scopes.SINGLETON);
    bind(InstanceInfo.class).in(Scopes.SINGLETON);
    bind(EurekaClient.class).in(Scopes.SINGLETON);

    bind(EurekaHealthCheck.class).asEagerSingleton();
    bind(EurekaService.class).asEagerSingleton();
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
public RefreshablePeerEurekaNodes(
		final PeerAwareInstanceRegistry registry,
		final EurekaServerConfig serverConfig,
		final EurekaClientConfig clientConfig, 
		final ServerCodecs serverCodecs,
		final ApplicationInfoManager applicationInfoManager) {
	super(registry, serverConfig, clientConfig, serverCodecs, applicationInfoManager);
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
public EurekaRibbonClientConfiguration(EurekaClientConfig clientConfig,
		String serviceId, EurekaInstanceConfig eurekaConfig,
		boolean approximateZoneFromHostname) {
	this.clientConfig = clientConfig;
	this.serviceId = serviceId;
	this.eurekaConfig = eurekaConfig;
	this.approximateZoneFromHostname = approximateZoneFromHostname;
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
public EurekaHealthIndicator(EurekaClient eurekaClient,
		EurekaInstanceConfig instanceConfig, EurekaClientConfig clientConfig) {
	super();
	this.eurekaClient = eurekaClient;
	this.instanceConfig = instanceConfig;
	this.clientConfig = clientConfig;
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
public CloudEurekaClient(ApplicationInfoManager applicationInfoManager,
						 EurekaClientConfig config,
						 AbstractDiscoveryClientOptionalArgs<?> args,
						 ApplicationEventPublisher publisher) {
	super(applicationInfoManager, config, args);
	this.applicationInfoManager = applicationInfoManager;
	this.publisher = publisher;
	this.eurekaTransportField = ReflectionUtils.findField(DiscoveryClient.class, "eurekaTransport");
	ReflectionUtils.makeAccessible(this.eurekaTransportField);
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Override
public TransportClientFactory newTransportClientFactory(final EurekaClientConfig clientConfig,
														final Collection<Void> additionalFilters,
														final InstanceInfo myInstanceInfo,
														final Optional<SSLContext> sslContext,
														final Optional<HostnameVerifier> hostnameVerifier) {
	return new RestTemplateTransportClientFactory();
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(value = EurekaClientConfig.class, search = SearchStrategy.CURRENT)
public EurekaClientConfigBean eurekaClientConfigBean() {
	EurekaClientConfigBean client = new EurekaClientConfigBean();
	if ("bootstrap".equals(this.env.getProperty("spring.config.name"))) {
		// We don't register during bootstrap by default, but there will be another
		// chance later.
		client.setRegisterWithEureka(false);
	}
	return client;
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
@ConditionalOnEnabledHealthIndicator("eureka")
public EurekaHealthIndicator eurekaHealthIndicator(EurekaClient eurekaClient,
												   EurekaInstanceConfig instanceConfig, EurekaClientConfig clientConfig) {
	return new EurekaHealthIndicator(eurekaClient, instanceConfig, clientConfig);
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@Bean(destroyMethod = "shutdown")
@ConditionalOnMissingBean(value = EurekaClient.class, search = SearchStrategy.CURRENT)
public EurekaClient eurekaClient(ApplicationInfoManager manager, EurekaClientConfig config, ApplicationContext context) {
	return new CloudEurekaClient(manager, config, null, context) {
		@Override
		public synchronized void shutdown() {
			CountDownLatch latch = countDownLatch();
			if (latch.getCount() == 1) {
				latch.countDown();
			}
			super.shutdown();
		}
	};
}
 

import com.netflix.discovery.EurekaClientConfig; //导入依赖的package包/类
@SuppressWarnings("deprecation")
protected void initDiscoveryManager(EurekaInstanceConfig eurekaInstanceConfig,
                                    EurekaClientConfig eurekaClientConfig) {
    DiscoveryManager.getInstance().initComponent(eurekaInstanceConfig, eurekaClientConfig);
}