AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

SpringCloud源码剖析-Eureka Client 初始化过程

2023-07-29 65
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 在spring-cloud-commons-2.0.1.RELEASE.jar SpringCloud公共包中/META-INF/spring.factories配置文件中有AutoServiceRegistrationAutoConfiguration自动配置类，当应用启动SpringBoot会扫描到该自动配置类，然后注册到Spring容器

前言

前面我们简单了解了一下SpringCloud Eureka的核心API,这一章我们跟踪一下Eureka的启动过程

1.EurekaClientAutoConfiguration:Eureka自动配置

有了解过SpringBoot自动配置的同学应该知道，在主程序启动类上我们会贴一个 @SpringBootApplication 注解，该注解里面包含了一个 @EnableAutoConfiguration 注解，该注解的作用是开启SpringBoot的自动配置，即：在 @EnableAutoConfiguration 标签中使用了一个 AutoConfigurationImportSelector选择器，该选择器会去扫描当前classpath环境中的 META-INF/spring.factories 文件中的自动配置类，然后完成相关的自动配置。如下：

  • @SpringBootApplication标签源码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented@Inherited@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(excludeFilters= {
@Filter(type=FilterType.CUSTOM, classes=TypeExcludeFilter.class),
@Filter(type=FilterType.CUSTOM, classes=AutoConfigurationExcludeFilter.class) })
public@interfaceSpringBootApplication {}
  • @EnableAutoConfiguration 标签源码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented@Inherited@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)
public@interfaceEnableAutoConfiguration {...}
  • AutoConfigurationImportSelector选择器源码
publicclassAutoConfigurationImportSelectorimplementsDeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware,
BeanFactoryAware, EnvironmentAware, Ordered {
//省略部分代码......//扫描classpath下的spring.factories自动配置@OverridepublicString[] selectImports(AnnotationMetadataannotationMetadata) {
if (!isEnabled(annotationMetadata)) {
returnNO_IMPORTS;
        }
AutoConfigurationMetadataautoConfigurationMetadata=AutoConfigurationMetadataLoader                .loadMetadata(this.beanClassLoader);
AnnotationAttributesattributes=getAttributes(annotationMetadata);
List<String>configurations=getCandidateConfigurations(annotationMetadata,
attributes);
configurations=removeDuplicates(configurations);
Set<String>exclusions=getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
configurations=filter(configurations, autoConfigurationMetadata);
fireAutoConfigurationImportEvents(configurations, exclusions);
returnStringUtils.toStringArray(configurations);
    }
}

在 selectImports 方法中会将扫描到的 META-INF/spring.factories 文件中的自动配置的一些类加载进来，然后注册到Spring容器中

其中在 spring-cloud-netflix-eureka-client-2.0.1.RELEASE.jar 这个jar包里面就有一个 META-INF/spring.factories文件，内容如下：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\org.springframework.cloud.netflix.eureka.config.EurekaClientConfigServerAutoConfiguration,\org.springframework.cloud.netflix.eureka.config.EurekaDiscoveryClientConfigServiceAutoConfiguration,\org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration,\org.springframework.cloud.netflix.ribbon.eureka.RibbonEurekaAutoConfiguration,\org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration

我们这里需要重点关注是 EurekaClientAutoConfiguration 这个类，从名字就能看出它是对EureakClient的自动配置，来详细看一下它的源码

//EurekaClient自动配置@Configuration@EnableConfigurationProperties@ConditionalOnClass(EurekaClientConfig.class)
@Import(DiscoveryClientOptionalArgsConfiguration.class)
@ConditionalOnBean(EurekaDiscoveryClientConfiguration.Marker.class)
@ConditionalOnProperty(value="eureka.client.enabled", matchIfMissing=true)
@AutoConfigureBefore({ NoopDiscoveryClientAutoConfiguration.class,
CommonsClientAutoConfiguration.class, ServiceRegistryAutoConfiguration.class })
@AutoConfigureAfter(name= {"org.springframework.cloud.autoconfigure.RefreshAutoConfiguration",
"org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration",
"org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration"})
publicclassEurekaClientAutoConfiguration {
...省略...
//注册EurekaClientConfigBean，该类实现了EurekaClientConfig客户端配置接口，EurekaClientConfigBean封装了客户端实例Eureaka Client注册到Eureak Server 服务端所需要的注册信息，比如：服务注册地址，拉取服务注册表的时间间隔, 注册信息复制到EurekaServer的时间等等@Bean@ConditionalOnMissingBean(value=EurekaClientConfig.class, search=SearchStrategy.CURRENT)
publicEurekaClientConfigBeaneurekaClientConfigBean(ConfigurableEnvironmentenv) {
EurekaClientConfigBeanclient=newEurekaClientConfigBean();
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);
        }
returnclient;
    }
//注册EurekaInstanceConfigBean ， eureka实例配置，实现了EurekaInstanceConfig配置接口，其中包括了：获取实例ID，//获取https协议端口，获取应用名，获取应用组名，获取租约心跳间隔时间，租约到期时间，获取ip,获取主机名等等方法。@Bean@ConditionalOnMissingBean(value=EurekaInstanceConfig.class, search=SearchStrategy.CURRENT)
publicEurekaInstanceConfigBeaneurekaInstanceConfigBean(InetUtilsinetUtils,
ManagementMetadataProvidermanagementMetadataProvider) {
Stringhostname=getProperty("eureka.instance.hostname");
booleanpreferIpAddress=Boolean.parseBoolean(getProperty("eureka.instance.prefer-ip-address"));
StringipAddress=getProperty("eureka.instance.ip-address");
booleanisSecurePortEnabled=Boolean.parseBoolean(getProperty("eureka.instance.secure-port-enabled"));
StringserverContextPath=env.getProperty("server.context-path", "/");
intserverPort=Integer.valueOf(env.getProperty("server.port", env.getProperty("port", "8080")));
IntegermanagementPort=env.getProperty("management.server.port", Integer.class);// nullable. should be wrapped into optionalStringmanagementContextPath=env.getProperty("management.server.servlet.context-path");// nullable. should be wrapped into optionalIntegerjmxPort=env.getProperty("com.sun.management.jmxremote.port", Integer.class);//nullableEurekaInstanceConfigBeaninstance=newEurekaInstanceConfigBean(inetUtils);
instance.setNonSecurePort(serverPort);
instance.setInstanceId(getDefaultInstanceId(env));
instance.setPreferIpAddress(preferIpAddress);
instance.setSecurePortEnabled(isSecurePortEnabled);
if (StringUtils.hasText(ipAddress)) {
instance.setIpAddress(ipAddress);
        }
if(isSecurePortEnabled) {
instance.setSecurePort(serverPort);
        }
if (StringUtils.hasText(hostname)) {
instance.setHostname(hostname);
        }
StringstatusPageUrlPath=getProperty("eureka.instance.status-page-url-path");
StringhealthCheckUrlPath=getProperty("eureka.instance.health-check-url-path");
if (StringUtils.hasText(statusPageUrlPath)) {
instance.setStatusPageUrlPath(statusPageUrlPath);
        }
if (StringUtils.hasText(healthCheckUrlPath)) {
instance.setHealthCheckUrlPath(healthCheckUrlPath);
        }
ManagementMetadatametadata=managementMetadataProvider.get(instance, serverPort,
serverContextPath, managementContextPath, managementPort);
if(metadata!=null) {
instance.setStatusPageUrl(metadata.getStatusPageUrl());
instance.setHealthCheckUrl(metadata.getHealthCheckUrl());
if(instance.isSecurePortEnabled()) {
instance.setSecureHealthCheckUrl(metadata.getSecureHealthCheckUrl());
            }
Map<String, String>metadataMap=instance.getMetadataMap();
if (metadataMap.get("management.port") ==null) {
metadataMap.put("management.port", String.valueOf(metadata.getManagementPort()));
            }
        } else {
//without the metadata the status and health check URLs will not be set//and the status page and health check url paths will not include the//context path so set them hereif(StringUtils.hasText(managementContextPath)) {
instance.setHealthCheckUrlPath(managementContextPath+instance.getHealthCheckUrlPath());
instance.setStatusPageUrlPath(managementContextPath+instance.getStatusPageUrlPath());
            }
        }
setupJmxPort(instance, jmxPort);
returninstance;
    }
//注册DiscoveryClient服务发现客户端，它是spring-cloud-commons:2.0.1.RELEASE SpringCloud公共抽象包中的（org.springframework.cloud.netflix.eureka.EurekaDiscoveryClient），//是Spring Cloudd的服务发现抽象接口 EurekaDiscoveryClient是它的实现@BeanpublicDiscoveryClientdiscoveryClient(EurekaInstanceConfigconfig, EurekaClientclient) {
returnnewEurekaDiscoveryClient(config, client);
    }
//Eureak服务注册器，他是SpringCloud 在Netflix标准上拓展出来的，提供了服务注册，取消注册，设置服务状态，获取服务状态方法,ServiceRegistry负责服务注册，DiscoveryClient负责服务发现@BeanpublicEurekaServiceRegistryeurekaServiceRegistry() {
returnnewEurekaServiceRegistry();
    }
//EurekaAutoServiceRegistration ：eureka服务自动注册器@Bean@ConditionalOnBean(AutoServiceRegistrationProperties.class)
@ConditionalOnProperty(value="spring.cloud.service-registry.auto-registration.enabled", matchIfMissing=true)
publicEurekaAutoServiceRegistrationeurekaAutoServiceRegistration(ApplicationContextcontext, EurekaServiceRegistryregistry,
EurekaRegistrationregistration) {
returnnewEurekaAutoServiceRegistration(context, registry, registration);
    }
//取消注册@Overridepublicvoidstop() {
this.serviceRegistry.deregister(this.registration);
this.running.set(false);
    }
//EureakClient配置，该配置没有刷新功能@Configuration@ConditionalOnMissingRefreshScope//不可刷新protectedstaticclassEurekaClientConfiguration {
@AutowiredprivateApplicationContextcontext;
@AutowiredprivateAbstractDiscoveryClientOptionalArgs<?>optionalArgs;
//注册EurekaClient  客户端对象 ， 它有一个实现 DiscoveryClient ，//这个实现 DiscoveryClient  是eureka-client:1.9.3包里面的，是Euraek的服务发现的核心实现@Bean(destroyMethod="shutdown")
@ConditionalOnMissingBean(value=EurekaClient.class, search=SearchStrategy.CURRENT)
publicEurekaClienteurekaClient(ApplicationInfoManagermanager, EurekaClientConfigconfig) {
returnnewCloudEurekaClient(manager, config, this.optionalArgs,
this.context);
        }
//注册ApplicationInfoManager  ，该对象用来管理 InstanceInfo@Bean@ConditionalOnMissingBean(value=ApplicationInfoManager.class, search=SearchStrategy.CURRENT)
publicApplicationInfoManagereurekaApplicationInfoManager(
EurekaInstanceConfigconfig) {
InstanceInfoinstanceInfo=newInstanceInfoFactory().create(config);
returnnewApplicationInfoManager(config, instanceInfo);
        }
//注册EurekaRegistration，它是Eureka实例的服务注册信息,开启自动注册时，该对象才会被注册@Bean@ConditionalOnBean(AutoServiceRegistrationProperties.class)
@ConditionalOnProperty(value="spring.cloud.service-registry.auto-registration.enabled", matchIfMissing=true)
publicEurekaRegistrationeurekaRegistration(EurekaClienteurekaClient,
CloudEurekaInstanceConfiginstanceConfig,
ApplicationInfoManagerapplicationInfoManager,
@Autowired(required=false) ObjectProvider<HealthCheckHandler>healthCheckHandler) {
returnEurekaRegistration.builder(instanceConfig)
                    .with(applicationInfoManager)
                    .with(eurekaClient)
                    .with(healthCheckHandler)
                    .build();
        }
    }
//这里也是EurekaClient的配置，只是可刷新的@Configuration@ConditionalOnRefreshScopeprotectedstaticclassRefreshableEurekaClientConfiguration {
@AutowiredprivateApplicationContextcontext;
@AutowiredprivateAbstractDiscoveryClientOptionalArgs<?>optionalArgs;
//注册Eureak客户端EurekaClient， @Lazy 懒初始化，该bean被用到的时候会被创建//EurekaClient有一个实现 DiscoveryClient这个实现 是eureka-client:1.9.3包里面的，是Euraek的服务发现的核心实现@Bean(destroyMethod="shutdown")
@ConditionalOnMissingBean(value=EurekaClient.class, search=SearchStrategy.CURRENT)
@org.springframework.cloud.context.config.annotation.RefreshScope@LazypublicEurekaClienteurekaClient(ApplicationInfoManagermanager, EurekaClientConfigconfig, EurekaInstanceConfiginstance) {
manager.getInfo(); // force initializationreturnnewCloudEurekaClient(manager, config, this.optionalArgs,
this.context);
        }
//注册ApplicationInfoManager,它是InstanceInfo的管理器@Bean@ConditionalOnMissingBean(value=ApplicationInfoManager.class, search=SearchStrategy.CURRENT)
@org.springframework.cloud.context.config.annotation.RefreshScope@LazypublicApplicationInfoManagereurekaApplicationInfoManager(EurekaInstanceConfigconfig) {
//注意：这里的InstanceInfo被创建的状态是InstanceStatus.STARTING；后面在初始化的过程中会修改为 InstanceStatus.UP;InstanceInfoinstanceInfo=newInstanceInfoFactory().create(config);
returnnewApplicationInfoManager(config, instanceInfo);
        }
@Bean@org.springframework.cloud.context.config.annotation.RefreshScope@ConditionalOnBean(AutoServiceRegistrationProperties.class)
@ConditionalOnProperty(value="spring.cloud.service-registry.auto-registration.enabled", matchIfMissing=true)
publicEurekaRegistrationeurekaRegistration(EurekaClienteurekaClient,
CloudEurekaInstanceConfiginstanceConfig,
ApplicationInfoManagerapplicationInfoManager,
@Autowired(required=false) ObjectProvider<HealthCheckHandler>healthCheckHandler) {
returnEurekaRegistration.builder(instanceConfig)
                    .with(applicationInfoManager)
                    .with(eurekaClient)
                    .with(healthCheckHandler)
                    .build();
        }
    }
    ...省略...
//健康指示器，用来管理服务的健康状况@Configuration@ConditionalOnClass(Health.class)
protectedstaticclassEurekaHealthIndicatorConfiguration {
@Bean@ConditionalOnMissingBean@ConditionalOnEnabledHealthIndicator("eureka")
publicEurekaHealthIndicatoreurekaHealthIndicator(EurekaClienteurekaClient,
EurekaInstanceConfiginstanceConfig, EurekaClientConfigclientConfig) {
returnnewEurekaHealthIndicator(eurekaClient, instanceConfig, clientConfig);
        }
    }

总结一下：这里注册了很多对象比较重要的有：

1.EurekaClientConfigBean ：这个类实现了netflix 的 EurekaClientConfig客户端配置接口，是对Eureka客户端的配置对象，即我们在配置文件中配置的 eureka.client 节点下的配置都会被封装到该对象中。

2.EurekaInstanceConfigBean: 该类实现了netflix的EurekaInstanceConfig接口，是的服务实例信息配置，ApplicationManager通过该接口用来构建InstanceConfig,比如我们在配置文件中配置的eureka.instance 开头的配置就会配置到该对象中。

3.DiscoveryClient：注册了DiscoveryClient服务发现客户端接口，默认实现是EurekaDiscoveryClient。这个类来源于spring-cloud-common.2.0.1.jar 这个包，这个包是springcloud的抽象包的公共包里面制定了一系列公共的API，而DiscoveryClient中包含了服务发现的基本公共方法

4.配置了一些客户端自动注册组件

  • EurekaServiceRegistry： Eureak服务注册器，他是SpringCloud 在Netflix标准上拓展出来的，提供了服务注册，取消注册, 关闭服务，设置服务状态，获取服务状态方法
  • EurekaRegistration： 它是Eureka实例的服务注册信息对象,开启自动注册时，该对象才会被注册，EurekaServiceRegistry负责服务注册，EurekaRegistration存放服务注册信息
  • EurekaAutoServiceRegistration： Eureka服务自动注册器，用来注册EurekaRegistration信息

5.EurekaClient：这里通过CloudEurekaClient来实例化，他是用来和EureakServer进行交互，是netflix提供的接口类，它还有个比较重要的实现 DiscoveryClient 主要负责服务发现，这个是与注册中心EureakServer交互的最核心的实现，包括服务注册，注册表拉取，服务续约等等功能都在里面提现。需要注意的是该Bean在注册的时候使用了@Lazy进行延迟创建

6.ApplicationInfoManager：这个类是用来管理实例注册信息InstanceInfo的，其中还包括了对实例状的态监听机制

7.EurekaHealthIndicator：这个是用作服务的健康检查的，以及提供了获取服务状态，以及获取Applications服务注册表等方法

2.EurekaAutoServiceRegistration:Eureaka自动注册

在spring-cloud-commons-2.0.1.RELEASE.jar SpringCloud公共包中/META-INF/spring.factories配置文件中有AutoServiceRegistrationAutoConfiguration自动配置类，当应用启动SpringBoot会扫描到该自动配置类，然后注册到Spring容器

#AutoConfigurationorg.springframework.boot.autoconfigure.EnableAutoConfiguration=\org.springframework.cloud.client.serviceregistry.ServiceRegistryAutoConfiguration,\org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration

ServiceRegistryAutoConfiguration是配置注册的服务的端点信息，可通过端点 “/service-registry”查看到服务注册情况

@ConfigurationpublicclassServiceRegistryAutoConfiguration {
@ConditionalOnBean(ServiceRegistry.class)
@ConditionalOnClass(Endpoint.class)
protectedclassServiceRegistryEndpointConfiguration {
@Autowired(required=false)
privateRegistrationregistration;
@Bean@ConditionalOnEnabledEndpointpublicServiceRegistryEndpointserviceRegistryEndpoint(ServiceRegistryserviceRegistry) {
ServiceRegistryEndpointendpoint=newServiceRegistryEndpoint(serviceRegistry);
endpoint.setRegistration(registration);
returnendpoint;
        }
    }
}
------------------------------------------------------------------------//查看注册服务端点@Endpoint(id="service-registry")
publicclassServiceRegistryEndpoint {
privatefinalServiceRegistryserviceRegistry;
privateRegistrationregistration;
publicServiceRegistryEndpoint(ServiceRegistry<?>serviceRegistry) {
this.serviceRegistry=serviceRegistry;
    }
publicvoidsetRegistration(Registrationregistration) {
this.registration=registration;
    }
@WriteOperationpublicResponseEntity<?>setStatus(Stringstatus) {
Assert.notNull(status, "status may not by null");
if (this.registration==null) {
returnResponseEntity.status(HttpStatus.NOT_FOUND).body("no registration found");
        }
this.serviceRegistry.setStatus(this.registration, status);
returnResponseEntity.ok().build();
    }
//获取服务状态@ReadOperationpublicResponseEntitygetStatus() {
if (this.registration==null) {
returnResponseEntity.status(HttpStatus.NOT_FOUND).body("no registration found");
        }
returnResponseEntity.ok().body(this.serviceRegistry.getStatus(this.registration));
    }
}

AutoServiceRegistrationAutoConfiguration是开启服务自动注册其中注入了AutoServiceRegistration确保该类会被注册，源码如下

@Configuration@Import(AutoServiceRegistrationConfiguration.class)
@ConditionalOnProperty(value="spring.cloud.service-registry.auto-registration.enabled", matchIfMissing=true)
publicclassAutoServiceRegistrationAutoConfiguration {
@Autowired(required=false)
privateAutoServiceRegistrationautoServiceRegistration;
@AutowiredprivateAutoServiceRegistrationPropertiesproperties;
@PostConstructprotectedvoidinit() {
if (autoServiceRegistration==null&&this.properties.isFailFast()) {
thrownewIllegalStateException("Auto Service Registration has been requested, but there is no AutoServiceRegistration bean");
        }
    }
}

EurekaAutoServiceRegistration是Eureka的自动注册器，在EurekaClientAutoConfiguration中对EurekaAutoServiceRegistration做了Bean的定义，当开启spring.cloud.service-registry.auto-registration.enabled=true(默认)该Bean注册起效 ， 它是 AutoServiceRegistration的实现

EurekaAutoServiceRegistration 源码如下：

//自动注册器publicclassEurekaAutoServiceRegistrationimplementsAutoServiceRegistration, SmartLifecycle, Ordered {
privatestaticfinalLoglog=LogFactory.getLog(EurekaAutoServiceRegistration.class);
privateAtomicBooleanrunning=newAtomicBoolean(false);
privateintorder=0;
privateAtomicIntegerport=newAtomicInteger(0);
privateApplicationContextcontext;
//服务注册器privateEurekaServiceRegistryserviceRegistry;
//服务注册信息登记privateEurekaRegistrationregistration;
publicEurekaAutoServiceRegistration(ApplicationContextcontext, EurekaServiceRegistryserviceRegistry, EurekaRegistrationregistration) {
this.context=context;
this.serviceRegistry=serviceRegistry;
this.registration=registration;
    }
//开启服务注册@Overridepublicvoidstart() {
// only set the port if the nonSecurePort or securePort is 0 and this.port != 0if (this.port.get() !=0) {
if (this.registration.getNonSecurePort() ==0) {
this.registration.setNonSecurePort(this.port.get());
            }
if (this.registration.getSecurePort() ==0&&this.registration.isSecure()) {
this.registration.setSecurePort(this.port.get());
            }
        }
// only initialize if nonSecurePort is greater than 0 and it isn't already running// because of containerPortInitializer belowif (!this.running.get() &&this.registration.getNonSecurePort() >0) {
//调用服务注册器进行服务注册this.serviceRegistry.register(this.registration);
//发布一个服务注册事件this.context.publishEvent(
newInstanceRegisteredEvent<>(this, this.registration.getInstanceConfig()));
this.running.set(true);
        }
    }
@Overridepublicvoidstop() {
//服务停止，取消服务注册this.serviceRegistry.deregister(this.registration);
this.running.set(false);
    }
@OverridepublicbooleanisRunning() {
//获取服务状态是否运行returnthis.running.get();
    }
@OverridepublicintgetPhase() {
return0;
    }
@OverridepublicbooleanisAutoStartup() {
returntrue;
    }
//停止服务@Overridepublicvoidstop(Runnablecallback) {
stop();
callback.run();
    }
@OverridepublicintgetOrder() {
returnthis.order;
    }
//监听web启动完成事件，执行start()方法开启服务注册@EventListener(WebServerInitializedEvent.class)
publicvoidonApplicationEvent(WebServerInitializedEventevent) {
// TODO: take SSL into accountintlocalPort=event.getWebServer().getPort();
if (this.port.get() ==0) {
log.info("Updating port to "+localPort);
this.port.compareAndSet(0, localPort);
start();
        }
    }
//监听应用关闭事件，执行stop()方法@EventListener(ContextClosedEvent.class)
publicvoidonApplicationEvent(ContextClosedEventevent) {
if( event.getApplicationContext() ==context ) {
stop();
        }
    }
}

EurekaAutoServiceRegistration监听了应用启动事件，调用EurekaServiceRegistry.register进行服务注册，同时监听应用关闭事件，调用EurekaServiceRegistry.deregister取消服务注册

3.EurekaServiceRegistry:服务注册器

EurekaServiceRegistry是Eureak服务注册器，他是SpringCloud 在Netflix标准ServiceRegistry上拓展出来的，提供了服务注册，取消注册, 关闭服务，设置服务状态，获取服务状态方法

ServiceRegistry是EureakaServiceRegistry的接口，他是Netflix的服务发现抽象，ServiceRegistry需要依赖EurekaRegistration,EurekaRegistration是ServiceInstance的实现它约定了服务发现的实例应用的通用的信息

在应用启动时，EurekaAutoServiceRegistration会监听应用启动完成事件，在start()方法中调用，EureakaServiceRegistry.register方法开始服务注册，源码如下

//服务注册publicclassEurekaServiceRegistryimplementsServiceRegistry<EurekaRegistration> {
privatestaticfinalLoglog=LogFactory.getLog(EurekaServiceRegistry.class);
//注册方法，注册EurekaRegistration@Overridepublicvoidregister(EurekaRegistrationreg) {
//初始化客户端，该方法会触发 EurekaClient 的创建maybeInitializeClient(reg);
if (log.isInfoEnabled()) {
log.info("Registering application "+reg.getInstanceConfig().getAppname()
+" with eureka with status "+reg.getInstanceConfig().getInitialStatus());
        }
//初始化客户端状态,把InstanceStatus设置为 InstanceStatus.UP;reg.getApplicationInfoManager()
                .setInstanceStatus(reg.getInstanceConfig().getInitialStatus());
//注册健康检查处理器reg.getHealthCheckHandler().ifAvailable(healthCheckHandler->reg.getEurekaClient().registerHealthCheck(healthCheckHandler));
    }
//初始化客户端，reg.getEurekaClient()会触发EureakClient(DiscoveryClient)的初始化privatevoidmaybeInitializeClient(EurekaRegistrationreg) {
// force initialization of possibly scoped proxiesreg.getApplicationInfoManager().getInfo();
//初始化Eurak客户端reg.getEurekaClient().getApplications();
    }
//取消注册，设置服务状态为down@Overridepublicvoidderegister(EurekaRegistrationreg) {
if (reg.getApplicationInfoManager().getInfo() !=null) {
if (log.isInfoEnabled()) {
log.info("Unregistering application "+reg.getInstanceConfig().getAppname()
+" with eureka with status DOWN");
            }
reg.getApplicationInfoManager().setInstanceStatus(InstanceInfo.InstanceStatus.DOWN);
//shutdown of eureka client should happen with EurekaRegistration.close()//auto registration will create a bean which will be properly disposed//manual registrations will need to call close()        }
    }
//设置服务注册状态@OverridepublicvoidsetStatus(EurekaRegistrationregistration, Stringstatus) {
InstanceInfoinfo=registration.getApplicationInfoManager().getInfo();
//TODO: howto deal with delete properly?if ("CANCEL_OVERRIDE".equalsIgnoreCase(status)) {
registration.getEurekaClient().cancelOverrideStatus(info);
return;
        }
//TODO: howto deal with status types across discovery systems?InstanceInfo.InstanceStatusnewStatus=InstanceInfo.InstanceStatus.toEnum(status);
registration.getEurekaClient().setStatus(newStatus, info);
    }
//获取服务注册状态@OverridepublicObjectgetStatus(EurekaRegistrationregistration) {
Stringappname=registration.getInstanceConfig().getAppname();
StringinstanceId=registration.getInstanceConfig().getInstanceId();
InstanceInfoinfo=registration.getEurekaClient().getInstanceInfo(appname, instanceId);
HashMap<String, Object>status=newHashMap<>();
if (info!=null) {
status.put("status", info.getStatus().toString());
status.put("overriddenStatus", info.getOverriddenStatus().toString());
        } else {
status.put("status", UNKNOWN.toString());
        }
returnstatus;
    }
publicvoidclose() {
    }
}

EurekaServiceRegistry中register方法初始化了Eureka客户端，以及注册了健康检查处理器，在private void maybeInitializeClient(EurekaRegistration reg)方法中reg.getEurekaClient().getApplications();会触发在EurekaClientAutoConfiguration自动配置中对EureakClient的延迟创建，使用的EurekaClient的实现com.netflix.discovery.DiscoveryClient

4.DiscoveryClient:服务发现

这个类来源于 eureka-client-19.3.jar这个包 ，DiscoveryClient这个类是用来和Eureak Server服务端做交互，通过程序的主入口类上的@EnableDiscoveryClient标签开启,该类在EurekaClientAutoConfiguration中被注册，该类的继承关系如下：

CloudEurekaClient实现了 com.netflix.discovery.DiscoveryClient接口，DiscoveryClient实现了com.netflix.discovery.EurekaClient接口，

EurekaClient是Netflix提供的服务发现抽象的接口，DiscoveryClient是其默认实现，CloudEurekaClient是spring cloud的提供的，其中重写了onCacheRefreshed()方法，目的是在刷新本地注册表缓存之后用于使用ApplicationEventPublisher发布HeartbeatEvent事件。

com.netflix.discovery.shared.LookupService ：

服务发现顶级接口，里面包含了服务查找方法

/*** Lookup service for finding active instances.* 用来查找活动的服务实例*/publicinterfaceLookupService<T> {
/**根据应用名获取该名字对应的应用，Application中描述了该appName对应的多个应用实例*/ApplicationgetApplication(StringappName);
/**获取所有的应用注册列表，Applications是eureka server返回的所有注册信息*/ApplicationsgetApplications();
/**根据ID获取服务实例信息信息对象列表*/List<InstanceInfo>getInstancesById(Stringid);
InstanceInfogetNextServerFromEureka(StringvirtualHostname, booleansecure);
}

com.netflix.discovery.EurekaClient

这里接口也来源于com.netflix.discovery.EurekaClient.1.9.3.jar这个包，EurekaClient是DiscoverClient的接口，定义了服务发现的基本功能，如下：

  • 提供获取InstanceInfo 服务实例信息的功能（以不同的方式）
  • 提供获取本地服务数据（已知地区、自有AZ等）
  • 提供注册和访问客户端的healthcheck健康检查处理程序的能力

他的源码如下

/**为当前服务实现DiscoveryClient定义一个简单的接口* Define a simple interface over the current DiscoveryClient implementation.** This interface does NOT try to clean up the current client interface for eureka 1.x. Rather it tries* to provide an easier transition path from eureka 1.x to eureka 2.x.EurekaClient API合同包括：- 提供获取InstanceInfo 服务实例信息的功能（以不同的方式）- 提供获取本地客户数据的能力（已知地区、自有AZ等）- 提供注册和访问客户端的healthcheck处理程序的能力* EurekaClient API contracts are:*  - provide the ability to get InstanceInfo(s) (in various different ways)*  - provide the ability to get data about the local Client (known regions, own AZ etc)*  - provide the ability to register and access the healthcheck handler for the client** @author David Liu*/@ImplementedBy(DiscoveryClient.class)   //实现于DiscoveryClientpublicinterfaceEurekaClientextendsLookupService {
// ========================// getters for InstanceInfo// ========================/**根据region地区获取服务列表Applications*/publicApplicationsgetApplicationsForARegion(@NullableStringregion);
/**根据服务注册地址，返回Applications*/publicApplicationsgetApplications(StringserviceUrl);
/**根据地址获取服务实例信息列表*/publicList<InstanceInfo>getInstancesByVipAddress(StringvipAddress, booleansecure);
/** 获取服务的远程注册状态 ：InstanceStatus是用来描述服务注册状态的，状态有：UP，DOWN，STARTING，OUT_OF_SERVICE，UNKNOWN*/publicInstanceInfo.InstanceStatusgetInstanceRemoteStatus();
    ...省略一些方法..
/**注册健康检查回调处理器*/@DeprecatedpublicvoidregisterHealthCheckCallback(HealthCheckCallbackcallback);
/**注册健康检查处理器*/publicvoidregisterHealthCheck(HealthCheckHandlerhealthCheckHandler);
    ...省略...
//注册eureak监听器，监听eureka内部状态变化publicvoidregisterEventListener(EurekaEventListenereventListener);
/**Eureak客户端down机，从Eureak服务端取消服务注册*/publicvoidshutdown();
    ...省略...

该接口是Eureak服务发现接口，在LookupService的基础上扩展，主要定义方法有：

  • 获取Applications服务列表
  • 获取InstanceInfo服务实例信息
  • 获取服务的远程状态（UP，DOWN，STARTING，OUT_OF_SERVICE，UNKNOWN）
  • 注册健康检查回调处理器
  • 注册健康检查处理器
  • 注册eureka状态监听器，监听eureka的状态变化
  • Eureak客户端down机，从Eureak服务端取消服务注册

com.netflix.discovery.DiscoveryClient

服务发现核心实现与Eureka Server交互，功能包括：

  • Eureka客户端负责向Eureka服务器注册实例
  • 与Eureak服务器续租
  • 关闭期间,从Eureka服务器取消租约
  • 查询在Eureka服务器上注册的服务/实例列表

5.总结

这里总结一个Eureak的启动流程

  1. 当程序启动,SpringBoot开启自动配置，EurekaClientAutoConfiguration Eureka客户端自动配置,和EurekaAutoServiceRegistration Eureka自动注册启动
  2. EurekaClientAutoConfiguration进行一些列组件的注册，包括对DiscoverClient服务发现客户端的组合，对EurekaServiceRegistry服务注册器的注册
  3. EurekaAutoServiceRegistration监听Web程序启动，调用EurekaServiceRegistry进行服务注册
  4. EurekaServiceRegistry是服务注册器，提供了服务注册，取消注册等方法，其中对DiscoverClient进行初始化，并注册健康检查处理器
  5. 5.DiscoveryClient服务发现客户端，负责与Eureka服务端进行交互


文章标签：
Java
容器
Spring
API
缓存
关键词：
springcloud eureka
springcloud client
springcloud源码
springcloud源码剖析
springcloud eureka初始化
Heron
目录
相关文章
qhhf_地道酬勤
|
16天前
|
负载均衡 监控 Java
SpringCloud常见面试题（一）：SpringCloud 5大组件，服务注册和发现，nacos与eureka区别，服务雪崩、服务熔断、服务降级，微服务监控
SpringCloud常见面试题（一）：SpringCloud 5大组件，服务注册和发现，nacos与eureka区别，服务雪崩、服务熔断、服务降级，微服务监控
qhhf_地道酬勤
247 5
SpringCloud常见面试题（一）：SpringCloud 5大组件，服务注册和发现，nacos与eureka区别，服务雪崩、服务熔断、服务降级，微服务监控
ktee5tyrczvty
|
4天前
|
缓存 Java Maven
SpringCloud基于Eureka的服务治理架构搭建与测试：从服务提供者到消费者的完整流程
Spring Cloud微服务框架中的Eureka是一个用于服务发现和注册的基础组件，它基于RESTful风格，为微服务架构提供了关键的服务注册与发现功能。以下是对Eureka的详细解析和搭建举例。
ktee5tyrczvty
21 0
weixin_836869520
|
1月前
|
Java API 开发工具
Spring Boot与Spring Cloud Config的集成
Spring Boot与Spring Cloud Config的集成
weixin_836869520
102 2
不吃核桃
|
28天前
|
监控 NoSQL Java
通用快照方案问题之Martin Flower提出的微服务之间的通信如何解决
通用快照方案问题之Martin Flower提出的微服务之间的通信如何解决
不吃核桃
32 0
公众号:码到三十五
|
2月前
|
Java API 数据格式
Spring三兄弟：Spring、Spring Boot、Spring Cloud的100个常用注解大盘点
Spring三兄弟：Spring、Spring Boot、Spring Cloud的100个常用注解大盘点
公众号:码到三十五
50 1
泥腿子架构师
|
1月前
|
Java API 网络架构
Spring Boot与Spring Cloud Gateway的集成
Spring Boot与Spring Cloud Gateway的集成
泥腿子架构师
57 0
聚娃科技开发者团队
|
1月前
|
负载均衡 监控 Java
深入理解Spring Boot与Spring Cloud的整合方式
深入理解Spring Boot与Spring Cloud的整合方式
聚娃科技开发者团队
37 0
不会编程的小孩子
|
2月前
|
Java Maven 微服务
Spring Cloud Netflix 之 Eureka
Spring Cloud Netflix Eureka是服务发现组件，由Netflix开发，Spring Cloud集成为微服务治理工具。Eureka采用客户端/服务器架构，包含Eureka Server（服务注册中心）和Eureka Client（服务提供者和服务消费者）。服务提供者注册到Eureka Server，服务消费者通过它查找并调用服务。
不会编程的小孩子
19 0
米诺斯
|
2月前
|
微服务
springCloud之服务注册与发现Eureka
springCloud之服务注册与发现Eureka
米诺斯
14 0
热爱技术的小郑
|
2天前
|
Java 微服务 Spring
SpringBoot+Vue+Spring Cloud Alibaba 实现大型电商系统【分布式微服务实现】
文章介绍了如何利用Spring Cloud Alibaba快速构建大型电商系统的分布式微服务，包括服务限流降级等主要功能的实现，并通过注解和配置简化了Spring Cloud应用的接入和搭建过程。
热爱技术的小郑
16 0
SpringBoot+Vue+Spring Cloud Alibaba 实现大型电商系统【分布式微服务实现】

热门文章

最新文章

  • 1
    SpringCloud Alibaba - Nacos 作为配置中心 & 读取Yaml配置信息
  • 2
    第十四章：SpringCloud 依赖Git仓库实现配置对称加密
  • 3
    F版本SpringCloud 2—什么是SpringCloud？SpringCloud版本选择
  • 4
    Kubernetes + Spring Cloud 集成链路追踪 SkyWalking
  • 5
    整合spring cloud云架构 --spring cloud分布式系统中实现分布式锁
  • 6
    Spring Cloud Alibaba Nacos配置导入问题解决方案
  • 7
    SpringCloud之Hystrix服务降级入门全攻略
  • 8
    【SpringCloud微服务实战】搭建企业级应用开发框架（一）：架构说明
  • 9
    SpringCloud微服务实战——搭建企业级开发框架（四十）：使用Spring Security OAuth2实现单点登录(SSO)系统
  • 10
    SpringCloud（Gateway 网关负载均衡） | 学习笔记
  • 1
    Springboot框架整合Spring JDBC操作数据
    43
  • 2
    Springboot框架整合Spring Data JPA操作数据
    45
  • 3
    Spring事务与分布式事务
    39
  • 4
    Spring Boot单元测试报错java.lang.IllegalStateException: Could not load TestContextBootstrapper [null]
    80
  • 5
    Spring Cloud Feign 使用Apache的HTTP Client替换Feign原生httpclient
    154
  • 6
    如何在Spring框架中实现横切关注点的集中管理和重用？
    32
  • 7
    在Spring框架中，IoC和AOP是如何实现的？
    50
  • 8
    Spring IoC容器通过依赖注入机制实现控制反转
    41
  • 9
    在Spring Bean中，如何通过Java配置类定义Bean?
    45
  • 10
    【初学者慎入】Spring源码中的16种设计模式实现
    121

    • 相关课程

    更多
  • 微服务+全栈在线教育实战项目演练（SpringCloud Alibaba+SpringBoot）
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • Spring Cloud 微服务核心组件集 mica 的设计思路
  • workshop专场-微服务专场-开发者动手实践营-微服务-Spring Cloud Alibaba 微服务全家桶体验
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧

    • 相关实验场景

    更多
  • 快速上手使用Dubbo进行远程调用
  • Spring-cloud-stream-binder-rocketmq入门与实践
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    【案例实战】SpringBoot整合阿里云文件上传OSS