Eureka Client源码分析(1)-注册服务

最新推荐文章于 2023-08-26 08:42:23 发布
最新推荐文章于 2023-08-26 08:42:23 发布
阅读量133 收藏
点赞数
分类专栏： Eureka SpringCloud 文章标签： Eureka SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rzpy_qifengxiaoyue/article/details/108191049
版权

前面的文章分析了Eureka Server,是基于SpringBoot自动装配实现的，Eureka Client同样如此，查看spring-cloud-netflix-eureka-client- 2.1.0.RELEASE.jar下的文件结构，如下
在这里插入图片描述
点开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

org.springframework.cloud.bootstrap.BootstrapConfiguration=\
org.springframework.cloud.netflix.eureka.config.EurekaDiscoveryClientConfigServiceBootstrapConfiguration

可以看出Eureka客户端在启动时会装载很多配置类，下面重点关注EurekaClientAutoConfiguration

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
@ConditionalOnClass(EurekaClientConfig.class)
@ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true)
@ConditionalOnDiscoveryEnabled
@AutoConfigureBefore({ NoopDiscoveryClientAutoConfiguration.class,
		CommonsClientAutoConfiguration.class, ServiceRegistryAutoConfiguration.class })
//必须先装配完成下面的类才能加载当前类
@AutoConfigureAfter(name = {
		"org.springframework.cloud.netflix.eureka.config.DiscoveryClientOptionalArgsConfiguration",
		"org.springframework.cloud.autoconfigure.RefreshAutoConfiguration",
		"org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration",
		"org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration" })
public class EurekaClientAutoConfiguration {

从上面可以看出装配EurekaClientAutoConfiguration之前，必须先装配一些其他的配置类，另外如果不想作为客户端，可以设置eureka.client.enabled=false，我们先关注EurekaDiscoveryClientConfiguration

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
@ConditionalOnClass(EurekaClientConfig.class)
//如果项目中引入了EurekaClient相关的jar,但是不想成为客户端，可以配置eureka.client.enabled=false
@ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true)
@ConditionalOnDiscoveryEnabled
@ConditionalOnBlockingDiscoveryEnabled
public class EurekaDiscoveryClientConfiguration {

这个类没做多少东西，回到主配置类EurekaClientAutoConfiguration
思考:EurekaClient启动过程要做什么事情?

  1. 读取配置文件
  2. 启动时从EurekaServer获取服务实例信息
  3. 注册自己到EurekaServer(addInstance)
  4. 开启一些定时任务(心跳续约，刷新本地服务缓存列表)
  • 读取配置文件
//读取封装配置信息注入容器
@Bean
@ConditionalOnMissingBean(value = EurekaInstanceConfig.class,
		search = SearchStrategy.CURRENT)
public EurekaInstanceConfigBean eurekaInstanceConfigBean(InetUtils inetUtils,
		ManagementMetadataProvider managementMetadataProvider) {
	String hostname = getProperty("eureka.instance.hostname");
	boolean preferIpAddress = Boolean
			.parseBoolean(getProperty("eureka.instance.prefer-ip-address"));
	String ipAddress = getProperty("eureka.instance.ip-address");
	boolean isSecurePortEnabled = Boolean
			.parseBoolean(getProperty("eureka.instance.secure-port-enabled"));

	String serverContextPath = env.getProperty("server.servlet.context-path", "/");
	int serverPort = Integer.parseInt(
			env.getProperty("server.port", env.getProperty("port", "8080")));

	Integer managementPort = env.getProperty("management.server.port", Integer.class);
	String managementContextPath = env
			.getProperty("management.server.servlet.context-path");
	Integer jmxPort = env.getProperty("com.sun.management.jmxremote.port",
			Integer.class);
	EurekaInstanceConfigBean instance = new EurekaInstanceConfigBean(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);
	}
	String statusPageUrlPath = getProperty("eureka.instance.status-page-url-path");
	String healthCheckUrlPath = getProperty("eureka.instance.health-check-url-path");

	if (StringUtils.hasText(statusPageUrlPath)) {
		instance.setStatusPageUrlPath(statusPageUrlPath);
	}
	if (StringUtils.hasText(healthCheckUrlPath)) {
		instance.setHealthCheckUrlPath(healthCheckUrlPath);
	}

	ManagementMetadata metadata = 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();
		metadataMap.computeIfAbsent("management.port",
				k -> 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 here
		if (StringUtils.hasText(managementContextPath)) {
			instance.setHealthCheckUrlPath(
					managementContextPath + instance.getHealthCheckUrlPath());
			instance.setStatusPageUrlPath(
					managementContextPath + instance.getStatusPageUrlPath());
		}
	}

	setupJmxPort(instance, jmxPort);
	return instance;
}
  • 启动时从EurekaServer获取服务实例信息
//实例化EurekaClient，返回CloudEurekaClient
@Bean(destroyMethod = "shutdown")
@ConditionalOnMissingBean(value = EurekaClient.class,
		search = SearchStrategy.CURRENT)
public EurekaClient eurekaClient(ApplicationInfoManager manager,
		EurekaClientConfig config) {
	return new CloudEurekaClient(manager, config, this.optionalArgs,
			this.context);
}

服务下架，服务死掉的时候就会调用shutdown方法

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);
}

public DiscoveryClient(ApplicationInfoManager applicationInfoManager, final EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args) {
        this(applicationInfoManager, config, args, ResolverUtils::randomize);
    }

    public DiscoveryClient(ApplicationInfoManager applicationInfoManager, final EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args, EndpointRandomizer randomizer) {
        this(applicationInfoManager, config, args, new Provider<BackupRegistry>() {
            private volatile BackupRegistry backupRegistryInstance;

            @Override
            public synchronized BackupRegistry get() {
                if (backupRegistryInstance == null) {
                    String backupRegistryClassName = config.getBackupRegistryImpl();
                    if (null != backupRegistryClassName) {
                        try {
                            backupRegistryInstance = (BackupRegistry) Class.forName(backupRegistryClassName).newInstance();
                            logger.info("Enabled backup registry of type {}", backupRegistryInstance.getClass());
                        } catch (InstantiationException e) {
                            logger.error("Error instantiating BackupRegistry.", e);
                        } catch (IllegalAccessException e) {
                            logger.error("Error instantiating BackupRegistry.", e);
                        } catch (ClassNotFoundException e) {
                            logger.error("Error instantiating BackupRegistry.", e);
                        }
                    }

                    if (backupRegistryInstance == null) {
                        logger.warn("Using default backup registry implementation which does not do anything.");
                        backupRegistryInstance = new NotImplementedRegistryImpl();
                    }
                }

                return backupRegistryInstance;
            }
        }, randomizer);
    }

下面的构造方法做了很多事情，如下

@Inject
    DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
                    Provider<BackupRegistry> backupRegistryProvider, EndpointRandomizer endpointRandomizer) {
        if (args != null) {
            this.healthCheckHandlerProvider = args.healthCheckHandlerProvider;
            this.healthCheckCallbackProvider = args.healthCheckCallbackProvider;
            this.eventListeners.addAll(args.getEventListeners());
            this.preRegistrationHandler = args.preRegistrationHandler;
        } else {
            this.healthCheckCallbackProvider = null;
            this.healthCheckHandlerProvider = null;
            this.preRegistrationHandler = null;
        }
        
        this.applicationInfoManager = applicationInfoManager;
        InstanceInfo myInfo = applicationInfoManager.getInfo();

        clientConfig = config;
        staticClientConfig = clientConfig;
        transportConfig = config.getTransportConfig();
        instanceInfo = myInfo;
        if (myInfo != null) {
            appPathIdentifier = instanceInfo.getAppName() + "/" + instanceInfo.getId();
        } else {
            logger.warn("Setting instanceInfo to a passed in null value");
        }

        this.backupRegistryProvider = backupRegistryProvider;
        this.endpointRandomizer = endpointRandomizer;
        this.urlRandomizer = new EndpointUtils.InstanceInfoBasedUrlRandomizer(instanceInfo);
        localRegionApps.set(new Applications());

        fetchRegistryGeneration = new AtomicLong(0);

        remoteRegionsToFetch = new AtomicReference<String>(clientConfig.fetchRegistryForRemoteRegions());
        remoteRegionsRef = new AtomicReference<>(remoteRegionsToFetch.get() == null ? null : remoteRegionsToFetch.get().split(","));

        //根据是否需要获取注册信息，设置不同的监控统计对象
        if (config.shouldFetchRegistry()) {
            this.registryStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRY_PREFIX + "lastUpdateSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
        } else {
            this.registryStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
        }
        //根据是否需要向注册中心注册自己，设置不同的监控统计对象
        if (config.shouldRegisterWithEureka()) {
            this.heartbeatStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRATION_PREFIX + "lastHeartbeatSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
        } else {
            this.heartbeatStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
        }

        logger.info("Initializing Eureka in region {}", clientConfig.getRegion());

        //既不需要获取注册信息也不需要向注册中心注册自己
        if (!config.shouldRegisterWithEureka() && !config.shouldFetchRegistry()) {
            logger.info("Client configured to neither register nor query for data.");
            scheduler = null;
            heartbeatExecutor = null;
            cacheRefreshExecutor = null;
            eurekaTransport = null;
            instanceRegionChecker = new InstanceRegionChecker(new PropertyBasedAzToRegionMapper(config), clientConfig.getRegion());

            // This is a bit of hack to allow for existing code using DiscoveryManager.getInstance()
            // to work with DI'd DiscoveryClient
            DiscoveryManager.getInstance().setDiscoveryClient(this);
            DiscoveryManager.getInstance().setEurekaClientConfig(config);

            initTimestampMs = System.currentTimeMillis();
            initRegistrySize = this.getApplications().size();
            registrySize = initRegistrySize;
            logger.info("Discovery Client initialized at timestamp {} with initial instances count: {}",
                    initTimestampMs, initRegistrySize);

            return;  // no need to setup up an network tasks and we are done
        }

        try {
            //设置心跳续约和刷新本地缓存的线程池
            // default size of 2 - 1 each for heartbeat and cacheRefresh
            scheduler = Executors.newScheduledThreadPool(2,
                    new ThreadFactoryBuilder()
                            .setNameFormat("DiscoveryClient-%d")
                            .setDaemon(true)
                            .build());
            
            //心跳续约线程池
            heartbeatExecutor = new ThreadPoolExecutor(
                    1, clientConfig.getHeartbeatExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
                    new SynchronousQueue<Runnable>(),
                    new ThreadFactoryBuilder()
                            .setNameFormat("DiscoveryClient-HeartbeatExecutor-%d")
                            .setDaemon(true)
                            .build()
            );  // use direct handoff
            //刷新本地缓存的线程池
            cacheRefreshExecutor = new ThreadPoolExecutor(
                    1, clientConfig.getCacheRefreshExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
                    new SynchronousQueue<Runnable>(),
                    new ThreadFactoryBuilder()
                            .setNameFormat("DiscoveryClient-CacheRefreshExecutor-%d")
                            .setDaemon(true)
                            .build()
            );  // use direct handoff

            eurekaTransport = new EurekaTransport();
            scheduleServerEndpointTask(eurekaTransport, args);

            AzToRegionMapper azToRegionMapper;
            if (clientConfig.shouldUseDnsForFetchingServiceUrls()) {
                azToRegionMapper = new DNSBasedAzToRegionMapper(clientConfig);
            } else {
                azToRegionMapper = new PropertyBasedAzToRegionMapper(clientConfig);
            }
            if (null != remoteRegionsToFetch.get()) {
                azToRegionMapper.setRegionsToFetch(remoteRegionsToFetch.get().split(","));
            }
            instanceRegionChecker = new InstanceRegionChecker(azToRegionMapper, clientConfig.getRegion());
        } catch (Throwable e) {
            throw new RuntimeException("Failed to initialize DiscoveryClient!", e);
        }
        
        //如果需要获取注册信息，从注册中心获取信息列表
        if (clientConfig.shouldFetchRegistry()) {
            try {
                boolean primaryFetchRegistryResult = fetchRegistry(false);
                if (!primaryFetchRegistryResult) {
                    logger.info("Initial registry fetch from primary servers failed");
                }
                boolean backupFetchRegistryResult = true;
                if (!primaryFetchRegistryResult && !fetchRegistryFromBackup()) {
                    backupFetchRegistryResult = false;
                    logger.info("Initial registry fetch from backup servers failed");
                }
                if (!primaryFetchRegistryResult && !backupFetchRegistryResult && clientConfig.shouldEnforceFetchRegistryAtInit()) {
                    throw new IllegalStateException("Fetch registry error at startup. Initial fetch failed.");
                }
            } catch (Throwable th) {
                logger.error("Fetch registry error at startup: {}", th.getMessage());
                throw new IllegalStateException(th);
            }
        }

        // call and execute the pre registration handler before all background tasks (inc registration) is started
        if (this.preRegistrationHandler != null) {
            this.preRegistrationHandler.beforeRegistration();
        }
        //如果需要向注册中心注册自己，就注册自己
        if (clientConfig.shouldRegisterWithEureka() && clientConfig.shouldEnforceRegistrationAtInit()) {
            try {
                if (!register() ) {
                    throw new IllegalStateException("Registration error at startup. Invalid server response.");
                }
            } catch (Throwable th) {
                logger.error("Registration error at startup: {}", th.getMessage());
                throw new IllegalStateException(th);
            }
        }

        // finally, init the schedule tasks (e.g. cluster resolvers, heartbeat, instanceInfo replicator, fetch
        //初始化心跳续约和刷新本地缓存定时任务
        initScheduledTasks();

        try {
            Monitors.registerObject(this);
        } catch (Throwable e) {
            logger.warn("Cannot register timers", e);
        }

        // This is a bit of hack to allow for existing code using DiscoveryManager.getInstance()
        // to work with DI'd DiscoveryClient
        DiscoveryManager.getInstance().setDiscoveryClient(this);
        DiscoveryManager.getInstance().setEurekaClientConfig(config);

        initTimestampMs = System.currentTimeMillis();
        initRegistrySize = this.getApplications().size();
        registrySize = initRegistrySize;
        logger.info("Discovery Client initialized at timestamp {} with initial instances count: {}",
                initTimestampMs, initRegistrySize);
    }

从上面可以看出，主要做了一下几件事情

  1. 各种参数校验和属性设置
  2. 根据是否需要获取注册信息，设置不同的监控统计对象
  3. 根据是否需要向注册中心注册自己，设置不同的监控统计对象
  4. 设置心跳续约和刷新本地缓存的线程池
  5. 如果需要获取注册信息，从注册中心获取信息列表
  6. 如果需要向注册中心注册自己，就注册自己到注册中心
  7. 初始化心跳续约和刷新本地缓存定时任务

下面看一下获取注册信息方法

private boolean fetchRegistry(boolean forceFullRegistryFetch) {
    Stopwatch tracer = FETCH_REGISTRY_TIMER.start();

    try {
        // If the delta is disabled or if it is the first time, get all
        // applications
        //拿本地缓存
        Applications applications = getApplications();

        if (clientConfig.shouldDisableDelta()
                || (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
                || forceFullRegistryFetch
                || (applications == null)
                || (applications.getRegisteredApplications().size() == 0)
                || (applications.getVersion() == -1)) //Client application does not have latest library supporting delta
        {
            logger.info("Disable delta property : {}", clientConfig.shouldDisableDelta());
            logger.info("Single vip registry refresh property : {}", clientConfig.getRegistryRefreshSingleVipAddress());
            logger.info("Force full registry fetch : {}", forceFullRegistryFetch);
            logger.info("Application is null : {}", (applications == null));
            logger.info("Registered Applications size is zero : {}",
                    (applications.getRegisteredApplications().size() == 0));
            logger.info("Application version is -1: {}", (applications.getVersion() == -1));
            //全量获取注册信息
            getAndStoreFullRegistry();
        } else {
            //增量获取注册信息
            getAndUpdateDelta(applications);
        }
        applications.setAppsHashCode(applications.getReconcileHashCode());
        logTotalInstances();
    } catch (Throwable e) {
        logger.error(PREFIX + "{} - was unable to refresh its cache! status = {}", appPathIdentifier, e.getMessage(), e);
        return false;
    } finally {
        if (tracer != null) {
            tracer.stop();
        }
    }

    // Notify about cache refresh before updating the instance remote status
    //在更新实例远程状态之前通知有关缓存刷新的信息
    onCacheRefreshed();

    // Update remote status based on refreshed data held in the cache
    //根据缓存中保存的数据更新远程状态
    updateInstanceRemoteStatus();

    // registry was fetched successfully, so return true
    return true;
}
  • 注册自己到EurekaServer(addInstance)
/**
 * Register with the eureka service by making the appropriate REST call.
 * 通过进行适当的REST调用向eureka服务注册。
 */
boolean register() throws Throwable {
    logger.info(PREFIX + "{}: registering service...", appPathIdentifier);
    EurekaHttpResponse<Void> httpResponse;
    try {
        //向注册中心注册自己
        httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
    } catch (Exception e) {
        logger.warn(PREFIX + "{} - registration failed {}", appPathIdentifier, e.getMessage(), e);
        throw e;
    }
    if (logger.isInfoEnabled()) {
        logger.info(PREFIX + "{} - registration status: {}", appPathIdentifier, httpResponse.getStatusCode());
    }
    //返回注册成功状态码
    return httpResponse.getStatusCode() == Status.NO_CONTENT.getStatusCode();
}
  • 开启一些定时任务(心跳续约，刷新本地服务缓存列表)
private void initScheduledTasks() {
   //如果需要获取注册信息，才会有刷新本地缓存的定时任务
   if (clientConfig.shouldFetchRegistry()) {
       // registry cache refresh timer
       int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
       int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
       cacheRefreshTask = new TimedSupervisorTask(
               "cacheRefresh",
               scheduler,
               cacheRefreshExecutor,
               registryFetchIntervalSeconds,
               TimeUnit.SECONDS,
               expBackOffBound,
               new CacheRefreshThread()
       );
       scheduler.schedule(
               cacheRefreshTask,
               registryFetchIntervalSeconds, TimeUnit.SECONDS);
   }
   //如果向注册中心注册自己，才会有心跳续约定时任务
   if (clientConfig.shouldRegisterWithEureka()) {
       int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
       int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
       logger.info("Starting heartbeat executor: " + "renew interval is: {}", renewalIntervalInSecs);

       // Heartbeat timer
       heartbeatTask = new TimedSupervisorTask(
               "heartbeat",
               scheduler,
               heartbeatExecutor,
               renewalIntervalInSecs,
               TimeUnit.SECONDS,
               expBackOffBound,
               new HeartbeatThread()
       );
       scheduler.schedule(
               heartbeatTask,
               renewalIntervalInSecs, TimeUnit.SECONDS);

       // InstanceInfo replicator
       instanceInfoReplicator = new InstanceInfoReplicator(
               this,
               instanceInfo,
               clientConfig.getInstanceInfoReplicationIntervalSeconds(),
               2); // burstSize

       statusChangeListener = new ApplicationInfoManager.StatusChangeListener() {
           @Override
           public String getId() {
               return "statusChangeListener";
           }

           @Override
           public void notify(StatusChangeEvent statusChangeEvent) {
               if (InstanceStatus.DOWN == statusChangeEvent.getStatus() ||
                       InstanceStatus.DOWN == statusChangeEvent.getPreviousStatus()) {
                   // log at warn level if DOWN was involved
                   logger.warn("Saw local status change event {}", statusChangeEvent);
               } else {
                   logger.info("Saw local status change event {}", statusChangeEvent);
               }
               instanceInfoReplicator.onDemandUpdate();
           }
       };

       if (clientConfig.shouldOnDemandUpdateStatusChange()) {
           applicationInfoManager.registerStatusChangeListener(statusChangeListener);
       }

       instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
   } else {
       logger.info("Not registering with Eureka server per configuration");
   }
}

刷新本地缓存

class CacheRefreshThread implements Runnable {
    public void run() {
        refreshRegistry();
    }
}

心跳续约

private class HeartbeatThread implements Runnable {

    public void run() {
        if (renew()) {
       		 //心跳成功，修改对应时间戳
            lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
        }
    }
}

boolean renew() {
    EurekaHttpResponse<InstanceInfo> httpResponse;
    try {
        //向续约接口发送请求
        httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);
        logger.debug(PREFIX + "{} - Heartbeat status: {}", appPathIdentifier, httpResponse.getStatusCode());
        //找不到服务，可能代表当前实例已经被EurekaServer剔除
        if (httpResponse.getStatusCode() == Status.NOT_FOUND.getStatusCode()) {
            REREGISTER_COUNTER.increment();
            logger.info(PREFIX + "{} - Re-registering apps/{}", appPathIdentifier, instanceInfo.getAppName());
            long timestamp = instanceInfo.setIsDirtyWithTime();
            //如果被剔除了，重新注册自己
            boolean success = register();
            if (success) {
                instanceInfo.unsetIsDirty(timestamp);
            }
            return success;
        }
        return httpResponse.getStatusCode() == Status.OK.getStatusCode();
    } catch (Throwable e) {
        logger.error(PREFIX + "{} - was unable to send heartbeat!", appPathIdentifier, e);
        return false;
    }
}

到这里，客户端服务注册算是完成了。

四月丶丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
eureka配置
CherishL_的专栏
01-31 646
idea新建project File-&amp;gt;New-&amp;gt;Project,选择Spring Initializr，设置相关信息，next Eureka Server项目选择Eureka Server Eureka Client项目选择Eureka Discovery pom会自动配置相关依赖 Eureka Server配置: server: port: 8761 spring: s...
Eureka核心源码分析，包含注册，剔除，服务发现，续约的分析
12-30
下面我们将深入分析 Eureka 的核心源码，探讨服务注册、剔除、服务发现和续约的实现原理。 ### 服务注册 服务注册是 Eureka 工作的起点。客户端（Eureka Client）在启动时，会向 Eureka Server 注册自身的信息。这...
Eureka Client注册服务
小城我家
08-18 581
Eureka Client注册服务 动过程： Eureka客户端在启动时也会装载很多配置类，我们通过spring-cloud-netflix-eureka-client- xxxx.jar下的spring.factories⽂件可以看到加载的配置类 EurekaClientAutoConfiguration //标志为配置类，可以被Spring扫描与管理 @Configuration //启用配置属性 @EnableConfigurationProperties @ConditionalOnClass(
spring cloud：eureka源码之我见（四）服务注册源码剖析
weixin_41703510的博客
07-23 240
服务注册源码剖析 一、Eureka client端的服务注册 Eureka client的服务注册流程代码位于eureka client包下的InstanceInfoReplicator类中。还记得之前的Eureka server初始化流程和Eureka client初始化流程中都实例化了一个DiscoveryClient类吗？在他的构造方法中，有一行代码 initScheduledTasks(); 这行代码内部就隐藏着eureka client的注册。 （1）在InstanceInfoRe.
Spring Cloud本地调试设置绕过Eureka
罗兰娇的博客
05-17 945
Spring Cloud本地调试设置绕过Eureka 假设中台提供了一个service-A服务接口； 应用端FeignClient会自动创建一个ribbon对象。那么在应用端（客户端）设置ribbon的服务列表为service-A服务接口启动的地址,并且设置eureka.enabled: false，则可以绕过Eureka. ribbon: ReadTimeout: 10000 ConnectTimeout: 10000 eureka: enabled: false service-A:
Eureka源码-Client启动入口(注册，续约，定时任务)
m0_57042151的博客
10-21 393
本文主要是解析下整合去Eureka Server 拉取全量注册表，创建定时任务，包括定时去Eureka Server 上增量拉取注册表信息，定时renew （服务续约）。服务注册Client提交register()在应用启动时就可以直接进行register()，不过，需要提前在配置文件中配置在renew时，如果server端返回的是NOT_FOUND，则提交register()当Client的配置信息发生了变更，则Client提交register()
eureka实践源码.zip
04-29
此外，还会配置EurekaClient，使服务器自身也作为一个客户端注册到自己，形成自我保护机制。 接下来，producer-demo工程代表了服务提供者。服务提供者需要在启动时向Eureka服务器注册自身的信息，包括服务ID、服务...
spring cloud 向 eureka 注册服务
04-24
至于源码分析，Eureka Client 的核心组件包括 `EurekaHttpClient`（用于与 Eureka Server 通信）、`EurekaInstanceConfigBean`（保存服务实例的配置信息）和 `EurekaClient`（提供注册、查询等操作的接口）。...
SpringCloud+SpringBoot+Eureka源码
02-28
源码分析方面，Eureka Server主要由两个核心组件构成：`EurekaClient`和`EurekaServer`. `EurekaClient`是每个服务实例的客户端，负责服务注册和心跳维持；`EurekaServer`则负责存储和处理这些注册信息，提供服务...
spring cloud eureka 服务搭建
04-24
Eureka Server 是服务注册中心，负责接收服务实例的注册信息，并提供服务查询功能。Eureka Client 则是服务提供者和服务消费者的应用程序，它们向 Eureka Server 注册自己的服务实例，并通过 Eureka Server 查找其他...
Eureka的客户端配置文件详解和Eureka实例的配置文件详解
qq_48477526的博客
06-19 794
【代码】Eureka的客户端配置文件详解。
2、Springcloud中Eureka的配置
最新发布
一切皆有可能，无畏将来
08-26 67
表示eureka注册中心的路径，如果配置为eureka，则为http://x.x.x.x:x/eureka/，在eureka的配置文件中加入此配置表示eureka作为客户端向注册中心注册，从而构成eureka集群。#实例是否使用同一zone里的eureka服务器，默认为true，理想状态下，eureka客户端与服务端是在同一zone下。从官方的宣传角度来说，并不支持这样的处理，推荐使用的是Eureka，以为速度更快。#这是一个短暂的×××的配置，如果最新的×××是稳定的，则可以去除，默认为null。
Eureka配置文件详解
记录总结工作过往
06-20 4579
Spring Cloud Eureka为分布式系统外部化配置提供了服务器端和客户端的支持，它包括Eureka Server和Eureka Client两部分，因此Spring Cloud Eureka 配置项比较多，本文将详细讲解Eureka的配置。
SpringCloud之Eureka客户端源码解析
majinan3456的博客
04-06 329
这个接口 我们也可以 自己手动调, 如果 我们明确知道某个实例出现故障下线了，然后 那个实例 的定时器 还没有到 发送心跳给服务端的时间点 ,还没有把自己down的状态发给服务端, 那么, 其他 新上线的 服务从服务端 拉取到的服务列表里，这个实例的状态还是UP, 那么调用的时候 还有可能调到他, 就会产生一次失败的调用。(服务端 把这个实例更新成DOWN之后，其他服务拉取服务列表的定时器还没到时间点, 本地的服务列表还是旧的,这个实例的状态还是UP,那么还会调到它，最终失败。
EnableDiscoveryClient与EnableEurekaClient的区别、Cloud-2.0以后无需增加
z69183787的专栏
08-04 695
EnableDiscoveryClient注解现在也没用了。EnableDiscoveryClient不是必须的，只要classpath中存在DiscoveryClient的实现就可以保证将应用注册到注册中心了，只依赖以spring-cloud-starter-netflix为前缀的库(例如spring-cloud-starter-netflix-eureka-client)，就启用了服务注册发现功能，利用spring容器通过META-INF/spring.factories文件加载配置的能力。
服务发现之：EurekaClient
枣泥馅的博客
06-27 504
在springboot的官方文档中有介绍怎么搭建EurekaClient，这里我们结合Idea来搭建EurekaClient 在文档中有一段是这样描述的： To include the Eureka Client in your project, use the starter with a group ID of org.springframework.cloud and an artifact ID of spring-cloud-starter-netflix-eureka-client 如果要创建一
Eureka的配置项详解
goalietang的专栏
09-18 7287
Eureka的配置项详解: Eureka instance 配置项 #服务注册中心实例的主机名 eureka.instance.hostname=localhost #注册在Eureka服务中的应用组名 eureka.instance.app-group-name= #注册在的Eureka服务中的应用名称 eureka.instance.appname= #该实例注册到服务中心的唯一ID eureka.instance.instance-id= #该实例的IP地址 eureka.instance.ip
Eureka客户端配置详解
梦想起飞的地方.........
04-27 3156
Eureka客户端配置详解 1、RegistryFetchIntervalSeconds 从eureka服务器注册表中获取注册信息的时间间隔（s），默认为30秒 2、InstanceInfoReplicationIntervalSeconds 复制实例变化信息到eureka服务器所需要的时间间隔（s），默认为30秒 3、InitialInstanceInfoReplica...
Eureka常用配置详解
Leon_Jinhai_Sun的博客
08-27 1450
Part XVII. Appendix: Compendium of Configuration Properties 现在来讨论一下Eureka的常用配置,Eureka有非常多的配置项 Appendix:Compendium of Configuration Properties https://cloud.spring.io/spring-cloud-static/Finchley.R...
eureka.client.service-url.defaultZone 和 eureka.client.service-url 有区别吗
05-10
`eureka.client.service-url.defaultZone` 是 Eureka 客户端配置属性，用于指定 Eureka 服务器的 URL 地址，它的格式为：`http://<eureka-server-hostname>:<eureka-server-port>/eureka/`。它是 Eureka 客户端连接 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值