Service registration process and data storage design of Spring Cloud Eureka source code analysis!

Spring Cloud is an ecosystem. It provides a set of standards. This set of standards can be implemented through different components, including service registration/discovery, fuse, load balancing, etc. In the spring-cloud-common package, the org.springframework.cloud.client.serviceregistry path Below, you can see the interface definition ServiceRegistry a service registration. It is an interface that defines service registration in spring cloud.

public interface ServiceRegistry<R extends Registration> {
    void register(R registration);

    void deregister(R registration);

    void close();

    void setStatus(R registration, String status);

    <T> T getStatus(R registration);
}

Let's take a look at its class diagram, this interface has a unique implementation EurekaServiceRegistry . Indicates that Eureka Server is used as the service registry.

Trigger mechanism for automatic registration

Eureka automatic registration is triggered by the object EurekaAutoServiceRegistration

When Spring Boot program starts, will be based on an automatic assembly mechanism, in EurekaClientAutoConfiguration this configuration class, initialize a EurekaAutoServiceRegistration This Bean object, as follows.

public class EurekaClientAutoConfiguration {
    @Bean
    @ConditionalOnBean(AutoServiceRegistrationProperties.class)
    @ConditionalOnProperty(
        value = "spring.cloud.service-registry.auto-registration.enabled",
        matchIfMissing = true)
    public EurekaAutoServiceRegistration eurekaAutoServiceRegistration(
        ApplicationContext context, EurekaServiceRegistry registry,
        EurekaRegistration registration) {
        return new EurekaAutoServiceRegistration(context, registry, registration);
    }
}

The definition of the EurekaAutoServiceRegistration class is as follows.

public class EurekaAutoServiceRegistration implements AutoServiceRegistration,
SmartLifecycle, Ordered, SmartApplicationListener {
    //省略
    @Override
    public void start() {
        // only set the port if the nonSecurePort or securePort is 0 and this.port != 0
        if (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 below
        if (!this.running.get() && this.registration.getNonSecurePort() > 0) {

            this.serviceRegistry.register(this.registration);

            this.context.publishEvent(new InstanceRegisteredEvent<>(this,
                                                                    this.registration.getInstanceConfig()));
            this.running.set(true);
        }
    }
    //省略...
}

We found that EurekaAutoServiceRegistration implements the SmartLifecycle interface. After the Spring container has loaded all the Beans and initialized, it will continue to call back the corresponding methods in the class that implements the SmartLifeCycle interface, such as (start).

SmartLifeCycle knowledge expansion

Let me expand my knowledge of SmartLifeCycle. SmartLifeCycle is an interface. After the Spring container has loaded all Beans and initialized, it will continue to call back the corresponding methods in the class that implements the SmartLifeCycle interface, such as (start).

In fact, we can also expand ourselves. For example, write a test class in the same-level directory of the main method of the springboot project, implement the @Service interface, and declare it as a bean through 061bed87ca8308, because to be loaded by spring, the bean must be the first.

@Service
public class TestSmartLifeCycle implements SmartLifecycle {
    @Override
    public void start() {
        System.out.println("start");
    }

    @Override
    public void stop() {
        System.out.println("stop");
    }

    @Override
    public boolean isRunning() {
        return false;
    }
}

Then, after we start the spring boot application, we can see that the string start

We add a debug to the DefaultLifecycleProcessor.startBeans method, we can clearly see that the TestSmartLifeCycle defined by ourselves is scanned, and finally the start method of the bean will be called.

In the startBeans method, we can see that it will first obtain all the Beans that implement SmartLifeCycle, and then it will call the start method of the bean that implements SmartLifeCycle cyclically. The code is as follows.

private void startBeans(boolean autoStartupOnly) {
    Map<String, Lifecycle> lifecycleBeans = this.getLifecycleBeans();
    Map<Integer, DefaultLifecycleProcessor.LifecycleGroup> phases = new HashMap();
    lifecycleBeans.forEach((beanName, bean) -> {
        if (!autoStartupOnly || bean instanceof SmartLifecycle && ((SmartLifecycle)bean).isAutoStartup()) {
            int phase = this.getPhase(bean);
            DefaultLifecycleProcessor.LifecycleGroup group = (DefaultLifecycleProcessor.LifecycleGroup)phases.get(phase);
            if (group == null) {
                group = new DefaultLifecycleProcessor.LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
                phases.put(phase, group);
            }

            group.add(beanName, bean);
        }

    });
    if (!phases.isEmpty()) {
        List<Integer> keys = new ArrayList(phases.keySet());
        Collections.sort(keys);
        Iterator var5 = keys.iterator();

        while(var5.hasNext()) {
            Integer key = (Integer)var5.next();
            ((DefaultLifecycleProcessor.LifecycleGroup)phases.get(key)).start(); //循环调用实现了SmartLifeCycle接口的start方法。
        }
    }

}

The callback of the SmartLifeCycle interface is triggered when SpringBoot starts. The specific execution path is as follows!

SpringApplication.run() -> this.refreshContext(context);->this.refresh(context);->ServletWebServerApplicationContext.refresh()->this.finishRefresh();->AbstractApplicationContext.finishRefresh->DefaultLifecycleProcessor.onRefresh()-> this.startBeans->this.start()->this.doStart()->

Service Registration

Therefore, when SpringBoot starts, it will trigger the start method in EurekaAutoServiceRegistration, the code is as follows.

public class EurekaAutoServiceRegistration implements AutoServiceRegistration,
SmartLifecycle, Ordered, SmartApplicationListener {
    //省略
    @Override
    public void start() {
        // only set the port if the nonSecurePort or securePort is 0 and this.port != 0
        if (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 below
        if (!this.running.get() && this.registration.getNonSecurePort() > 0) {
            //实现服务注册。
            this.serviceRegistry.register(this.registration);
            //发布一个事件
            this.context.publishEvent(new InstanceRegisteredEvent<>(this,
                                                                    this.registration.getInstanceConfig()));
            this.running.set(true);
        }
    }
    //省略...
}

EurekaServiceRegistry.register

this.serviceRegistry.register(this.registration); , the actual call is EurekaServiceRegistry this object register as the following code.

public class EurekaServiceRegistry implements ServiceRegistry<EurekaRegistration> {

    private static final Log log = LogFactory.getLog(EurekaServiceRegistry.class);

    @Override
    public void register(EurekaRegistration reg) {
        maybeInitializeClient(reg);

        if (log.isInfoEnabled()) {
            log.info("Registering application "
                    + reg.getApplicationInfoManager().getInfo().getAppName()
                    + " with eureka with status "
                    + reg.getInstanceConfig().getInitialStatus());
        }
 //设置当前实例的状态，一旦这个实例的状态发生变化，只要状态不是DOWN，那么就会被监听器监听并且执行服务注册。
        reg.getApplicationInfoManager()
                .setInstanceStatus(reg.getInstanceConfig().getInitialStatus());
    //设置健康检查的处理
        reg.getHealthCheckHandler().ifAvailable(healthCheckHandler -> reg
                .getEurekaClient().registerHealthCheck(healthCheckHandler));
    }
}

Judging from the above code, the registration method does not actually call Eureka's method to perform the registration, but only sets a state and sets the health check processor. Let's continue to look at the reg.getApplicationInfoManager().setInstanceStatus method.

public synchronized void setInstanceStatus(InstanceStatus status) {
    InstanceStatus next = instanceStatusMapper.map(status);
    if (next == null) {
        return;
    }

    InstanceStatus prev = instanceInfo.setStatus(next);
    if (prev != null) {
        for (StatusChangeListener listener : listeners.values()) {
            try {
                listener.notify(new StatusChangeEvent(prev, next));
            } catch (Exception e) {
                logger.warn("failed to notify listener: {}", listener.getId(), e);
            }
        }
    }
}

In this method, it will post a state change event through the listener. ok, this time instance listener is StatusChangeListener , is calling StatusChangeListener of notify() method. This event is to trigger a service state change, there should be a place to listen to this event, and then based on this event.

At this time we thought we had found the direction, and then clicked to take a look, clicked and found that it was an interface. And we found that it is a static internal interface, and we can't directly see its implementation class.

Based on my years of source code reading experience, so I looked back, because I can basically guess that the initialization must be done somewhere, so I want to find EurekaServiceRegistry.register reg.getApplicationInfoManager instance in the 061bed87ca860e method is, and we found ApplicationInfoManager is an attribute EurekaRegistration

public class EurekaRegistration implements Registration {

    private final ApplicationInfoManager applicationInfoManager;

    private ObjectProvider<HealthCheckHandler> healthCheckHandler;

    private EurekaRegistration(CloudEurekaInstanceConfig instanceConfig,
                               EurekaClient eurekaClient, ApplicationInfoManager applicationInfoManager,
                               ObjectProvider<HealthCheckHandler> healthCheckHandler) {
        this.eurekaClient = eurekaClient;
        this.instanceConfig = instanceConfig;
        this.applicationInfoManager = applicationInfoManager;
        this.healthCheckHandler = healthCheckHandler;
    }
}

And EurekaRegistration is EurekaAutoServiceRegistration the class 061bed87ca8659.

Then we go to the configuration class EurekaAutoServiceRegistration applicationInfoManager , the code is as follows:

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingRefreshScope
protected static class EurekaClientConfiguration {

    @Bean
    @ConditionalOnMissingBean(value = ApplicationInfoManager.class,
                              search = SearchStrategy.CURRENT)
    @org.springframework.cloud.context.config.annotation.RefreshScope
        @Lazy
        public ApplicationInfoManager eurekaApplicationInfoManager(
        EurekaInstanceConfig config) {
        InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
        return new ApplicationInfoManager(config, instanceInfo);  //构建了一个ApplicationInfoManager实例。
    }

}

In the construction method of ApplicationInfoManager, a listeners object is initialized, which is a ConcurrentHashMap collection, but this collection is not assigned a value when it is initialized.

@Inject
public ApplicationInfoManager(EurekaInstanceConfig config, InstanceInfo instanceInfo, OptionalArgs optionalArgs) {
    this.config = config;
    this.instanceInfo = instanceInfo;
    this.listeners = new ConcurrentHashMap<String, StatusChangeListener>();
    if (optionalArgs != null) {
        this.instanceStatusMapper = optionalArgs.getInstanceStatusMapper();
    } else {
        this.instanceStatusMapper = NO_OP_MAPPER;
    }

    // Hack to allow for getInstance() to use the DI'd ApplicationInfoManager
    instance = this;
}

When encountering this problem, let's not panic. Let's take a look at the method of assigning value to ApplicationInfoManager the class listeners

public void registerStatusChangeListener(StatusChangeListener listener) {
    listeners.put(listener.getId(), listener);
}

The only caller of this method is the DiscoveryClient.initScheduledTasks method.

Where is this method called?

DiscoveryClient

In EurekaClientAutoConfiguration static inner class of this class autoconfiguration EurekaClientConfiguration by @Bean it injected a CloudEurekaClient example, as follows.

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingRefreshScope
protected static class EurekaClientConfiguration {

    @Autowired
    private ApplicationContext context;

    @Autowired
    private AbstractDiscoveryClientOptionalArgs<?> optionalArgs;

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

It is not difficult to guess from the name that EurekaClient should be a client implementation class specifically responsible for interacting with EurekaServer, and the instance object returned here is CloudEurekaClient , and the construction code is as follows.

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

Note that in the construction method of the CloudEurekaClient ApplicationInfoManager passed, which will be used later.

At the same time, the construction method will synchronously call super(applicationInfoManager, config, args); , that is, call DiscoveryClient , the code is as follows.

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

Eventually, the following methods overloaded in DiscoveryClient will be called. The code is relatively long and non-critical codes are omitted.

DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
                Provider<BackupRegistry> backupRegistryProvider, EndpointRandomizer endpointRandomizer) {
    //省略....

    if (config.shouldFetchRegistry()) { //是否要从eureka server上获取服务地址信息
        this.registryStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRY_PREFIX + "lastUpdateSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
    } else {
        this.registryStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
    }
    //是否要注册到eureka server上
    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);
    }
   
    //如果需要注册到Eureka server并且是开启了初始化的时候强制注册，则调用register()发起服务注册
    if (clientConfig.shouldFetchRegistry()) {
        try {
            //从Eureka-Server中拉去注册地址信息
            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();
    }
      //如果需要注册到Eureka server并且是开启了初始化的时候强制注册，则调用register()发起服务注册(默认情况下，shouldEnforceRegistrationAtInit为false)
    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);
}

DiscoveryClient.initScheduledTasks

initScheduledTasks to start a timed task.

• If it is configured to enable the refresh service list from the registry, the timing task of cacheRefreshExecutor will be enabled

• If the service is turned on and registered to Eureka, several things need to be done.

  • Establish a heartbeat detection mechanism
  • The StatusChangeListener instance status monitoring interface is instantiated through the internal class. This is what we saw during the analysis and startup process. Calling the notify method will actually be reflected here.

private void initScheduledTasks() {
     //如果配置了开启从注册中心刷新服务列表，则会开启cacheRefreshExecutor这个定时任务
    if (clientConfig.shouldFetchRegistry()) {
        // registry cache refresh timer
        //registryFetchIntervalSeconds:30s
        int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
        //expBackOffBound:10
        int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        cacheRefreshTask = new TimedSupervisorTask(
            "cacheRefresh",
            scheduler,
            cacheRefreshExecutor,
            registryFetchIntervalSeconds,
            TimeUnit.SECONDS,
            expBackOffBound,
            new CacheRefreshThread()
        );
        scheduler.schedule(
            cacheRefreshTask,
            registryFetchIntervalSeconds, TimeUnit.SECONDS);
    }
      //如果开启了服务注册到Eureka，则通过需要做几个事情
    if (clientConfig.shouldRegisterWithEureka()) {
        int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
        int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
        logger.info("Starting heartbeat executor: " + "renew interval is: {}", renewalIntervalInSecs);

        // 开启一个心跳任务
        heartbeatTask = new TimedSupervisorTask(
            "heartbeat",
            scheduler,
            heartbeatExecutor,
            renewalIntervalInSecs,
            TimeUnit.SECONDS,
            expBackOffBound,
            new HeartbeatThread()
        );
        scheduler.schedule(
            heartbeatTask,
            renewalIntervalInSecs, TimeUnit.SECONDS);

        //创建一个instanceInfoReplicator实例信息复制器
        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) {
                logger.info("Saw local status change event {}", statusChangeEvent);
                instanceInfoReplicator.onDemandUpdate();
            }
        };
               //注册实例状态变化的监听
        if (clientConfig.shouldOnDemandUpdateStatusChange()) { 
            applicationInfoManager.registerStatusChangeListener(statusChangeListener); //注意（case）
        }
  //启动一个实例信息复制器，主要就是为了开启一个定时线程，每40秒判断实例信息是否变更，如果变更了则重新注册
        instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }
}

In the above code, we found a very important logic: applicationInfoManager.registerStatusChangeListener(statusChangeListener);

This code is to register a StatusChangeListener and save it to the listener collection in ApplicationInfoManager. (Remember the service registration logic in the previous source code analysis? When the server is started or stopped, ApplicationInfoManager.listener will be called, and the listener.notify method will be traversed one by one), and listener collection are completed when DiscoveryClient is initialized.

instanceInfoReplicator.onDemandUpdate()

The main function of this method is to trigger the data in the service registry based on whether the instance data has changed.

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");
                   //取出之前已经提交的任务，也就是在start方法中提交的更新任务，如果任务还没有执行完成，则取消之前的任务。
                    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;
    }
}

InstanceInfoReplicator.this.run();

The run method calls the register method for service registration, and in finally, the current run method will be periodically executed every 30s to check.

public void run() {
    try {
        //刷新实例信息
        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 {
        //每隔30s，执行一次当前的`run`方法
        Future next = scheduler.schedule(this, replicationIntervalSeconds, TimeUnit.SECONDS);
        scheduledPeriodicRef.set(next);
    }
}

DiscoveryClient.register

After remembering the above analysis, we finally found Eureka's service registration method: eurekaTransport.registrationClient.register , and the final call was AbstractJerseyEurekaHttpClient#register(...).

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

AbstractJerseyEurekaHttpClient#register

Obviously, here is an http request to access the apps/${APP_NAME} interface of Eureka-Server, and the information of the current service instance is sent to Eureka Server for storage.

So far, we basically know how Spring Cloud Eureka registers service information to Eureka Server when it starts.

public EurekaHttpResponse<Void> register(InstanceInfo info) {
        String urlPath = "apps/" + info.getAppName();
    ClientResponse response = null;
    try {
        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();
        }
    }
}

Service registration summary

The service registration process is divided into two steps

1. The DiscoveryClient object, during initialization, calls the initScheduledTask() method to construct a StatusChangeListener monitor.
2. When the Spring Cloud application starts, it is based on the SmartLifeCycle interface callback to trigger the StatusChangeListener event notification
3. In the callback method of StatusChangeListener, call the onDemandUpdate method to update the client's address information to complete the service registration.

How is Eureka's registration information stored?

After Eureka Server receives the service registration request from the client, it needs to store the information in Eureka Server. Its storage structure is shown in the figure below.

EurekaServer uses the ConcurrentHashMap collection method. To store the address information of the service provider, where the final storage object of the instance information of each node is InstanceInfo. >

Eureka Server receives request processing

The request entrance is at: com.netflix.eureka.resources.ApplicationResource.addInstance() .

You can find that the REST service provided here is implemented using Jersey. Jersey is based on the JAX-RS standard and provides support for the implementation of REST, so I will not analyze it here.

The service registration interface defined on the Eureka Server side is implemented as follows:

@POST
@Consumes({"application/json", "application/xml"})
public Response addInstance(InstanceInfo info,
                            @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication) {
    logger.debug("Registering instance {} (replication={})", info.getId(), isReplication);
      
    // handle cases where clients may be registering with bad DataCenterInfo with missing data
    //实例部署的数据中心， 这里是AWS实现的数据相关的逻辑，这里不涉及到，所以不需要去关心
    DataCenterInfo dataCenterInfo = info.getDataCenterInfo();
    if (dataCenterInfo instanceof UniqueIdentifier) {
        String dataCenterInfoId = ((UniqueIdentifier) dataCenterInfo).getId();
        if (isBlank(dataCenterInfoId)) {
            boolean experimental = "true".equalsIgnoreCase(serverConfig.getExperimental("registration.validation.dataCenterInfoId"));
            if (experimental) {
                String entity = "DataCenterInfo of type " + dataCenterInfo.getClass() + " must contain a valid id";
                return Response.status(400).entity(entity).build();
            } else if (dataCenterInfo instanceof AmazonInfo) {
                AmazonInfo amazonInfo = (AmazonInfo) dataCenterInfo;
                String effectiveId = amazonInfo.get(AmazonInfo.MetaDataKey.instanceId);
                if (effectiveId == null) {
                    amazonInfo.getMetadata().put(AmazonInfo.MetaDataKey.instanceId.getName(), info.getId());
                }
            } else {
                logger.warn("Registering DataCenterInfo of type {} without an appropriate id", dataCenterInfo.getClass());
            }
        }
    }
   //在这里会调用服务注册方法，传递`info`，表示客户端的服务实例信息。
    registry.register(info, "true".equals(isReplication));
    return Response.status(204).build();  // 204 to be backwards compatible
}

PeerAwareInstanceRegistryImpl.register

Let's first look at the class diagram of PeerAwareInstanceRegistryImpl. From the class diagram, we can see that the top-level interface of PeerAwareInstanceRegistry is LeaseManager and LookupService.

• Among them, LookupService defines the most basic behavior of discovering instances.
• LeaseManager defines operations such as processing client registration, renewal, and cancellation.

InstanceRegistry.register

Then enter the register method of InstanceRegistry. In this method, a call to the handleRegistration method is added. This method is used to publish a EurekaInstanceRegisteredEvent event.

@Override
public void register(final InstanceInfo info, final boolean isReplication) {
   handleRegistration(info, resolveInstanceLeaseDuration(info), isReplication);
   super.register(info, isReplication);
}

The register method of the parent class

Then call the register method of the parent class PeerAwareInstanceRegistryImpl, the code is as follows.

@Override
public void register(final InstanceInfo info, final boolean isReplication) {
    int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;  //租约过期时间
    if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) { //如果客户端有自己定义心跳超时时间，则采用客户端的
        leaseDuration = info.getLeaseInfo().getDurationInSecs();
    }
    super.register(info, leaseDuration, isReplication);  //节点注册
    replicateToPeers(Action.Register, info.getAppName(), info.getId(), info, null, isReplication); //把注册信息同步到其他集群节点。
}

in:

• leaseDuration represents the lease expiration time, the default is 90s, that is, when the server does not receive the client's heartbeat for more than 90s, the node is actively removed
• Call super.register to initiate node registration
• Copy the information to other machines in the Eureka Server cluster, the implementation of synchronization is also very simple, that is, get all the nodes in the cluster, and then initiate registration one by one

AbstractInstanceRegistry.register

Finally, the implementation of service registration is completed in the instance registration class of this abstract class. The code is as follows.

public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
    read.lock();
    try {
        //从registry中获得当前实例信息，根据appName， registry中保存了所有客户端的实例数据
        Map<String, Lease<InstanceInfo>> gMap = registry.get(registrant.getAppName());
        REGISTER.increment(isReplication);  //原子递增，做数据统计
        if (gMap == null) { //如果gMap为空，说明当前服务端没有保存该实例数据，则通过下面代码进行初始化
            final ConcurrentHashMap<String, Lease<InstanceInfo>> gNewMap = new ConcurrentHashMap<String, Lease<InstanceInfo>>();
            gMap = registry.putIfAbsent(registrant.getAppName(), gNewMap);
            if (gMap == null) {
                gMap = gNewMap;
            }
        } 
        //从gMap中查询已经存在的Lease信息，Lease中文翻译为租约，实际上它把服务提供者的实例信息包装成了一个lease，里面提供了对于改服务实例的租约管理
        Lease<InstanceInfo> existingLease = gMap.get(registrant.getId());
        //  当instance已经存在时，和客户端的instance的信息做比较，时间最新的那个，为有效instance信息
        if (existingLease != null && (existingLease.getHolder() != null)) {
            Long existingLastDirtyTimestamp = existingLease.getHolder().getLastDirtyTimestamp();
            Long registrationLastDirtyTimestamp = registrant.getLastDirtyTimestamp();
            logger.debug("Existing lease found (existing={}, provided={}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);

            // this is a > instead of a >= because if the timestamps are equal, we still take the remote transmitted
            // InstanceInfo instead of the server local copy.
              // 比较lastDirtyTimestamp ， 以lastDirtyTimestamp大的为准
            if (existingLastDirtyTimestamp > registrationLastDirtyTimestamp) {
                logger.warn("There is an existing lease and the existing lease's dirty timestamp {} is greater" +
                            " than the one that is being registered {}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
                logger.warn("Using the existing instanceInfo instead of the new instanceInfo as the registrant");
                registrant = existingLease.getHolder();  //重新赋值registrant为服务端最新的实例信息
            }
        } else {
            // 如果lease不存在，则认为是一个新的实例信息，执行下面这段代码（后续单独分析它的作用）
            synchronized (lock) {
                if (this.expectedNumberOfClientsSendingRenews > 0) {
                    // Since the client wants to register it, increase the number of clients sending renews
                    this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews + 1;
                    updateRenewsPerMinThreshold();
                }
            }
            logger.debug("No previous lease information found; it is new registration");
        }
        //创建一个Lease租约信息
        Lease<InstanceInfo> lease = new Lease<InstanceInfo>(registrant, leaseDuration);
        if (existingLease != null) {  // 当原来存在Lease的信息时，设置serviceUpTimestamp, 保证服务启动的时间一直是第一次注册的那个（避免状态变更影响到服务启动时间）
            lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());
        }
        gMap.put(registrant.getId(), lease);  //把当前服务实例保存到gMap中。
        
        recentRegisteredQueue.add(new Pair<Long, String>(
            System.currentTimeMillis(),
            registrant.getAppName() + "(" + registrant.getId() + ")"));
        // This is where the initial state transfer of overridden status happens
        //如果实例状态不等于UNKNOWN，则把当前实例状态添加到overriddenInstanceStatusMap中
        if (!InstanceStatus.UNKNOWN.equals(registrant.getOverriddenStatus())) {
            logger.debug("Found overridden status {} for instance {}. Checking to see if needs to be add to the "
                         + "overrides", registrant.getOverriddenStatus(), registrant.getId());
            if (!overriddenInstanceStatusMap.containsKey(registrant.getId())) {
                logger.info("Not found overridden id {} and hence adding it", registrant.getId());
                overriddenInstanceStatusMap.put(registrant.getId(), registrant.getOverriddenStatus());
            }
        }
        //重写实例状态
        InstanceStatus overriddenStatusFromMap = overriddenInstanceStatusMap.get(registrant.getId());
        if (overriddenStatusFromMap != null) {
            logger.info("Storing overridden status {} from map", overriddenStatusFromMap);
            registrant.setOverriddenStatus(overriddenStatusFromMap);
        }

        // Set the status based on the overridden status rules
        InstanceStatus overriddenInstanceStatus = getOverriddenInstanceStatus(registrant, existingLease, isReplication);
        registrant.setStatusWithoutDirty(overriddenInstanceStatus);// 设置实例信息的状态，但不标记 dirty

        // If the lease is registered with UP status, set lease service up timestamp
        if (InstanceStatus.UP.equals(registrant.getStatus())) { //如果服务实例信息为UP状态，则更新该实例的启动时间。
            lease.serviceUp();
        }
        registrant.setActionType(ActionType.ADDED); // 设置注册类型为添加
        recentlyChangedQueue.add(new RecentlyChangedItem(lease));  // 租约变更记录队列，记录了实例的每次变化， 用于注册信息的增量获取
        registrant.setLastUpdatedTimestamp(); //修改最后一次更新时间
        //让缓存失效
        invalidateCache(registrant.getAppName(), registrant.getVIPAddress(), registrant.getSecureVipAddress());
        logger.info("Registered instance {}/{} with status {} (replication={})",
                    registrant.getAppName(), registrant.getId(), registrant.getStatus(), isReplication);
    } finally {
        read.unlock();
    }
}

EurekaServer registration information storage summary

So far, we have done a detailed analysis of the process of service registration on the client and server. In fact, on the Eureka Server side, the client address information will be saved in ConcurrentHashMap for storage. And a heartbeat detection mechanism will be established between the service provider and the registration center.

Used to monitor the health status of service providers.

Copyright statement: All articles in this blog, except for special statements, adopt the CC BY-NC-SA 4.0 license agreement. Please indicate the reprint from Mic takes you to learn architecture!
If this article is helpful to you, please help me to follow and like. Your persistence is the motivation for my continuous creation. Welcome to follow the WeChat public account of the same name for more technical dry goods!