三.SpringCloud源码剖析-Eureka Client服务注册

最新推荐文章于 2021-12-30 21:42:41 发布
最新推荐文章于 2021-12-30 21:42:41 发布
阅读量944 收藏 2
点赞数 1
分类专栏： 《升职加薪之SpringCloudNetflix源码剖析》 文章标签： cloud spring spring boot 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014494148/article/details/106907911
版权

系列文章目录

一.SpringCloud源码剖析-Eureka核心API

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

三.SpringCloud源码剖析-Eureka服务注册

四.SpringCloud源码剖析-Eureka服务发现

五.SpringCloud源码剖析-Eureka Client服务续约

六.SpringCloud源码剖析-Eureka Client取消注册

七.SpringCloud源码剖析-Eureka Server的自动配置

八.SpringCloud源码剖析-Eureka Server初始化流程

九.SpringCloud源码剖析-Eureka Server服务注册流程

十.SpringCloud源码剖析-Eureka Server服务续约

十一.SpringCloud源码剖析-Eureka Server服务注册表拉取

十二.SpringCloud源码剖析-Eureka Server服务剔除

十三.SpringCloud源码剖析-Eureka Server服务下线

前言

文章过长，您需要有些耐心！！！

在上一章《Eureka Client 初始化过程》中我们了解到，应用程序在启动的时候就会初始化Eureka并触发Eureka的自动注册，最终会调用DiscoveryClient进行服务注册，我们来跟踪一下DiscoveryClient是如何实现服务注册与发现的。

1.DiscoveryClient 初始化定时任务

程序启动EurekaClientAutoConfiguration被加载，EurekaClient在EurekaClientAutoConfiguration 中通过“延迟@Lazy”注册。同时EurekaAutoServiceRegistration 监听启动事件，调用 EurekaServiceRegistry的register方法进行注册，该方法会触发EurekaClient的创建 。自动配置类中有如下代码

    //可刷新的Eureka客户端配置
    @Configuration
	@ConditionalOnRefreshScope
	protected static class RefreshableEurekaClientConfiguration {

		@Autowired
		private ApplicationContext context;

		@Autowired
		private AbstractDiscoveryClientOptionalArgs<?> optionalArgs;
		//注册EurekaClient
		@Bean(destroyMethod = "shutdown")
		@ConditionalOnMissingBean(value = EurekaClient.class, search = SearchStrategy.CURRENT)
		@org.springframework.cloud.context.config.annotation.RefreshScope
		@Lazy
		public EurekaClient eurekaClient(ApplicationInfoManager manager, EurekaClientConfig config, EurekaInstanceConfig instance) {
			//初始化InstanceInfo，服务实例注册信息对象
			manager.getInfo(); // force initialization
			//创建CloudEurekaClient ，他是 EurekaClient的实现类
			return new CloudEurekaClient(manager, config, this.optionalArgs,
					this.context);
		}
		...省略...

这里初始化InstanceInfo服务注册实例之后，创建了EurekaClient 客户端，通过子类 CloudEurekaClient进行创建，只不过这里是@Lazy延迟创建，在，跟踪下去，我们看一下CloudEurekaClient是如何创建的

public class CloudEurekaClient extends DiscoveryClient {
	...省略...
	private ApplicationInfoManager applicationInfoManager;
	private AtomicReference<EurekaHttpClient> eurekaHttpClient = new AtomicReference<>();

	public CloudEurekaClient(ApplicationInfoManager applicationInfoManager,
							 EurekaClientConfig config, ApplicationEventPublisher publisher) {
		this(applicationInfoManager, config, null, publisher);
	}
	//创建CloudEurekaClient的构造器
	public CloudEurekaClient(ApplicationInfoManager applicationInfoManager,
							 EurekaClientConfig config,
							 AbstractDiscoveryClientOptionalArgs<?> args,
							 ApplicationEventPublisher publisher) {
		//通过父类DiscoveryClient进行初始化
		super(applicationInfoManager, config, args);
		this.applicationInfoManager = applicationInfoManager;
		this.publisher = publisher;
		this.eurekaTransportField = ReflectionUtils.findField(DiscoveryClient.class, "eurekaTransport");
		ReflectionUtils.makeAccessible(this.eurekaTransportField);
	}

这里super(applicationInfoManager, config, args);通过父类初始化他的父类是DiscoveryClient，DiscoveryClient的父接口是EurekaClient
在这里插入图片描述
我们继续跟踪上去DiscoveryClient的构造器


@Inject
    DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
                    Provider<BackupRegistry> backupRegistryProvider) {
        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;
        }
        //InstanceInfo管理器
        this.applicationInfoManager = applicationInfoManager;
        //InstanceInfo服务实例注册信息,注册的对象
        InstanceInfo myInfo = applicationInfoManager.getInfo();
		//eureka客户端配置
        clientConfig = config;
        staticClientConfig = clientConfig;
        //和eurekaServrer的通信配置，该配置通过EurekaClientConfigBean来创建
        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.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();
            logger.info("Discovery Client initialized at timestamp {} with initial instances count: {}",
                    initTimestampMs, this.getApplications().size());

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

        try {
        	//初始化线程池======================================
        	//创建定时任务执行器，核心数2
            // 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
			//初始化和EurekaServer交互的客户端EurekaHttpClient，
			//会创建服务注册的EurekaHttpClient和拉取注册表的EurekaHttpClient
            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() && !fetchRegistry(false)) {
            fetchRegistryFromBackup();
        }

        // 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 {
            	//调用register()方法发起服务注册 ,默认 clientConfig.shouldEnforceRegistrationAtInit是不满足的
                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();
        logger.info("Discovery Client initialized at timestamp {} with initial instances count: {}",
                initTimestampMs, this.getApplications().size());
    }

构造器中做了一些初始化工作

  • 比如初始化心跳线程执行器，服务列表刷新线程执行器
  • 比如创建EurekaTransport，用来和Eureka交互的客户端，内部创建了EurekaHttpClient来发请求
  • 最后调用initScheduledTasks方法进行定时任务的初始化
2.initScheduledTasks初始化定时任务

接下来我们详细看一下initScheduledTasks中的代码：

 	  /**
 	  初始化所有定时任务
     * Initializes all scheduled tasks.
     */
    private void initScheduledTasks() {
    	//判断如果要拉取注册表
        if (clientConfig.shouldFetchRegistry()) {
        	//刷新注册表的心跳时间间隔
            // registry cache refresh timer
            int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
            int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
            //刷新注册表的定时任务：CacheRefreshThread刷新注册表
            scheduler.schedule(
                    new TimedSupervisorTask(
                            "cacheRefresh",
                            scheduler,
                            cacheRefreshExecutor,
                            registryFetchIntervalSeconds,
                            TimeUnit.SECONDS,
                            expBackOffBound,
                            new CacheRefreshThread()
                    ),
                    registryFetchIntervalSeconds, TimeUnit.SECONDS);
        }
		//是否要注册到Eureaka
        if (clientConfig.shouldRegisterWithEureka()) {
        	//这里取的是租约更新时间 30s/次
            int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
            int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
            logger.info("Starting heartbeat executor: " + "renew interval is: {}", renewalIntervalInSecs);

            // Heartbeat timer
            //心跳续约的定时任务 ：HeartbeatThread 中进行续约，内部调用DiscoverClient.renew方法
            scheduler.schedule(
                    new TimedSupervisorTask(
                            "heartbeat",
                            scheduler,
                            heartbeatExecutor,
                            renewalIntervalInSecs,
                            TimeUnit.SECONDS,
                            expBackOffBound,
                            new HeartbeatThread()
                    ),
                    renewalIntervalInSecs, TimeUnit.SECONDS);

            // InstanceInfo replicator
            //注册实例InstanceInfo的复制器,负责将自身的信息周期性的上报到EurekaServer；
            //，内部会通过定时任务调用(赋值时间40s间隔)，检查InstanceInfo(DataCenterInfo,LeaseInfo,InstanceStatus)是否有变化，
            //内部调用InstanceInfoReplicator.run方法，再调用Discoverlient.refreshInstanceInfo()方法通过ApplicationInfoManager刷新实例状态
            //刷新完成后会调用 discoveryClient.register();进行注册
            instanceInfoReplicator = new InstanceInfoReplicator(
                    this,
                    instanceInfo,
                    //定时调度时间间隔，30s/次
                    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);
                    }
                    //按需更新，使用scheduler执行一个Runnable任务，任务中调用InstanceInfoReplicator.this.run()方法，
                    //run方法中先执行discoveryClient.refreshInstanceInfo();刷新实例状态，
               		//然后调用discoveryClient.register()注册,如果在DiscoveryClient初始化的时候，
                    instanceInfoReplicator.onDemandUpdate();
                }
            };
			//通过applicationInfoManager注册监听器
            if (clientConfig.shouldOnDemandUpdateStatusChange()) {
                applicationInfoManager.registerStatusChangeListener(statusChangeListener);
            }

			//启动InstanceInfo复制器，传入 复制实例的时间间隔
          instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
        } else {
            logger.info("Not registering with Eureka server per configuration");
        }
    }

总结一下initScheduledTasks做了如下事情

  • 启动线程调用CacheRefreshThread任务刷新服务列表(registryFetchIntervalSeconds=30s执行一次),从EurekaServer拉取服务注册列表同时刷新客户端缓存

  • 启动heartbeat心跳定时线程(renewalIntervalInSecs=30s续约一次)执行任务HeartbeatThread，调用DiscoverClient.renew定时向Eureka Server发送心跳

  • 启动InstanceInfo复制器定时线程,开启定时线程检查当前检查DataCenterInfo,LeaseInfo,InstanceStatus状态，内部通过isInstanceInfoDirty属性来标记是否有状态改变，如果发现变更就执行discoveryClient.register()将实例信息同步到Server端实现服务注册

  • 通过ApplicationInfoManager注册了StatusChangeListener来监听服务的注册状态改变，当服务状态改变会调用ApplicationInfoManager.setInstanceStatus方法设置服务状态会触发StatusChangeListener监听器，该监听器会调用instanceInfoReplicator.onDemandUpdate();进行按需更新，内部会检查服务变更信息，如果有变更，然后把服务信息注册到Eureaka

需要补充说明的是：在Eureka启动时会自动注册，在EurekaServiceRegistry.register方法会注册EurekaRegistration,方法中会初始化EurekaClient(DiscoveryClient创建)从而注册ApplicationInfoManager中的StatusChangeListener，初始化完成之后会接着执行reg.getApplicationInfoManager().setInstanceStatus(reg.getInstanceConfig().getInitialStatus());修改ApplicationInfoManager中的InstatceStatus状态为UP，ApplicationInfoManager在EurekaClientAutoConfiguration中被创建的时候，里面的InstanceInfo是通过new InstanceInfoFactory().create(config);创建，其中的InstanceStatus默认是STARING，这个状态的改变会触发StatusChangeListener监听器的执行从而触发StatusChangeListener

3.InstanceInfoReplicator复制InstanceInfo注册服务

在initScheduledTasks方法中通过InstanceInfoReplicator复制服务实例，然后调用DiscoverClient.register进行注册

class InstanceInfoReplicator implements Runnable {
...省略...
//在DiscoverClient初始化的时候调用 延迟40s执行
 public void start(int initialDelayMs) {
        if (started.compareAndSet(false, true)) {
        	//标记实例有更新(脏数据)，这个标记是服务注册的依据
            instanceInfo.setIsDirty();  // for initial register
            //定时调度，30s/次
            Future next = scheduler.schedule(this, initialDelayMs, TimeUnit.SECONDS);	
            scheduledPeriodicRef.set(next);
        }
    }
    ...省略...
//按需更新，会定时触发服务状态检查和服务注册，见Run方法
public boolean onDemandUpdate() {
        if (rateLimiter.acquire(burstSize, allowedRatePerMinute)) {
        	//定时执行
            if (!scheduler.isShutdown()) {
                scheduler.submit(new Runnable() {
                    @Override
                    public void run() {
                        logger.debug("Executing on-demand update of local InstanceInfo");
    
                        Future latestPeriodic = scheduledPeriodicRef.get();
                        if (latestPeriodic != null && !latestPeriodic.isDone()) {
                            logger.debug("Canceling the latest scheduled update, it will be rescheduled at the end of on demand update");
                            latestPeriodic.cancel(false);
                        }
    
                        //调用run方法
                        InstanceInfoReplicator.this.run();
                    }
                });
                return true;
            } else {
                logger.warn("Ignoring onDemand update due to stopped scheduler");
                return false;
            }
        } else {
            logger.warn("Ignoring onDemand update due to rate limiter");
            return false;
        }
    }

    public void run() {
        try {
        	//刷新InstanceInfo，内部会检查：dataCenter和 LeaseInfo
        	//applicationInfoManager.refreshDataCenterInfoIfRequired();
        	//applicationInfoManager.refreshLeaseInfoIfRequired();
        	//根据HealthCheckHandler获取实例状态InstanceStatus，并更新，如果状态发生变化会触发所有StatusChangeListener
            discoveryClient.refreshInstanceInfo();
			//刷新后，如果实例发生了变更(有脏数据)，就发起注册
            Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
            if (dirtyTimestamp != null) {
            	//发起注册
                discoveryClient.register();
                instanceInfo.unsetIsDirty(dirtyTimestamp);
            }
        } catch (Throwable t) {
            logger.warn("There was a problem with the instance info replicator", t);
        } finally {
            Future next = scheduler.schedule(this, replicationIntervalSeconds, TimeUnit.SECONDS);
            scheduledPeriodicRef.set(next);
        }
    }

InstanceInfoReplicator的run方法会在2个地方被调用，一是会在DiscoverClient初始化定时任务initScheduledTasks方法中被创建调用instanceInfoReplicator.start 延迟40s执行，而是调用ApplicationInfoManager.setInstanceStatus改变了实例状态，触发StatusChangeListener监听器，在监听器内部会触发InstanceInfoReplicator.onDemandUpdate方法，然后调用run方法。

4.DiscoveryClient.register服务注册

通过上面的源码跟踪我们知道，Eureka通过DiscoverClient发起服务注册

 /**
     * Register with the eureka service by making the appropriate REST call.
     */
    boolean register() throws Throwable {
        logger.info(PREFIX + "{}: registering service...", appPathIdentifier);
        //http响应
        EurekaHttpResponse<Void> httpResponse;
        try {
        //提交注册，发起http请求，eurekaTransport是在DiscoveryClient初始化的时候创建的和EurekaServer交互的客户端，这里是把InstanceInfo作为注册实例提交到EurekaServer
            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() == 204;
    }

这里通过调用：eurekaTransport.registrationClient.register(instanceInfo);得到一个EurekaHttpClient，然后调用register方法向EurekaServer发起http请求实现注册，eurekaTransport是在DiscoveryClient初始化的时候创建的和EurekaServer交互的客户端，这里是把InstanceInfo作为注册实例提交到EurekaServer，继续跟踪下去

public abstract class EurekaHttpClientDecorator implements EurekaHttpClient {
    @Override
    public EurekaHttpResponse<Void> register(final InstanceInfo info) {
        return execute(new RequestExecutor<Void>() {
            @Override
            public EurekaHttpResponse<Void> execute(EurekaHttpClient delegate) {
            	//发起注册请求
                return delegate.register(info);
            }

            @Override
            public RequestType getRequestType() {
                return RequestType.Register;
            }
        });
    }

代码执行到EurekaHttpClient的装饰类EurekaHttpClientDecorator，先后会执行RetryableEurekaHttpClient(Http请求失败进行重试),
RedirectingEurekaHttpClient(重定向到不同的EurekaServer)
MetricsCollectingEurekaHttpClient(统计执行指标)
AbstractJerseyEurekaHttpClient(使用jersey发起注册)
继续跟踪，会调用AbstractJerseyEurekaHttpClient的register方法注册

public abstract class AbstractJerseyEurekaHttpClient implements EurekaHttpClient {
@Override
    public EurekaHttpResponse<Void> register(InstanceInfo info) {
        String urlPath = "apps/" + info.getAppName();
        ClientResponse response = null;
        try {
        //jerseyClient其实是ApacheHttpClient
            Builder resourceBuilder = jerseyClient.resource(serviceUrl).path(urlPath).getRequestBuilder();
            addExtraHeaders(resourceBuilder);
            response = resourceBuilder
                    .header("Accept-Encoding", "gzip")
                    .type(MediaType.APPLICATION_JSON_TYPE)
                    .accept(MediaType.APPLICATION_JSON)
                    .post(ClientResponse.class, info);
            return anEurekaHttpResponse(response.getStatus()).headers(headersOf(response)).build();
        } finally {
            if (logger.isDebugEnabled()) {
                logger.debug("Jersey HTTP POST {}/{} with instance {}; statusCode={}", serviceUrl, urlPath, info.getId(),
                        response == null ? "N/A" : response.getStatus());
            }
            if (response != null) {
                response.close();
            }
        }
    }

看到这里我们应该就明白了，在register方法中获取到了 serviceUrl 即配置文件中的注册服务地址，把InstanceInfo作为参数，底层通过jersey(rest)来发请求然后会调用WebResource发送post请求，实现服务注册。

public class WebResource extends Filterable implements RequestBuilder<WebResource.Builder>, UniformInterface {
		//发送post请求
 		public <T> T post(Class<T> c, Object requestEntity) throws UniformInterfaceException, ClientHandlerException {
            return WebResource.this.handle(c, this.build("POST", requestEntity));
        }
        ....省略....
5.服务注册流程总结

在这里插入图片描述

1.程序启动触发EurekaServiceRegistry.register(EurekaRegistration)实现服务自动注册

  • 该方法中会初始化DiscoveryClient，
  • 同时改变ApplicationInfoManager中的InstanceStatus的状态为UP,该状态默认是STARING，该状态的变更会触发StatusChangeListener监听器
  • 给EurekaRegistration.eurekaClient注册了监控检查处理器healthCheckHandler

2.DiscoveryClient初始化流程(构造器)中

  • 创建了心跳线程执行器，服务列表刷新线程执行器，
  • 创建了EurekaTransport(EurekaHttpClient)用来向EureakServer发请求的客户端，
  • 然后调用initScheduledTask初始化定时任务

3.DiscoveryClient.initScheduledTasks方法中

  • 初始化了刷新注册表的定时任务(CacheRefreshThread)，
  • 服务心跳心跳定时任务(HeartbeatThread)，
  • 创建了InstanceInfoReplicator实例信息复制器，
  • 还注册了ApplicationInfoManager.StatusChangeListener
  • 最后启动InstanceInfoReplicator复制器

4.InstanceInfoReplicator复制InstanceInfo注册服务

  • 首先它是一个Runnable 线程，30s定时调度一次，除了在DiscoveryClient.initScheduledTasks中会被触发调用，会被StatusChangeListener监听器中被调用InstanceInfoReplicator.onDemandUpdate(),
  • 在InstanceInfoReplicator的run方法中会调用discoveryClient.refreshInstanceInfo();先检查实例信息是否有变更，如果有变更(通过instanceInfo.setIsDirty()标记)会向Eureak注册，调用discoveryClient.register();进行注册

4.DiscoveryClient.register服务注册

  • 使用的是eurekaTransport获取一个EurekaHttpClient，调用register方法
  • 最终调用AbstractJerseyEurekaHttpClient中的register，发起http把InstanceInfo注册到EureakServer

下一章节推荐《Eureka Server服务注册流程》

Spring Cloud 微服务开发：入门、进阶与源码剖析 —— 2.1 Spring Cloud Eureka 入门
极客挖掘机
01-17 4147
第二章 Spring Cloud Eureka Netflix Eureka是Netflix开源的一款基于REST提供服务注册和发现的产品，它提供了完整的Service Registry和Service Discovery实现。从2012年9月再Github上发布1.1.2版本依赖，目前已经发布了239个Release版本，目前最新版本是2019年6月14日发布的v1.9.12版本。期间Netfl...
理解 Spring Cloud 分布式配置中心Eureka
AI天才研究院
08-05 2043
在 Spring Cloud 的世界里，分布式系统经历了开发、测试、运维三个阶段。而在开发阶段，通常采用集中式配置方式，将所有配置文件统一管理在一台服务器上。随着业务系统的不断扩张，各个微服务模块都需要配置自己的属性值。因此，需要一个分布式配置中心来解决这一问题。Spring Cloud 提供了基于 Netflix Eureka 和 Spring Cloud Config 的分布式配置中心解决方案，本文主要以 Eureka 为例进行分析。
Spring-Cloud Eureka
M风景的技术博客
03-08 267
Spring Eureka是什么？ Eureka是服务注册与发现的组件，包含了服务注册和服务发现两个主要的功能 Eureka原理 Eureka服务注册 在Spring-Boot启动类添加注解@EnableEurekaServer @SpringBootApplication @EnableEurekaServer public class EurekaServerApplication { public static void main(String[] args) {..
springcloud 和apollo配置中心一起使用时踩到的一个坑
热门推荐
xiao_jun_0820的专栏
09-23 1万+
场景描述： 今天收到线上一个服务的instance deregistered的告警邮件，在springboot admin上确实那个instance不在线了。于是去服务器上jps看了一下，进程正常的，但是/health端点信息显示eureka为down。查看error.log，并没有错误日志，查看warn.log，发现里面有些许的警告日志如下： [2018-09-20T19:12:24.159...
Eureka服务注册源码分析
wh柒八九的博客
08-23 610
本文来说下Eureka服务注册源码 文章目录Eureka-Client注册服务啥时候会注册 Eureka-Client注册服务 啥时候会注册 在两种情况下客户端会主动向服务端发送自己的注册信息 当客户端的instance信息发生改变时，Eureka-Client和Server端信息不一致时 当客户端刚刚启动的时候。 ...
Eureka 源码解析 —— 基于令牌桶算法的 RateLimiter
天黑了
12-15 1342
摘要: 原创出处 http://www.iocoder.cn/Eureka/rate-limiter/ 「芋道源码」欢迎转载，保留摘要，谢谢！本文主要基于 Eureka 1.8.X 版本 1. 概述 2. RateLimiter 2.1 refillToken 2.2 consumeToken3. RateLimitingFilter 4. InstanceInfoReplicator 666. 彩
Eureka的InstanceInfoReplicator类（服务注册辅助工具）
程序员欣宸的博客
09-30 5429
关于服务注册 以下图片来自Netflix官方，图中显示Eureka Client会向注册中心发起Get Registry请求来获取服务列表： 以Spring Cloud的Edgware.RELEASE版本为例，Eureka client的注册动作是在com.netflix.discovery.DiscoveryClient类的initScheduledTasks方法中执行的，相关代码片段如下所示...
SpringCloud学习笔记--Eureka注册中心
dukay2021的博客
07-27 460
1、互联网应用架构发展 1）、单体应用架构 业务简单，数据量小，所有的模块部署在一个应用，一个服务容器。 优点：成本低，开发节奏快，架构简单，易于调试部署。 缺点：功能不断迭代，耦合严重；代码杂乱；沟通成功高。 2）、垂直应用架构 为了解决单体架构的问题，开始做模块的垂直划分，划分依据业务特性，互相不影响。 优点：系统拆分流量分担，方便水平扩展，系统互不影响，可以独立优化。 缺点：系统之间调用硬编码，方式不统一，监控不到位；数据库资源浪...
springcloud 之 eureka 源码解析(4)-Eureka服务注册源码分析
yeyinzhu3211的专栏
12-30 841
springcloud 之 eureka 源码解析(4)-Eureka服务注册源码分析
spring cloud 配置源码.zip
06-17
源码中展示了Eureka Server如何启动并管理服务实例，以及Eureka Client如何进行服务注册和心跳维持。通过调整Eureka的各项参数，例如服务注册的超时时间、心跳间隔等，可以优化服务发现的效率和稳定性。 四、Zuul：...
深入理解Eureka
weixin_34198797的博客
06-11 1010
转载请标明出处：blog.csdn.net/forezp/arti…本文出自方志朋的博客 Eureka的一些概念 Register：服务注册当Eureka客户端向Eureka Server注册时，它提供自身的元数据，比如IP地址、端口，运行状况指示符URL，主页等。 Renew：服务续约Eureka客户会每隔30秒发送一次心跳来续约。 通过续约来告知Eureka Server该Eureka...
eureka之ApplicationInfoManager管理实例
欢谷悠扬
05-19 564
1.前言 在上一节《eureka之InstanceInfo单例管理器》中，EurekaConfigBasedInstanceInfoProvider对InstanceInfo进行初始化了， 但是由于是通过new EurekaConfigBasedInstanceInfoProvider(config).get()来实现的，而创建出来的EurekaConfigBasedInstanceInfoProvider对象，并没有被管理起来，所以无法通过EurekaConfigBasedInstanceInfoProv
Eureka 源码解析 —— 应用实例注册发现（一）之注册
天黑了
12-13 1683
摘要: 原创出处 http://www.iocoder.cn/Eureka/instance-registry-register/ 「芋道源码」欢迎转载，保留摘要，谢谢！本文主要基于 Eureka 1.8.X 版本 1. 概述 2. Eureka-Client 发起注册 2.1 应用实例信息复制器 2.2 刷新应用实例信息 2.3 发起注册应用实例3. Eureka-Server 接收注册 3.
eureka客户端启动流程
wzhzzzz的博客
09-09 1248
1. 获取eureka服务端的地址 2. 初始化延时任务 初始化任务位于这个方法中：com.netflix.discovery.DiscoveryClient#initScheduledTasks 把延迟任务封装到这个类里面com.netflix.discovery.TimedSupervisorTask#TimedSupervisorTask， 使得每个定时任务运行结束后根据运行时间动态调整下次...
spring-cloud-eureka (一) 原理分析
Mr_rain的专栏
12-14 6530
spring-cloud-eureka是spring-cloud-nettfix微服务套件中的一部分， 它基于nettfix-eureka做了二次封装，主要负责微服务架构中的服务治理功能。 如果了解dubbo的朋友应该知道，dubbo就是一个服务治理的框架，dubbo是基于zookeeper实现服务治理功能的。至于dubbo和nettfix-eureka的区别这里不多说，网上有不少这类文章。
注册中心 Eureka 源码解析 —— 应用实例注册发现（一）之注册
weixin_33994444的博客
04-20 108
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringCloud踩坑记（三）SpringCloud 注册中心Eureka
李哥的博客
01-08 846
简介 Eureka是基于REST（代表性状态转移）的服务，主要在AWS云中用于定位服务，以实现负载均衡和中间层服务器的故障转移。它主要分为Server和Client两个部份。与Zookeeper和Consul类型，是作用于服务注册和发现的组件。 架构 Eureka 的基本架构下图所示 其中主要包括以下3种角色 Register Service：服务注册中心，它是一个Eureka Server ，...
springcloud 系列 用几张图，带你了解 eureka-client
不能放弃治疗
04-19 108
引言 springcloud 通过 SPI 技术加载 spring.factories 文件中定义好的Bean。其中 EurekaClientAutoConfiguration 装入了 EurekaClient。 一个 EurekaClient 代表的就是我们的客户端，也是我们主要需要关心的对象。 俯瞰 Eureka-client 启动 代码入口：DiscoveryClient Discover...
【Eureka】【06】Eureka Clinet注册和状态改变时重新注册信息
huiyanshizhen21的博客
09-28 373
核心类EurekaDiscoveryClientConfiguration、DiscoveryClient、InstanceInfoReplicator 1.bean单利初始化完成后，执行SmartLifecycle的start方法 org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration.start() @Configuration @EnableConfigurationProperties @Conditi
spring-cloud-starter-netflix-eureka-client与spring-cloud-starter-eureka的区别
最新发布
04-10
spring-cloud-starter-netflix-eureka-client和spring-cloud-starter-eureka都是Spring Cloud框架中用于集成Netflix Eureka服务注册与发现组件的依赖库，它们的区别如下： 1. spring-cloud-starter-netflix-eureka-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

墨家巨子@俏如来

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值