SpringCloud源码剖析-Eureka核心API

//封装了服务注册所需要的注册信息@ProvidedBy(EurekaConfigBasedInstanceInfoProvider.class)
@Serializer("com.netflix.discovery.converters.EntityBodyConverter")
@XStreamAlias("instance")
@JsonRootName("instance")
publicclassInstanceInfo {
   ...省略...
//实例IDprivatevolatileStringinstanceId;
//服务名privatevolatileStringappName;
@AutoprivatevolatileStringappGroupName;
//服务地址privatevolatileStringipAddr;
//主机privatevolatileStringhostName;
//端口privatevolatileintport=DEFAULT_PORT;
    ...省略...

publicclassInstanceInfoFactory {
//创建服务注册实例对象，EurekaInstanceConfig 是用来加载配置文件中的服务配置信息publicInstanceInfocreate(EurekaInstanceConfigconfig) {
//服务续约Builder设置续约心跳间隔时间和续约超时时间LeaseInfo.BuilderleaseInfoBuilder=LeaseInfo.Builder.newBuilder()              .setRenewalIntervalInSecs(config.getLeaseRenewalIntervalInSeconds())
            .setDurationInSecs(config.getLeaseExpirationDurationInSeconds());
//翻译：构建要注册到Eureka服务端的服务实例,绑定相关的配置项目，这里的config就是// Builder the instance information to be registered with eureka// serverInstanceInfo.Builderbuilder=InstanceInfo.Builder.newBuilder();
builder.setNamespace(namespace).setAppName(config.getAppname())
            .setInstanceId(config.getInstanceId())
            .setAppGroupName(config.getAppGroupName())
            .setDataCenterInfo(config.getDataCenterInfo())
            .setIPAddr(config.getIpAddress()).setHostName(config.getHostName(false))
            .setPort(config.getNonSecurePort())
            .enablePort(InstanceInfo.PortType.UNSECURE,
config.isNonSecurePortEnabled())
            .setSecurePort(config.getSecurePort())
            .enablePort(InstanceInfo.PortType.SECURE, config.getSecurePortEnabled())
            .setVIPAddress(config.getVirtualHostName())
            .setSecureVIPAddress(config.getSecureVirtualHostName())
            .setHomePageUrl(config.getHomePageUrlPath(), config.getHomePageUrl())
            .setStatusPageUrl(config.getStatusPageUrlPath(),
config.getStatusPageUrl())
            .setHealthCheckUrls(config.getHealthCheckUrlPath(),
config.getHealthCheckUrl(), config.getSecureHealthCheckUrl())
            .setASGName(config.getASGName());
        .....省略......
//添加元数据信息// Add any user-specific metadata informationfor (Map.Entry<String, String>mapEntry : config.getMetadataMap().entrySet()) {
Stringkey=mapEntry.getKey();
Stringvalue=mapEntry.getValue();
// only add the metadata if the value is presentif (value!=null&&!value.isEmpty()) {
builder.add(key, value);
                }
            }
//构建服务注册实例对象InstanceInfoinstanceInfo=builder.build();
//设置服务租约对象instanceInfo.setLeaseInfo(leaseInfoBuilder.build());
returninstanceInfo;
 }

@JsonRootName("leaseInfo")
publicclassLeaseInfo {
publicstaticfinalintDEFAULT_LEASE_RENEWAL_INTERVAL=30;
publicstaticfinalintDEFAULT_LEASE_DURATION=90;
// Client settings//客户端：续约间隔周期时间 30/s 心跳机制privateintrenewalIntervalInSecs=DEFAULT_LEASE_RENEWAL_INTERVAL;
//客户端：续约有效时长超过 90s续约失败(服务端会剔除该实例)privateintdurationInSecs=DEFAULT_LEASE_DURATION;
// Server populated//服务端: 服务端设置该租约第一次续约时间privatelongregistrationTimestamp;
//服务端: 服务端设置该租约最后一次续约时间privatelonglastRenewalTimestamp;
//服务端: 服务端设置该租约被剔除时间privatelongevictionTimestamp;
//服务端: 服务端设置该服务上线 up 时间privatelongserviceUpTimestamp;
}

/*** Represents an instance of a Service in a Discovery System* @author Spencer Gibb*/publicinterfaceServiceInstance {
/**服务ID* @return the service id as registered.*/StringgetServiceId();
/**服务主机* @return the hostname of the registered ServiceInstance*/StringgetHost();
/**服务端口* @return the port of the registered ServiceInstance*/intgetPort();
/**是否开启https* @return if the port of the registered ServiceInstance is https or not*/booleanisSecure();
/**服务的URI地址* @return the service uri address*/URIgetUri();
/**实例的元数据信息* @return the key value pair metadata associated with the service instance*/Map<String, String>getMetadata();
/*** @return the scheme of the instance*/defaultStringgetScheme() {
returnnull;
    }
}

@ProvidedBy(EurekaConfigBasedInstanceInfoProvider.class)
@Serializer("com.netflix.discovery.converters.EntityBodyConverter")
@XStreamAlias("instance")
@JsonRootName("instance")
publicclassInstanceInfo {
    ...省略...
publicenumInstanceStatus {
UP, // Ready to receive trafficDOWN, // Do not send traffic- healthcheck callback failedSTARTING, // Just about starting- initializations to be done - do not// send trafficOUT_OF_SERVICE, // Intentionally shutdown for trafficUNKNOWN;
publicstaticInstanceStatustoEnum(Strings) {
if (s!=null) {
try {
returnInstanceStatus.valueOf(s.toUpperCase());
                } catch (IllegalArgumentExceptione) {
// ignore and fall through to unknownlogger.debug("illegal argument supplied to InstanceStatus.valueOf: {}, defaulting to {}", s, UNKNOWN);
                }
            }
returnUNKNOWN;
        }
    }
}

/**包含了应用实例列表* The application class holds the list of instances for a particular* application.** @author Karthik Ranganathan**/@Serializer("com.netflix.discovery.converters.EntityBodyConverter")
@XStreamAlias("application")
@JsonRootName("application")
publicclassApplication {
privatestaticRandomshuffleRandom=newRandom();
privateStringname;
@XStreamOmitFieldprivatevolatilebooleanisDirty=false;
@XStreamImplicitprivatefinalSet<InstanceInfo>instances;
//无序状态实例列表privatefinalAtomicReference<List<InstanceInfo>>shuffledInstances;
//map缓存服务ID 对应 实例关系privatefinalMap<String, InstanceInfo>instancesMap;
    ...省略...
/**翻译：添加实例信息* Add the given instance info the list.** @param i*            the instance info object to be added.*/publicvoidaddInstance(InstanceInfoi) {
instancesMap.put(i.getId(), i);
synchronized (instances) {
instances.remove(i);
instances.add(i);
isDirty=true;
        }
    }
/**翻译：移出实例信息* Remove the given instance info the list.** @param i*            the instance info object to be removed.*/publicvoidremoveInstance(InstanceInfoi) {
removeInstance(i, true);
    }
/**翻译：获取实例信息列表* Gets the list of instances associated with this particular application.* <p>* Note that the instances are always returned with random order after* shuffling to avoid traffic to the same instances during startup. The* shuffling always happens once after every fetch cycle as specified in* {@link EurekaClientConfig#getRegistryFetchIntervalSeconds}.* </p>** @return the list of shuffled instances associated with this application.*/@JsonProperty("instance")
publicList<InstanceInfo>getInstances() {
returnOptional.ofNullable(shuffledInstances.get()).orElseGet(this::getInstancesAsIsFromEureka);
    }
/**通过id获取实例信息* Get the instance info that matches the given id.** @param id*            the id for which the instance info needs to be returned.* @return the instance info object.*/publicInstanceInfogetByInstanceId(Stringid) {
returninstancesMap.get(id);
    }
    ...省略...
  }       

/**翻译：该类包装了由eureka服务器返回的所有注册表信息------------------------------------------------------------------------------* The class that wraps all the registry information returned by eureka server.翻译： EurekaClientConfig＃getRegistryFetchIntervalSeconds（） 方法从 Eureak Server获取服务注册列表，然后对服务进行过滤，按照(EurekaClientConfig#shouldFilterOnlyUpInstances())的规则过滤上线的服务------------------------------------------------------------------------------* <p>* Note that the registry information is fetched from eureka server as specified* in {@link EurekaClientConfig#getRegistryFetchIntervalSeconds()}. Once the* information is fetched it is shuffled and also filtered for instances with* {@link InstanceStatus#UP} status as specified by the configuration* {@link EurekaClientConfig#shouldFilterOnlyUpInstances()}.* </p>** @author Karthik Ranganathan**/@Serializer("com.netflix.discovery.converters.EntityBodyConverter")
@XStreamAlias("applications")
@JsonRootName("applications")
publicclassApplications {
privatestaticclassVipIndexSupport {
finalAbstractQueue<InstanceInfo>instances=newConcurrentLinkedQueue<>();
finalAtomicLongroundRobinIndex=newAtomicLong(0);
finalAtomicReference<List<InstanceInfo>>vipList=newAtomicReference<List<InstanceInfo>>(Collections.emptyList());
publicAtomicLonggetRoundRobinIndex() {
returnroundRobinIndex;
        }
publicAtomicReference<List<InstanceInfo>>getVipList() {
returnvipList;
        }
    }
privatestaticfinalStringSTATUS_DELIMITER="_";
privateStringappsHashCode;
privateLongversionDelta;
@XStreamImplicit//注册成功的服务的集合privatefinalAbstractQueue<Application>applications;
//注册成功的服务的集合，名字和服务对应关系privatefinalMap<String, Application>appNameApplicationMap;
privatefinalMap<String, VipIndexSupport>virtualHostNameAppMap;
privatefinalMap<String, VipIndexSupport>secureVirtualHostNameAppMap;
/**创建一个新的空的Eureka应用程序列表。* Create a new, empty Eureka application list.*/publicApplications() {
this(null, -1L, Collections.emptyList());
    }
/**这里是把注册成功的服务实例保存起来 registeredApplications是注册成功的实例* Note that appsHashCode and versionDelta key names are formatted in a* custom/configurable way.*/@JsonCreatorpublicApplications(@JsonProperty("appsHashCode") StringappsHashCode,
@JsonProperty("versionDelta") LongversionDelta,
@JsonProperty("application") List<Application>registeredApplications) {
this.applications=newConcurrentLinkedQueue<Application>();
this.appNameApplicationMap=newConcurrentHashMap<String, Application>();
this.virtualHostNameAppMap=newConcurrentHashMap<String, VipIndexSupport>();
this.secureVirtualHostNameAppMap=newConcurrentHashMap<String, VipIndexSupport>();
this.appsHashCode=appsHashCode;
this.versionDelta=versionDelta;
//添加到 队列中 applications 和  appNameApplicationMap map中for (Applicationapp : registeredApplications) {
this.addApplication(app);
        }
    }
    ...省略...
/**添加应用* Add the <em>application</em> to the list.** @param app*            the <em>application</em> to be added.*/publicvoidaddApplication(Applicationapp) {
appNameApplicationMap.put(app.getName().toUpperCase(Locale.ROOT), app);
addInstancesToVIPMaps(app, this.virtualHostNameAppMap, this.secureVirtualHostNameAppMap);
applications.add(app);
    }
/**获取所有注册成功的应用* Gets the list of all registered <em>applications</em> from eureka.** @return list containing all applications registered with eureka.*/@JsonProperty("application")
publicList<Application>getRegisteredApplications() {
returnnewArrayList<Application>(this.applications);
    }
/**根据名字获取注册成功的应用* Gets the list of all registered <em>applications</em> for the given* application name.** @param appName*            the application name for which the result need to be fetched.* @return the list of registered applications for the given application*         name.*/publicApplicationgetRegisteredApplications(StringappName) {
returnappNameApplicationMap.get(appName.toUpperCase(Locale.ROOT));
    }
//总共有多个个实例publicintsize() {
returnapplications.stream().mapToInt(Application::size).sum();
    }
//把应用的顺序打乱publicvoidshuffleInstances(booleanfilterUpInstances) {
shuffleInstances(filterUpInstances, false, null, null, null);
    }
}

@SingletonpublicclassApplicationInfoManager {
privatestaticfinalLoggerlogger=LoggerFactory.getLogger(ApplicationInfoManager.class);
privatestaticfinalInstanceStatusMapperNO_OP_MAPPER=newInstanceStatusMapper() {
@OverridepublicInstanceStatusmap(InstanceStatusprev) {
returnprev;
        }
    };
privatestaticApplicationInfoManagerinstance=newApplicationInfoManager(null, null, null);
//实例状态改变监听器protectedfinalMap<String, StatusChangeListener>listeners;
privatefinalInstanceStatusMapperinstanceStatusMapper;
//实例信息对象privateInstanceInfoinstanceInfo;
//实例配置对象privateEurekaInstanceConfigconfig;
    ...省略...
//注册元数据publicvoidregisterAppMetadata(Map<String, String>appMetadata) {
instanceInfo.registerRuntimeMetadata(appMetadata);
    }
//设置euerka状态改变publicsynchronizedvoidsetInstanceStatus(InstanceStatusstatus) {
InstanceStatusnext=instanceStatusMapper.map(status);
if (next==null) {
return;
        }
//设置状态InstanceStatusprev=instanceInfo.setStatus(next);
if (prev!=null) {
for (StatusChangeListenerlistener : listeners.values()) {
try {
//发布状态改变时间，对应的监听器会监听到该状态的改变listener.notify(newStatusChangeEvent(prev, next));
                } catch (Exceptione) {
logger.warn("failed to notify listener: {}", listener.getId(), e);
                }
            }
        }
    }
//注册状态改变的监听器publicvoidregisterStatusChangeListener(StatusChangeListenerlistener) {
listeners.put(listener.getId(), listener);
    }
//取消注册监听器publicvoidunregisterStatusChangeListener(StringlistenerId) {
listeners.remove(listenerId);
    }
/**如果EurekaInstanceConfig中配置数据改变，刷新数据中心的数据，做InstanceInfo数据刷新，发送给下一次心跳* Refetches the hostname to check if it has changed. If it has, the entire* <code>DataCenterInfo</code> is refetched and passed on to the eureka* server on next heartbeat.** see {@link InstanceInfo#getHostName()} for explanation on why the hostname is used as the default address*/publicvoidrefreshDataCenterInfoIfRequired() {
StringexistingAddress=instanceInfo.getHostName();
StringnewAddress;
if (configinstanceofRefreshableInstanceConfig) {
// Refresh data center info, and return up to date addressnewAddress= ((RefreshableInstanceConfig) config).resolveDefaultAddress(true);
        } else {
newAddress=config.getHostName(true);
        }
StringnewIp=config.getIpAddress();
if (newAddress!=null&&!newAddress.equals(existingAddress)) {
logger.warn("The address changed from : {} => {}", existingAddress, newAddress);
// :( in the legacy code here the builder is acting as a mutator.// This is hard to fix as this same instanceInfo instance is referenced elsewhere.// We will most likely re-write the client at sometime so not fixing for now.InstanceInfo.Builderbuilder=newInstanceInfo.Builder(instanceInfo);
builder.setHostName(newAddress).setIPAddr(newIp).setDataCenterInfo(config.getDataCenterInfo());
instanceInfo.setIsDirty();
        }
    }
//刷新租约信息，根据EurekaInstanceConfig重新设置LeaseInfopublicvoidrefreshLeaseInfoIfRequired() {
LeaseInfoleaseInfo=instanceInfo.getLeaseInfo();
if (leaseInfo==null) {
return;
        }
intcurrentLeaseDuration=config.getLeaseExpirationDurationInSeconds();
intcurrentLeaseRenewal=config.getLeaseRenewalIntervalInSeconds();
if (leaseInfo.getDurationInSecs() !=currentLeaseDuration||leaseInfo.getRenewalIntervalInSecs() !=currentLeaseRenewal) {
LeaseInfonewLeaseInfo=LeaseInfo.Builder.newBuilder()
                    .setRenewalIntervalInSecs(currentLeaseRenewal)
                    .setDurationInSecs(currentLeaseDuration)
                    .build();
instanceInfo.setLeaseInfo(newLeaseInfo);
instanceInfo.setIsDirty();
        }
    }
    ...省略...
   }