SpringCloud源码学习笔记之Eureka服务端——服务注册

关注

原创最新推荐文章于 2026-03-17 10:41:34 发布 560 阅读 AI 写同款· GEO 优化 ›

Spring 源码阅读：用于创建 AOP 代理的后处理器分析前面两篇文章分析了在注解配置和 XML 配置的情况下，Spring 是如何开启 AOP 特性的，经过源码分析我们知道，这两种方式的 AOP 开启，本质上都是注册了一个用来创建 AOP 代理的后处理器。对于在 XML 中配置切面的情况，Spring 会把创建代理的工作交给 AspectJAwareAdvisorAutoProxyCreator 后处理器来处理，而对于通过注解配置切面的情况，则交由 AnnotationAwareAspectJAutoProxyCreator 后处理器处理。阅读详情

1、接收注册请求

在Eureka开源框架中，使用了Jersey来构建RESTful Web服务，类似于Spring MVC中的Controller功能，不过Jersey更加专注RESTful风格的API。

Jersey参考文档：
1、Jersey是一个什么框架,价值在哪里？
2、Jersey 开发RESTful（七）Jersey快速入门
3、JAX-RS和Jersey

在Netflix开源框架中，eureka-core中的com.netflix.eureka.resources目录下，有一个ApplicationResource类，它就是基于jersey构建的处理与Application相关请求的资源类，其中主要提供了：

getApplication() 获取Application相关信息
getInstanceInfo() 获取了一个用于处理InstanceInfo的jersey资源类InstanceResource
addInstance() 提供InstanceInfo信息注册，这就是Eureka服务端为客户端提供服务注册的入口，用来接收注册请求的。

2、addInstance()方法

这是Eureka服务端为客户端提供服务注册的入口，该方法有两个参数，分别表示：

InstanceInfo表示需要注册的实例信息
isReplication表示是客户端请求还是集群中其他Eureka节点的同步请求

@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);
    // 省略 验证instanceinfo需要包含的必要信息的逻辑
  	 ……
    //省略 处理dataCenterInfo相关内容,一般使用的是MyDataCenterInfo
     ……
	//注册InstanceInfo 实例，这是最核心的逻辑
    registry.register(info, "true".equals(isReplication));
    //构建返回对象，注册成功，默认的状态码为204
    return Response.status(204).build();  // 204 to be backwards compatible
}

在上述方法中，实际用来注册服务的逻辑，是通过调用registry.register()方法来完成的。

3、InstanceRegistry类的register()方法

在前面的addInstance()方法中，通过调用registry.register()方法实现了服务注册的逻辑，其实就是调用了InstanceRegistry类（SpringCloud提供）的register()方法，在该方法中，首先通过handleRegistration()方法发布了EurekaInstanceRegisteredEvent广播事件，然后调用父类PeerAwareInstanceRegistryImpl的register()方法进行实例注册。

其实，在Spring Cloud集成和扩展Eureka组件时，SpringCloud提供InstanceRegistry类，主要作用就是发布对应的广播事件，包括后续的服务续约、服务剔除等。

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

resolveInstanceLeaseDuration()方法用来解析续约间隔，默认是90s，如果InstanceInfo有配置，就是用InstanceInfo 配置中的间隔时间。

private int resolveInstanceLeaseDuration(final InstanceInfo info) {
	//默认时间
	int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;
	//根据info进行配置时间
	if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) {
		leaseDuration = info.getLeaseInfo().getDurationInSecs();
	}
	return leaseDuration;
}

handleRegistration()方法用来处理注册事件，这里主要通过publishEvent()方法发布了一个EurekaInstanceRegisteredEvent广播事件，通过监听该事件可以进行一些扩展，比如监听到了注册事件进行一些回调之类的操作。

private void handleRegistration(InstanceInfo info, int leaseDuration,
	boolean isReplication) {
	log("register " + info.getAppName() + ", vip " + info.getVIPAddress()
			+ ", leaseDuration " + leaseDuration + ", isReplication "
			+ isReplication);
	//发布广播事件
	publishEvent(new EurekaInstanceRegisteredEvent(this, info, leaseDuration,
			isReplication));
}

4、PeerAwareInstanceRegistryImpl的register()方法

在前面InstanceRegistry类的register()方法中，实际上又调用了PeerAwareInstanceRegistryImpl类的register()方法。在该方法中，主要做了两件事：第一，调用父类AbstractInstanceRegistry中的register()方法；第二，通过调用replicateToPeers()方法，复制所有的操作到集群的其他节点中。

PeerAwareInstanceRegistryImpl类针对AbstractInstanceRegistry抽象类的扩展，主要就是在处理集群节点间的数据同步等。

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

4.1、replicateToPeers()方法

该方法是PeerAwareInstanceRegistryImpl类提供的通用方法，用来同步实例的所有操作（Heartbeat, Register, Cancel, StatusUpdate, DeleteStatusOverride）信息到集群中的其他节点。该方法主要实现了遍历peerEurekaNodes节点，然后排除自身，再调用replicateInstanceActionsToPeers()方法实现数据的同步。

private void replicateToPeers(Action action, String appName, String id,
                        InstanceInfo info /* optional */,
                             InstanceStatus newStatus /* optional */, boolean isReplication) {
   Stopwatch tracer = action.getTimer().start();
   try {
       if (isReplication) {
           numberOfReplicationsLastMin.increment();
       }
       // 如果节点为空或者已经是操作同步操作，就直接返回
       if (peerEurekaNodes == Collections.EMPTY_LIST || isReplication) {
           return;
       }

       for (final PeerEurekaNode node : peerEurekaNodes.getPeerEurekaNodes()) {
           // 排除给自己同步数据
           if (peerEurekaNodes.isThisMyUrl(node.getServiceUrl())) {
               continue;
           }
           //真正进行同步信息的方法
           replicateInstanceActionsToPeers(action, appName, id, info, newStatus, node);
       }
   } finally {
       tracer.stop();
   }
}

4.2、replicateInstanceActionsToPeers()方法

replicateInstanceActionsToPeers()方法是一个根据不同操作类型，进行不同操作类型的数据同步，比如：注册的时候，主要执行的是 node.register(info)方法，其中node是需要同步注册信息的集群节点。

private void replicateInstanceActionsToPeers(Action action, String appName,String id, InstanceInfo info, InstanceStatus newStatus, PeerEurekaNode node) {
   try {
       InstanceInfo infoFromRegistry;
       CurrentRequestVersion.set(Version.V2);
       switch (action) {
           case Cancel://取消应用
               node.cancel(appName, id);
               break;
           case Heartbeat://心跳
               InstanceStatus overriddenStatus = overriddenInstanceStatusMap.get(id);
               infoFromRegistry = getInstanceByAppAndId(appName, id, false);
               node.heartbeat(appName, id, infoFromRegistry, overriddenStatus, false);
               break;
           case Register://注册
               node.register(info);
               break;
           case StatusUpdate://状态修改
               infoFromRegistry = getInstanceByAppAndId(appName, id, false);
               node.statusUpdate(appName, id, newStatus, infoFromRegistry);
               break;
           case DeleteStatusOverride://删除覆盖状态
               infoFromRegistry = getInstanceByAppAndId(appName, id, false);
               node.deleteStatusOverride(appName, id, infoFromRegistry);
               break;
       }
   } catch (Throwable t) {
       logger.error("Cannot replicate information to {} for action {}", node.getServiceUrl(), action.name(), t);
   } finally {
       CurrentRequestVersion.remove();
   }
}

4.3、PeerEurekaNode类的register()方法

在前面的replicateInstanceActionsToPeers()方法中，我们可以知道，最终是通过调用node.register(info)方法实现注册操作的数据同步的，实际上真正调用的方法就是PeerEurekaNode类的register()方法。

public void register(final InstanceInfo info) throws Exception {
  long expiryTime = System.currentTimeMillis() + getLeaseRenewalOf(info);
   batchingDispatcher.process(
           taskId("register", info),
           new InstanceReplicationTask(targetHost, Action.Register, info, null, true) {
               public EurekaHttpResponse<Void> execute() {
                   return replicationClient.register(info);
               }
           },
           expiryTime
   );
}

其中，关于batchingDispatcher.process()方法，主要用于处理任务InstanceReplicationTask对象，并执行其中的replicationClient.register(info)方法，详细请参考《Eureka 源码解析 —— 任务批处理》。

4.4、AbstractJerseyEurekaHttpClient类的register()方法

AbstractJerseyEurekaHttpClient类的register()方法，是基于Jersey构建的服务注册请求。

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

5、AbstractInstanceRegistry类的register()方法

在前面PeerAwareInstanceRegistryImpl类的register()方法中，有调用了父类AbstractInstanceRegistry中的register()方法，该方法是真正实现注册InstanceInfo实例信息的方法，具体实现如下：

public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
  try {
      read.lock();
      //registry是一个ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>>类型的变量，其中第一次表示的是应用名称，第二层表示的是具体的实例对象，这里首先根据应用名称获取对应的租约对象
      Map<String, Lease<InstanceInfo>> gMap = registry.get(registrant.getAppName());
      //Eureka监听器，用来记录注册数量和同步数量
      REGISTER.increment(isReplication);
      //初始化应用的租约存储对象ConcurrentHashMap<String, Lease<InstanceInfo>>
      if (gMap == null) {
          final ConcurrentHashMap<String, Lease<InstanceInfo>> gNewMap = new ConcurrentHashMap<String, Lease<InstanceInfo>>();
          gMap = registry.putIfAbsent(registrant.getAppName(), gNewMap);
          if (gMap == null) {
              gMap = gNewMap;
          }
      }
      //获取指定实例对应的租约对象
      Lease<InstanceInfo> existingLease = gMap.get(registrant.getId());
      // 如果存在InstanceInfo实例对象的租约
      if (existingLease != null && (existingLease.getHolder() != null)) {
      	  //原来对象的租约时间
          Long existingLastDirtyTimestamp = existingLease.getHolder().getLastDirtyTimestamp();
          //当前注册对象的租约时间
          Long registrationLastDirtyTimestamp = registrant.getLastDirtyTimestamp();
          logger.debug("Existing lease found (existing={}, provided={}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);

          //如果原来的对象租约时间比当前要注册对象的租约时间大，就是用原来的租约对象
          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();
          }
      } else {//当原来没有租约时，就是从新注册对象，首先需要更新续约的阈值
          // The lease does not exist and hence it is a new registration
          synchronized (lock) {
              if (this.expectedNumberOfClientsSendingRenews > 0) {
                  //更新续约的阈值
                  this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews + 1;
                  updateRenewsPerMinThreshold();
              }
          }
          logger.debug("No previous lease information found; it is new registration");
      }
      //根据registrant创建租约对象（存在租约的对象，也会被重新创建）
      Lease<InstanceInfo> lease = new Lease<InstanceInfo>(registrant, leaseDuration);
      //设置ServiceUp时间戳，主要是记录第一次的时间（因为existingLease 存在，说明之前已经开始服务，所以把原来的赋值到这里即可）
      if (existingLease != null) {
          lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());
      }
      //把InstanceInfo的新的租约对象放到registry变量中
      gMap.put(registrant.getId(), lease);
      //添加实例信息到recentRegisteredQueue队列中，用于统计或调试
      recentRegisteredQueue.add(new Pair<Long, String>(
              System.currentTimeMillis(),
              registrant.getAppName() + "(" + registrant.getId() + ")"));
      // 记录实例状态到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);
      }

      // 根据指定规则获取覆盖状态，并在不修改dirty时间戳情况下，修改该状态
      InstanceStatus overriddenInstanceStatus = getOverriddenInstanceStatus(registrant, existingLease, isReplication);
      registrant.setStatusWithoutDirty(overriddenInstanceStatus);

      // 当实例状态是Up时，修改租约对象的service up时间戳
      if (InstanceStatus.UP.equals(registrant.getStatus())) {
          lease.serviceUp();
      }
      //设置操作类型
      registrant.setActionType(ActionType.ADDED);
      //添加变化实例对象到recentlyChangedQueue队列
      recentlyChangedQueue.add(new RecentlyChangedItem(lease));
      //设置InstanceInfo实例对象的最后一次更新时间
      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();
  }
}