SpringCloud源码学习(二) 面试官问我Eurake服务注册的实现细节？

public void register(EurekaRegistration reg) {
    this.maybeInitializeClient(reg);
    if (log.isInfoEnabled()) {
    //打印服务的状态，UP表示正常启动
        log.info("Registering application " + reg.getInstanceConfig().getAppname() + " with eureka with status " + reg.getInstanceConfig().getInitialStatus());
    }
    //设置启动状态
    reg.getApplicationInfoManager().setInstanceStatus(reg.getInstanceConfig().getInitialStatus());
    if (reg.getHealthCheckHandler() != null) {
        reg.getEurekaClient().registerHealthCheck(reg.getHealthCheckHandler());
    }
}

private void initScheduledTasks() {
    int renewalIntervalInSecs;
    int expBackOffBound;
    //判断是否拉取配置，默认为true
    if (this.clientConfig.shouldFetchRegistry()) {
    //多久拿一次，默认为30秒
        renewalIntervalInSecs = this.clientConfig.getRegistryFetchIntervalSeconds();
        //超时容许时间的倍数，和获取心跳或者服务信息失败的时间差的扩容有关系 默认10秒
        expBackOffBound = this.clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        //这里采用了代理模式，都是runnable接口哦，比较绕
        //启动刷新缓存的线程，也就是获取服务信息，全部打偶放到了定时任务中。
        this.scheduler.schedule(new TimedSupervisorTask("cacheRefresh", this.scheduler, this.cacheRefreshExecutor, renewalIntervalInSecs, 
        TimeUnit.SECONDS, expBackOffBound, new DiscoveryClient.CacheRefreshThread()), (long)renewalIntervalInSecs, TimeUnit.SECONDS);
    }
//判断是否向eureka注册 默认为true
    if (this.clientConfig.shouldRegisterWithEureka()) {
    //多久获取一次服务信息 默认30秒
        renewalIntervalInSecs = this.instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
         //超时容许时间的倍数，和获取心跳或者服务信息失败的时间差的扩容有关系 默认10秒
        expBackOffBound = this.clientConfig.getHeartbeatExecutorExponentialBackOffBound();
        logger.info("Starting heartbeat executor: renew interval is: " + renewalIntervalInSecs);
        //启动心跳线程
        this.scheduler.schedule(new TimedSupervisorTask("heartbeat", this.scheduler, this.heartbeatExecutor, renewalIntervalInSecs, TimeUnit.SECONDS, expBackOffBound, new DiscoveryClient.HeartbeatThread()), (long)renewalIntervalInSecs, TimeUnit.SECONDS);
        this.instanceInfoReplicator = new InstanceInfoReplicator(this, this.instanceInfo, this.clientConfig.getInstanceInfoReplicationIntervalSeconds(), 2);
        //定义一个监听器，用来看获取定时任务还在吗
        this.statusChangeListener = new StatusChangeListener() {
            public String getId() {
                return "statusChangeListener";
            }
            public void notify(StatusChangeEvent statusChangeEvent) {
                if (InstanceStatus.DOWN != statusChangeEvent.getStatus() && InstanceStatus.DOWN != statusChangeEvent.getPreviousStatus()) {
                    DiscoveryClient.logger.info("Saw local status change event {}", statusChangeEvent);
                } else {
                    DiscoveryClient.logger.warn("Saw local status change event {}", statusChangeEvent);
                }
                DiscoveryClient.this.instanceInfoReplicator.onDemandUpdate();
            }
        };
        if (this.clientConfig.shouldOnDemandUpdateStatusChange()) {
            this.applicationInfoManager.registerStatusChangeListener(this.statusChangeListener);
        }
        //启动监听
        this.instanceInfoReplicator.start(this.clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }

}

public void run() {
    Future future = null;
    try {
    //这里task是注册刷新的任务 
        future = this.executor.submit(this.task);
        //获取活动线程的个数
        this.threadPoolLevelGauge.set((long)this.executor.getActiveCount());
        //使用future任务类型，这里获取拿到的服务信息
        future.get(this.timeoutMillis, TimeUnit.MILLISECONDS);
        this.delay.set(this.timeoutMillis);
        this.threadPoolLevelGauge.set((long)this.executor.getActiveCount());
    } catch (TimeoutException var12) {
    //如果超时了，这里还会将当前的时间间隔扩大一倍
        logger.error("task supervisor timed out", var12);
        this.timeoutCounter.increment();
        long currentDelay = this.delay.get();
        long newDelay = Math.min(this.maxDelay, currentDelay * 2L);
        this.delay.compareAndSet(currentDelay, newDelay);
    } catch (RejectedExecutionException var13) {
        if (!this.executor.isShutdown() && !this.scheduler.isShutdown()) {
            logger.error("task supervisor rejected the task", var13);
        } else {
            logger.warn("task supervisor shutting down, reject the task", var13);
        }
        this.rejectedCounter.increment();
    } catch (Throwable var14) {
    //如果异常服务处理，就直接中断了
        if (!this.executor.isShutdown() && !this.scheduler.isShutdown()) {
            logger.error("task supervisor threw an exception", var14);
        } else {
            logger.warn("task supervisor shutting down, can't accept the task");
        }
        this.throwableCounter.increment();
    } finally {
        if (future != null) {
            future.cancel(true);
        }
        if (!this.scheduler.isShutdown()) {
        //如果没有启动的话就重新创建一个
            this.scheduler.schedule(this, this.delay.get(), TimeUnit.MILLISECONDS);
        }
    }
}

    @VisibleForTesting
    void refreshRegistry() {
        try {
            boolean isFetchingRemoteRegionRegistries = this.isFetchingRemoteRegionRegistries();
            boolean remoteRegionsModified = false;
            //先会判断这个值是否为空，如果为空话就从这里获取配置
            String latestRemoteRegions = this.clientConfig.fetchRegistryForRemoteRegions();
            if (null != latestRemoteRegions) {
                String currentRemoteRegions = (String)this.remoteRegionsToFetch.get();
                if (!latestRemoteRegions.equals(currentRemoteRegions)) {
                    synchronized(this.instanceRegionChecker.getAzToRegionMapper()) {
                        if (this.remoteRegionsToFetch.compareAndSet(currentRemoteRegions, latestRemoteRegions)) {
                            //设置最新的服务地址，用来获取服务配置
                            String[] remoteRegions = latestRemoteRegions.split(",");
                            this.remoteRegionsRef.set(remoteRegions);
                            this.instanceRegionChecker.getAzToRegionMapper().setRegionsToFetch(remoteRegions);
                            remoteRegionsModified = true;
                        } else {
                            logger.info("Remote regions to fetch modified concurrently, ignoring change from {} to {}", currentRemoteRegions, latestRemoteRegions);
                        }
                    }
                } else {
                    this.instanceRegionChecker.getAzToRegionMapper().refreshMapping();
                }
            }
           //查看从eureka服务上获取配置是否成功， 真正的获取服务信息
            boolean success = this.fetchRegistry(remoteRegionsModified);
            if (success) {
                this.registrySize = ((Applications)this.localRegionApps.get()).size();
                this.lastSuccessfulRegistryFetchTimestamp = System.currentTimeMillis();
            }
            if (logger.isDebugEnabled()) {
                StringBuilder allAppsHashCodes = new StringBuilder();
                allAppsHashCodes.append("Local region apps hashcode: ");
                allAppsHashCodes.append(((Applications)this.localRegionApps.get()).getAppsHashCode());
                allAppsHashCodes.append(", is fetching remote regions? ");
                allAppsHashCodes.append(isFetchingRemoteRegionRegistries);
                Iterator var11 = this.remoteRegionVsApps.entrySet().iterator();
                while(var11.hasNext()) {
                    Entry<String, Applications> entry = (Entry)var11.next();
                    allAppsHashCodes.append(", Remote region: ");
                    allAppsHashCodes.append((String)entry.getKey());
                    allAppsHashCodes.append(" , apps hashcode: ");
                    allAppsHashCodes.append(((Applications)entry.getValue()).getAppsHashCode());
                }
                logger.debug("Completed cache refresh task for discovery. All Apps hash code is {} ", allAppsHashCodes.toString());
            }
        } catch (Throwable var9) {
            logger.error("Cannot fetch registry from server", var9);
        }
    }

    private void getAndStoreFullRegistry() throws Throwable {
        long currentUpdateGeneration = this.fetchRegistryGeneration.get();
        logger.info("Getting all instance registry info from the eureka server");
        Applications apps = null;
        //这块就是从拉取服务所有信息的
        EurekaHttpResponse<Applications> httpResponse = 
        this.clientConfig.getRegistryRefreshSingleVipAddress() == null ?
        this.eurekaTransport.queryClient.getApplications((String[])this.remoteRegionsRef.get()) : this.eurekaTransport.queryClient.getVip(this.clientConfig.getRegistryRefreshSingleVipAddress(), (String[])this.remoteRegionsRef.get());
        if (httpResponse.getStatusCode() == Status.OK.getStatusCode()) {
            //处理成实体类型
            apps = (Applications)httpResponse.getEntity();
        }
        logger.info("The response status is {}", httpResponse.getStatusCode());
        if (apps == null) {
            logger.error("The application is null for some reason. Not storing this information");
        } else if (this.fetchRegistryGeneration.compareAndSet(currentUpdateGeneration, currentUpdateGeneration + 1L)) {
            this.localRegionApps.set(this.filterAndShuffle(apps));
            logger.debug("Got full registry with apps hashcode {}", apps.getAppsHashCode());
        } else {
            logger.warn("Not updating applications as another thread is updating it already");
        }
    }