這篇文章給大家介紹怎么在SpringCloud中實現Eureka注冊，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

10年積累的成都網站設計、成都網站制作經驗，可以快速應對客戶對網站的新想法和需求。提供各種問題對應的解決方案。讓選擇我們的客戶得到更好、更有力的網絡服務。我雖然不認識你，你也不認識我。但先網站設計后付款的網站建設流程，更有嵊泗免費網站建設讓你可以放心的選擇與我們合作。

一、Eureka的服務端

eureka的服務端核心類是EurekaBootstrap，該類實現了一個ServletContextListener的監聽器。因此我們可以斷定eureka是基于servlet容器實現的。關鍵代碼如下：

public class EurekaBootStrap implements ServletContextListener { 
 //...省略相關代碼
/**
  * Initializes Eureka, including syncing up with other Eureka peers and publishing the registry.
  *
  * @see
  * javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent)
  */
 @Override
 public void contextInitialized(ServletContextEvent event) {
  try {
   initEurekaEnvironment();
   initEurekaServerContext();
   ServletContext sc = event.getServletContext();
   sc.setAttribute(EurekaServerContext.class.getName(), serverContext);
  } catch (Throwable e) {
   logger.error("Cannot bootstrap eureka server :", e);
   throw new RuntimeException("Cannot bootstrap eureka server :", e);
  }
 }
　　//省略相關代碼.....
}

我們可以看到在ServletContext初始化完成時，會初始化Eureka環境，然后初始化EurekaServerContext，那么我們在看一看initEurekaServerContext方法：

/**
  * init hook for server context. Override for custom logic.
  */
 protected void initEurekaServerContext() throws Exception {
　　　　// .....
  ApplicationInfoManager applicationInfoManager = null;

  if (eurekaClient == null) {
   EurekaInstanceConfig instanceConfig = isCloud(ConfigurationManager.getDeploymentContext())
     ? new CloudInstanceConfig()
     : new MyDataCenterInstanceConfig();
   
   applicationInfoManager = new ApplicationInfoManager(
     instanceConfig, new EurekaConfigBasedInstanceInfoProvider(instanceConfig).get());
   
   EurekaClientConfig eurekaClientConfig = new DefaultEurekaClientConfig();
   eurekaClient = new DiscoveryClient(applicationInfoManager, eurekaClientConfig);
  } else {
   applicationInfoManager = eurekaClient.getApplicationInfoManager();
  }

  PeerAwareInstanceRegistry registry;
  if (isAws(applicationInfoManager.getInfo())) {
   registry = new AwsInstanceRegistry(
     eurekaServerConfig,
     eurekaClient.getEurekaClientConfig(),
     serverCodecs,
     eurekaClient
   );
   awsBinder = new AwsBinderDelegate(eurekaServerConfig, eurekaClient.getEurekaClientConfig(), registry, applicationInfoManager);
   awsBinder.start();
  } else {
   registry = new PeerAwareInstanceRegistryImpl(
     eurekaServerConfig,
     eurekaClient.getEurekaClientConfig(),
     serverCodecs,
     eurekaClient
   );
  }

　　　　//....省略部分代碼
 }

在這個方法里會創建許多與eureka服務相關的對象，在這里我列舉了兩個核心對象分別是eurekaClient與PeerAwareInstanceRegistry，關于客戶端部分我們等會再說，我們現在來看看PeerAwareInstanceRegistry到底是做什么用的，這里我寫貼出關于這個類的類圖：

根據類圖我們可以清晰的發現PeerAwareInstanceRegistry的最頂層接口為LeaseManager與LookupService,其中LookupService定義了最基本的發現示例的行為而LeaseManager定義了處理客戶端注冊，續約，注銷等操作。那么在這篇文章我們還是重點關注一下LeaseManager的相關接口的實現。回過頭來我們在看PeerAwareInstanceRegistry，其實這個類用于多個節點下復制相關信息，比如說一個節點注冊續約與下線那么通過這個類將會相關復制(通知)到各個節點。我們來看看它是怎么處理客戶端注冊的：

 /**
  * Registers the information about the {@link InstanceInfo} and replicates
  * this information to all peer eureka nodes. If this is replication event
  * from other replica nodes then it is not replicated.
  *
  * @param info
  *   the {@link InstanceInfo} to be registered and replicated.
  * @param isReplication
  *   true if this is a replication event from other replica nodes,
  *   false otherwise.
  */
 @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);
 }

我們可以看到它調用了父類的register方法后又通過replicateToPeers復制對應的行為到其他節點，具體如何復制的先不在這里討論，我們重點來看看注冊方法，我們在父類里找到register()方法： 

 /**
  * Registers a new instance with a given duration.
  *
  * @see com.netflix.eureka.lease.LeaseManager#register(java.lang.Object, int, boolean)
  */
 public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
try {
   read.lock();
   Map<String, Lease<InstanceInfo>> gMap = registry.get(registrant.getAppName());
   REGISTER.increment(isReplication);
   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());
   // Retain the last dirty timestamp without overwriting it, if there is already a lease
   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.
    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.expectedNumberOfRenewsPerMin > 0) {
      // Since the client wants to cancel it, reduce the threshold
      // (1
      // for 30 seconds, 2 for a minute)
      this.expectedNumberOfRenewsPerMin = this.expectedNumberOfRenewsPerMin + 2;
      this.numberOfRenewsPerMinThreshold =
        (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
     }
    }
    logger.debug("No previous lease information found; it is new registration");
   }
   Lease<InstanceInfo> lease = new Lease<InstanceInfo>(registrant, leaseDuration);
   if (existingLease != null) {
    lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());
   }
   gMap.put(registrant.getId(), lease);
 
   //。。。省略部分代碼
}

通過源代碼，我們來簡要梳理一下流程：

1）首先根據appName獲取一些列的服務實例對象，如果為Null,則新創建一個map并把當前的注冊應用程序信息添加到此Map當中，這里有一個Lease對象，這個類描述了泛型T的時間屬性，比如說注冊時間，服務啟動時間，最后更新時間等，大家可以關注一下它的實現：

/*
 * Copyright 2012 Netflix, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.netflix.eureka.lease;

import com.netflix.eureka.registry.AbstractInstanceRegistry;

/**
 * Describes a time-based availability of a {@link T}. Purpose is to avoid
 * accumulation of instances in {@link AbstractInstanceRegistry} as result of ungraceful
 * shutdowns that is not uncommon in AWS environments.
 *
 * If a lease elapses without renewals, it will eventually expire consequently
 * marking the associated {@link T} for immediate eviction - this is similar to
 * an explicit cancellation except that there is no communication between the
 * {@link T} and {@link LeaseManager}.
 *
 * @author Karthik Ranganathan, Greg Kim
 */
public class Lease<T> {

 enum Action {
  Register, Cancel, Renew
 };

 public static final int DEFAULT_DURATION_IN_SECS = 90;

 private T holder;
 private long evictionTimestamp;
 private long registrationTimestamp;
 private long serviceUpTimestamp;
 // Make it volatile so that the expiration task would see this quicker
 private volatile long lastUpdateTimestamp;
 private long duration;

 public Lease(T r, int durationInSecs) {
  holder = r;
  registrationTimestamp = System.currentTimeMillis();
  lastUpdateTimestamp = registrationTimestamp;
  duration = (durationInSecs * 1000);

 }

 /**
  * Renew the lease, use renewal duration if it was specified by the
  * associated {@link T} during registration, otherwise default duration is
  * {@link #DEFAULT_DURATION_IN_SECS}.
  */
 public void renew() {
  lastUpdateTimestamp = System.currentTimeMillis() + duration;

 }

 /**
  * Cancels the lease by updating the eviction time.
  */
 public void cancel() {
  if (evictionTimestamp <= 0) {
   evictionTimestamp = System.currentTimeMillis();
  }
 }

 /**
  * Mark the service as up. This will only take affect the first time called,
  * subsequent calls will be ignored.
  */
 public void serviceUp() {
  if (serviceUpTimestamp == 0) {
   serviceUpTimestamp = System.currentTimeMillis();
  }
 }

 /**
  * Set the leases service UP timestamp.
  */
 public void setServiceUpTimestamp(long serviceUpTimestamp) {
  this.serviceUpTimestamp = serviceUpTimestamp;
 }

 /**
  * Checks if the lease of a given {@link com.netflix.appinfo.InstanceInfo} has expired or not.
  */
 public boolean isExpired() {
  return isExpired(0l);
 }

 /**
  * Checks if the lease of a given {@link com.netflix.appinfo.InstanceInfo} has expired or not.
  *
  * Note that due to renew() doing the 'wrong" thing and setting lastUpdateTimestamp to +duration more than
  * what it should be, the expiry will actually be 2 * duration. This is a minor bug and should only affect
  * instances that ungracefully shutdown. Due to possible wide ranging impact to existing usage, this will
  * not be fixed.
  *
  * @param additionalLeaseMs any additional lease time to add to the lease evaluation in ms.
  */
 public boolean isExpired(long additionalLeaseMs) {
  return (evictionTimestamp > 0 || System.currentTimeMillis() > (lastUpdateTimestamp + duration + additionalLeaseMs));
 }

 /**
  * Gets the milliseconds since epoch when the lease was registered.
  *
  * @return the milliseconds since epoch when the lease was registered.
  */
 public long getRegistrationTimestamp() {
  return registrationTimestamp;
 }

 /**
  * Gets the milliseconds since epoch when the lease was last renewed.
  * Note that the value returned here is actually not the last lease renewal time but the renewal + duration.
  *
  * @return the milliseconds since epoch when the lease was last renewed.
  */
 public long getLastRenewalTimestamp() {
  return lastUpdateTimestamp;
 }

 /**
  * Gets the milliseconds since epoch when the lease was evicted.
  *
  * @return the milliseconds since epoch when the lease was evicted.
  */
 public long getEvictionTimestamp() {
  return evictionTimestamp;
 }

 /**
  * Gets the milliseconds since epoch when the service for the lease was marked as up.
  *
  * @return the milliseconds since epoch when the service for the lease was marked as up.
  */
 public long getServiceUpTimestamp() {
  return serviceUpTimestamp;
 }

 /**
  * Returns the holder of the lease.
  */
 public T getHolder() {
  return holder;
 }

}

2）根據當前注冊的ID，如果能在map中取到則做以下操作：

2.1）根據當前存在節點的觸碰時間和注冊節點的觸碰時間比較，如果前者的時間晚于后者的時間，那么當前注冊的實例就以已存在的實例為準

2.2）否則更新其每分鐘期望的續約數量及其閾值

3）將當前的注冊節點存到map當中，至此我們的注冊過程基本告一段落了

二、eureka客戶端

在服務端servletContext初始化完畢時，會創建DiscoveryClient。熟悉eureka的朋友，一定熟悉這兩個屬性：fetchRegistry與registerWithEureka。在springcloud中集成eureka獨立模式運行時，如果這兩個值不為false，那么啟動會報錯，為什么會報錯呢？其實答案就在DiscoveryClient的構造函數中：

 @Inject
 DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
     Provider<BackupRegistry> backupRegistryProvider) {

//....省略部分代碼

  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();
   logger.info("Discovery Client initialized at timestamp {} with initial instances count: {}",
     initTimestampMs, this.getApplications().size());

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

  　　　　//....省略部分代碼
  　　initScheduledTasks();
 

 //....
}

根據源代碼，我們可以得出以下結論：

1）如果shouldRegisterWithEureka與shouldFetchRegistry都為false,那么直接return。

2）創建發送心跳與刷新緩存的線程池

3）初始化創建的定時任務

那么我們在看看initScheduledTasks()方法里有如下代碼：

 // Heartbeat timer
   scheduler.schedule(
     new TimedSupervisorTask(
       "heartbeat",
       scheduler,
       heartbeatExecutor,
       renewalIntervalInSecs,
       TimeUnit.SECONDS,
       expBackOffBound,
       new HeartbeatThread()
     ),
     renewalIntervalInSecs, TimeUnit.SECONDS);

此處是觸發一個定時執行的線程，以秒為單位，根據renewalIntervalInSecs值定時執行發送心跳，HeartbeatThread線程執行如下：

 /**
  * The heartbeat task that renews the lease in the given intervals.
  */
 private class HeartbeatThread implements Runnable {

  public void run() {
   if (renew()) {
    lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
   }
  }
 }

我們可以看到run方法里很簡單執行renew方法，如果成功記錄一下時間。renew方法：

 /**
  * Renew with the eureka service by making the appropriate REST call
  */
 boolean renew() {
  EurekaHttpResponse<InstanceInfo> httpResponse;
  try {
   httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);
   logger.debug("{} - Heartbeat status: {}", PREFIX + appPathIdentifier, httpResponse.getStatusCode());
   if (httpResponse.getStatusCode() == 404) {
    REREGISTER_COUNTER.increment();
    logger.info("{} - Re-registering apps/{}", PREFIX + appPathIdentifier, instanceInfo.getAppName());
    long timestamp = instanceInfo.setIsDirtyWithTime();
    boolean success = register();
    if (success) {
     instanceInfo.unsetIsDirty(timestamp);
    }
    return success;
   }
   return httpResponse.getStatusCode() == 200;
  } catch (Throwable e) {
   logger.error("{} - was unable to send heartbeat!", PREFIX + appPathIdentifier, e);
   return false;
  }
 }

在這里發送心跳如果返回的是404，那么會執行注冊操作，注意我們根據返回值httpResponse可以斷定這一切的操作都是基于http請求的，到底是不是呢？我們繼續看一下register方法：

 /**
  * Register with the eureka service by making the appropriate REST call.
  */
 boolean register() throws Throwable {
  logger.info(PREFIX + appPathIdentifier + ": registering service...");
  EurekaHttpResponse<Void> httpResponse;
  try {
   httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
  } catch (Exception e) {
   logger.warn("{} - registration failed {}", PREFIX + appPathIdentifier, e.getMessage(), e);
   throw e;
  }
  if (logger.isInfoEnabled()) {
   logger.info("{} - registration status: {}", PREFIX + appPathIdentifier, httpResponse.getStatusCode());
  }
  return httpResponse.getStatusCode() == 204;
 }

在這里又調用了eurekaTransport里registrationClient的方法：

private static final class EurekaTransport {
  private ClosableResolver bootstrapResolver;
  private TransportClientFactory transportClientFactory;

  private EurekaHttpClient registrationClient;
  private EurekaHttpClientFactory registrationClientFactory;

  private EurekaHttpClient queryClient;
  private EurekaHttpClientFactory queryClientFactory;

  void shutdown() {
   if (registrationClientFactory != null) {
    registrationClientFactory.shutdown();
   }

   if (queryClientFactory != null) {
    queryClientFactory.shutdown();
   }

   if (registrationClient != null) {
    registrationClient.shutdown();
   }

   if (queryClient != null) {
    queryClient.shutdown();
   }

   if (transportClientFactory != null) {
    transportClientFactory.shutdown();
   }

   if (bootstrapResolver != null) {
    bootstrapResolver.shutdown();
   }
  }
 }

在這里我們可以看到，eureka的客戶端是使用http請求進行注冊服務的，也就是說當我們創建DiscoveryClient就會向服務端進行實例的注冊。

三、服務端提供的rest服務

服務端提供用于處理客戶端注冊請求的代碼我們已經看過了，既然客戶端是通過走HTTP協議進行注冊的，那服務端總要有處理這個http請求的地址吧，其實eureka服務端是采用jax-rs標準提供rest方式進行暴露服務的，我們可以看一下這個類ApplicationResoure的addInstance方法:

 /**
  * Registers information about a particular instance for an
  * {@link com.netflix.discovery.shared.Application}.
  *
  * @param info
  *   {@link InstanceInfo} information of the instance.
  * @param isReplication
  *   a header parameter containing information whether this is
  *   replicated from other nodes.
  */
 @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);
  // validate that the instanceinfo contains all the necessary required fields
  if (isBlank(info.getId())) {
   return Response.status(400).entity("Missing instanceId").build();
  } else if (isBlank(info.getHostName())) {
   return Response.status(400).entity("Missing hostname").build();
  } else if (isBlank(info.getIPAddr())) {
   return Response.status(400).entity("Missing ip address").build();
  } else if (isBlank(info.getAppName())) {
   return Response.status(400).entity("Missing appName").build();
  } else if (!appName.equals(info.getAppName())) {
   return Response.status(400).entity("Mismatched appName, expecting " + appName + " but was " + info.getAppName()).build();
  } else if (info.getDataCenterInfo() == null) {
   return Response.status(400).entity("Missing dataCenterInfo").build();
  } else if (info.getDataCenterInfo().getName() == null) {
   return Response.status(400).entity("Missing dataCenterInfo Name").build();
  }

  // handle cases where clients may be registering with bad DataCenterInfo with missing data
  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());
    }
   }
  }

  registry.register(info, "true".equals(isReplication));
  return Response.status(204).build(); // 204 to be backwards compatible
 }

關于怎么在SpringCloud中實現Eureka注冊就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。

文章名稱：怎么在SpringCloud中實現Eureka注冊
文章轉載：http://www.yijiale78.com/article4/pcpjie.html

成都網站建設公司_創新互聯，為您提供網站設計、服務器托管、企業建站、網頁設計公司、用戶體驗、App設計

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯