Renew

所谓续约，就是一种心跳保护机制，每隔一段时间（默认30秒），客户端需要发送心跳告知server端自己还活着，防止server端将自己的从registry注册表清除

eureka续约时序图

续约时序图

源码

InstanceResource

@Produces({"application/xml", "application/json"})
public class InstanceResource {

    // 对等实例注册器处理
    private final PeerAwareInstanceRegistry registry;

    // eureka server 配置信息
    private final EurekaServerConfig serverConfig;
    
    // Client请求实例InstanceId
    private final String id;

    // Client 请求方应用资源
    private final ApplicationResource app;


    InstanceResource(ApplicationResource app, String id, EurekaServerConfig serverConfig, PeerAwareInstanceRegistry registry) {
        this.app = app;
        this.id = id;
        this.serverConfig = serverConfig;
        this.registry = registry;
    }

    /**
    * 
    * 从eureka client 实例过来的PUT请求，续签租约
    *
    * @param isReplication 是否是其他server节点的复制请求
    *            
    * @param overriddenStatus 覆盖状态，正常client续约过来的心跳请求，该值为null
    *            
    * @param status client实例当前状态
    *            
    * @param lastDirtyTimestamp client实例信息被更新的时间
    *
    * @return response 
    */
    @PUT
    public Response renewLease(
            @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication,
            @QueryParam("overriddenstatus") String overriddenStatus,
            @QueryParam("status") String status,
            @QueryParam("lastDirtyTimestamp") String lastDirtyTimestamp) {
        boolean isFromReplicaNode = "true".equals(isReplication);

        // 1. 将续约请求委托给了registry处理
        boolean isSuccess = registry.renew(app.getName(), id, isFromReplicaNode);

        // Not found in the registry, immediately ask for a register
        // 2. 在注册表中没有发现，请求注册
        if (!isSuccess) {
            logger.warn("Not Found (Renew): {} - {}", app.getName(), id);
            
            // 2.1 返回404状态码  
            return Response.status(Status.NOT_FOUND).build();
        }

        // Check if we need to sync based on dirty time stamp, the client
        // instance might have changed some value
        // 3. 检查我们是否需要基于脏时间同步，客户端实例信息可能已经发生改变了
        Response response;

        // 3.1 这里需要满足两个条件，lastDirtyTimestamp 不为null且服务端开启了syncWhenTimestampDiffers，默认开启
        if (lastDirtyTimestamp != null && serverConfig.shouldSyncWhenTimestampDiffers()) {

            // 验证脏时间
            response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
            // Store the overridden status since the validation found out the node that replicates wins
            if (response.getStatus() == Response.Status.NOT_FOUND.getStatusCode()
                    && (overriddenStatus != null)
                    && !(InstanceStatus.UNKNOWN.name().equals(overriddenStatus))
                    && isFromReplicaNode) {
                registry.storeOverriddenStatusIfRequired(app.getAppName(), id, InstanceStatus.valueOf(overriddenStatus));
            }
        } else {
            response = Response.ok().build();
        }
        logger.debug("Found (Renew): {} - {}; reply status={}", app.getName(), id, response.getStatus());
        return response;
    }

PeerAwareInstanceRegistryImpl

/**
 * 
 * 标记指定app的指定实例为已续约，同时标记是否来自server节点的复制
 */
public boolean renew(String appName, String id, boolean isReplication) {
    RENEW.increment(isReplication);

    // 1. 获取指定app的签约信息Map
    Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
    Lease<InstanceInfo> leaseToRenew = null;
    if (gMap != null) {
        leaseToRenew = gMap.get(id);
    }

    // 2. 如果指定app的指定实例的租约信息不存在，则可能正在注册，或者还没有注册，返回false
    if (leaseToRenew == null) {
        RENEW_NOT_FOUND.increment(isReplication);
        logger.warn("DS: Registry: lease doesn't exist, registering resource: {} - {}", appName, id);
        return false;
    } else {

        // 2.1 实例租约信息存在，获取租约绑定的实例信息
        InstanceInfo instanceInfo = leaseToRenew.getHolder();
        if (instanceInfo != null) {
            // touchASGCache(instanceInfo.getASGName());
            InstanceStatus overriddenInstanceStatus = this.getOverriddenInstanceStatus(
                    instanceInfo, leaseToRenew, isReplication);
            if (overriddenInstanceStatus == InstanceStatus.UNKNOWN) {
                logger.info("Instance status UNKNOWN possibly due to deleted override for instance {}"
                        + "; re-register required", instanceInfo.getId());
                RENEW_NOT_FOUND.increment(isReplication);
                return false;
            }
            if (!instanceInfo.getStatus().equals(overriddenInstanceStatus)) {
                logger.info(
                        "The instance status {} is different from overridden instance status {} for instance {}. "
                                + "Hence setting the status to overridden status", instanceInfo.getStatus().name(),
                                instanceInfo.getOverriddenStatus().name(),
                                instanceInfo.getId());
                instanceInfo.setStatusWithoutDirty(overriddenInstanceStatus);

            }
        }
        // 2.2 增加上一分钟续约次数
        renewsLastMin.increment();
        
        // 2.3 续约操作，更新租约的上次更新时间lastUpdateTimestamp：当前时间戳 + duration（默认90s）
        leaseToRenew.renew();
        return true;
    }
}

总结

心跳续约主要就是更新该实例Instance对应租约Lease的lastUpdateTimestamp: 当前时间戳 + duration（默认90s）
如果不存在该实例对应的租约信息Lease,则返回404状态码，要求eureka client发起注册请求
续约成功后，会调用PeerAwareInstanceRegistryImpl的replicateToPeers(...)方法，后台任务完成其他server节点的复制操作
由于Client端心跳续约频率为默认30秒一次，而默认的duration租约持续时间为90s，即表示，如果Server端在90s内都没有收到来自Client的心跳续约请求，Server就会将该Client从注册表中剔除