Eureka 源碼解析 —— Eureka-Client 初始化（三）之 EurekaClient

原創 cyq12345_ 2020-02-21 05:06

摘要: 原創出處 http://www.iocoder.cn/Eureka/eureka-client-init-third/ 「芋道源碼」歡迎轉載，保留摘要，謝謝！

本文主要基於 Eureka 1.8.X 版本

  1. 創建 EurekaInstanceConfig對象
  2. 使用 EurekaInstanceConfig對象 創建 InstanceInfo對象
  3. 使用 EurekaInstanceConfig對象 + InstanceInfo對象 創建 ApplicationInfoManager對象
  4. 創建 EurekaClientConfig對象
  5. 使用 ApplicationInfoManager對象 + EurekaClientConfig對象 創建 EurekaClient對象

考慮到整個初始化的過程中涉及的配置特別多，拆分成三篇文章：

  1. （一）EurekaInstanceConfig)
  2. （二）EurekaClientConfig
  3. 【本文】（三）EurekaClient

下面我們來看看每個類的實現。

推薦 Spring Cloud 書籍：

2. EurekaClient

com.netflix.discovery.EurekaClient，Eureka-Client 接口，聲明如下方法：

  • 提供多種方法獲取應用集合(com.netflix.discovery.shared.Applications) 和 應用實例信息集合( com.netflix.appinfo.InstanceInfo )。
  • 提供方法獲取本地客戶端信息，例如，應用管理器( com.netflix.appinfo.ApplicationInfoManager )和 Eureka-Client 配置( com.netflix.discovery.EurekaClientConfig )。
  • 提供方法註冊本地客戶端的健康檢查和 Eureka 事件監聽器。

另外，Eureka 2.X 版本正在開發，該接口爲 Eureka 1.X 和 2.X 提供平滑過渡接口。

This interface does NOT try to clean up the current client interface for eureka 1.x. Rather it tries to provide an easier transition path from eureka 1.x to eureka 2.x.

2.1 LookupService

com.netflix.discovery.shared.LookupService，查找服務接口，提供簡單單一的方式獲取應用集合(com.netflix.discovery.shared.Applications) 和 應用實例信息集合( com.netflix.appinfo.InstanceInfo )。

  • 在 Eureka-Client 裏，EurekaClient 繼承該接口。
  • 在 Eureka-Server 裏，com.netflix.eureka.registry.InstanceRegistry 繼承該接口。

3. DiscoveryClient

com.netflix.discovery.DiscoveryClient，實現 EurekaClient 接口，用於與 Eureka-Server 交互。實現如下方法：

  • 向 Eureka-Server 註冊自身服務
  • 向 Eureka-Server 續約自身服務
  • 向 Eureka-Server 取消自身服務，當關閉時
  • 從 Eureka-Server 查詢應用集合和應用實例信息
  • 簡單來理解，對 Eureka-Server 服務的增刪改查

3.1 構造方法參數

DiscoveryClient 完整構造方法需要傳入四個參數，實現代碼如下：


DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
                    Provider<BackupRegistry> backupRegistryProvider) {
     // .... 省略代碼
}
  • ApplicationInfoManager，在《Eureka 源碼解析 —— Eureka-Client 初始化（一）之 EurekaInstanceConfig》有詳細解析。
  • EurekaClientConfig，在《Eureka 源碼解析 —— Eureka-Client 初始化（二）之 EurekaClientConfig》有詳細解析。

  • com.netflix.discovery.BackupRegistry，備份註冊中心接口。當 Eureka-Client 啓動時，無法從 Eureka-Server 讀取註冊信息（可能掛了），從備份註冊中心讀取註冊信息。實現代碼如下：

    // BackupRegistry.java
    public interface BackupRegistry {
        Applications fetchRegistry();
        Applications fetchRegistry(String[] includeRemoteRegions);
    }
    // NotImplementedRegistryImpl.java
    public class NotImplementedRegistryImpl implements BackupRegistry {
        @Override
        public Applications fetchRegistry() {
            return null;
        }
        @Override
        public Applications fetchRegistry(String[] includeRemoteRegions) {
            return null;
        }
    }
    • 從 com.netflix.discovery.NotImplementedRegistryImpl 可以看出，目前 Eureka-Client 未提供合適的默認實現。

  • com.netflix.discovery.AbstractDiscoveryClientOptionalArgs，DiscoveryClient 可選參數抽象基類。不同於上面三個必填參數，該參數是選填參數，實際生產下使用較少。實現代碼如下：


    public abstract class AbstractDiscoveryClientOptionalArgs<T> {
        /
         * 生成健康檢查回調的工廠
         /
        Provider<HealthCheckCallback> healthCheckCallbackProvider;
        /
          生成健康檢查處理器的工廠
         /
        Provider<HealthCheckHandler> healthCheckHandlerProvider;
        /
          向 Eureka-Server 註冊之前的處理器
         /
        PreRegistrationHandler preRegistrationHandler;
        /
          Jersey 過濾器集合
         /
        Collection<T> additionalFilters;
        /
          Jersey 客戶端
         /
        EurekaJerseyClient eurekaJerseyClient;
        /
          生成 Jersey 客戶端的工廠的工廠
         /
        TransportClientFactories transportClientFactories;
        /*
         * Eureka 事件監聽器集合
         */
        private Set<EurekaEventListener> eventListeners;
    }
    • com.netflix.appinfo.HealthCheckCallback，健康檢查回調接口，目前已經廢棄，使用 HealthCheckHandler 替代，你可以不關注該參數。

    • com.netflix.appinfo.HealthCheckHandler，健康檢查處理器接口，目前暫未提供合適的默認實現，唯一提供的 com.netflix.appinfo.HealthCheckCallbackToHandlerBridge，用於將 HealthCheckCallback 橋接成 HealthCheckHandler，實現代碼如下：

      // HealthCheckHandler.java
      public interface HealthCheckHandler {
          
          InstanceInfo.InstanceStatus getStatus(InstanceInfo.InstanceStatus currentStatus);
      }
      // HealthCheckCallbackToHandlerBridge.java
      public class HealthCheckCallbackToHandlerBridge implements HealthCheckHandler {
          private final HealthCheckCallback callback;
          public HealthCheckCallbackToHandlerBridge() {
              callback = null;
          }
          public HealthCheckCallbackToHandlerBridge(HealthCheckCallback callback) {
              this.callback = callback;
          }
          @Override
          public InstanceInfo.InstanceStatus getStatus(InstanceInfo.InstanceStatus currentStatus) {
              if (null == callback || InstanceInfo.InstanceStatus.STARTING == currentStatus
                      || InstanceInfo.InstanceStatus.OUT_OF_SERVICE == currentStatus) { // Do not go to healthcheck handler if the status is starting or OOS.
                  return currentStatus;
              }
              return callback.isHealthy() ? InstanceInfo.InstanceStatus.UP : InstanceInfo.InstanceStatus.DOWN;
          }
      }

    • com.netflix.discovery.PreRegistrationHandler，向 Eureka-Server 註冊之前的處理器接口，目前暫未提供默認實現。通過實現該接口，可以在註冊前做一些自定義的處理。實現代碼如下：


      public interface PreRegistrationHandler {
          
          void beforeRegistration();
      }
      • x

      • additionalFilters，Jersey 過濾器集合。這裏聲明泛型 <T> 的原因，Jersey 1.X 和 Jersey 2.X 的過濾器接口不同，通過泛型來支持。實現代碼如下：

        // Jersey1DiscoveryClientOptionalArgs.java
        public class Jersey1DiscoveryClientOptionalArgs extends AbstractDiscoveryClientOptionalArgs<ClientFilter> {
         }
         
        // Jersey2DiscoveryClientOptionalArgs.java
        public class Jersey2DiscoveryClientOptionalArgs extends AbstractDiscoveryClientOptionalArgs<ClientRequestFilter> {
         }
         
        // DiscoveryClientOptionalArgs.java
        public static class DiscoveryClientOptionalArgs extends Jersey1DiscoveryClientOptionalArgs {
        }
        • Jersey 1.X 使用 ClientFilter 。ClientFilter 目前有兩個過濾器實現：EurekaIdentityHeaderFilter 、DynamicGZIPContentEncodingFilter 。
        • Jersey 2.X 使用 ClientRequestFilter 。
        • DiscoveryClient 使用 DiscoveryClientOptionalArgs，即 Jersey 1.X 。


    • eurekaJerseyClient，Jersey 客戶端。該參數目前廢棄，使用下面 TransportClientFactories 參數來進行生成。

    • com.netflix.discovery.shared.transport.jersey.TransportClientFactories，生成 Jersey 客戶端工廠的工廠接口。目前有 Jersey1TransportClientFactories 、Jersey2TransportClientFactories 兩個實現。TransportClientFactories 實現代碼如下：

      // TransportClientFactories.java
      public interface TransportClientFactories<F> {
        
            @Deprecated
            TransportClientFactory newTransportClientFactory(final Collection<F> additionalFilters,
                                                             final EurekaJerseyClient providedJerseyClient);
        
            TransportClientFactory newTransportClientFactory(final EurekaClientConfig clientConfig,
                                                             final Collection<F> additionalFilters,
                                                             final InstanceInfo myInstanceInfo);
      }
      // TransportClientFactory.java
      public interface TransportClientFactory {
            EurekaHttpClient newClient(EurekaEndpoint serviceUrl);
          
            void shutdown();
          
      }
      • 第一個方法已經廢棄，這就是爲什麼說上面的 eurekaJerseyClient 參數( 不是 EurekaJerseyClient 類)已經廢棄，被第二個方法取代。相比來說，第二個方法對 EurekaJerseyClient 創建封裝會更好。

    • com.netflix.discovery.EurekaEventListener，Eureka 事件監聽器。實現代碼如下：


      // EurekaEventListener.java
      public interface EurekaEventListener {
      }
      // EurekaEvent.java
      public interface EurekaEvent {
      }
      // DiscoveryEvent.java
      public abstract class DiscoveryEvent implements EurekaEvent {
             private final long timestamp;
      }



3.2 構造方法

DiscoveryClient 的構造方法實現代碼相對較多，已經將代碼切塊 + 中文註冊，點擊 DiscoveryClient 鏈接，對照下面每個小結閱讀理解。


3.2.1 賦值 AbstractDiscoveryClientOptionalArgs

// DiscoveryClient.java 構造方法
if (args != null) {
  this.healthCheckHandlerProvider = args.healthCheckHandlerProvider;
  this.healthCheckCallbackProvider = args.healthCheckCallbackProvider;
  this.eventListeners.addAll(args.getEventListeners());
  this.preRegistrationHandler = args.preRegistrationHandler;
} else {
  this.healthCheckCallbackProvider = null;
  this.healthCheckHandlerProvider = null;
  this.preRegistrationHandler = null;
}

3.2.2 賦值 ApplicationInfoManager、EurekaClientConfig

// DiscoveryClient.java 構造方法
this.applicationInfoManager = applicationInfoManager;
InstanceInfo myInfo = applicationInfoManager.getInfo();
clientConfig = config;
staticClientConfig = clientConfig;
transportConfig = config.getTransportConfig();
instanceInfo = myInfo;
if (myInfo != null) {
  appPathIdentifier = instanceInfo.getAppName() + "/" + instanceInfo.getId(); // 無實際業務用途，用於打 logger
} else {
  logger.warn("Setting instanceInfo to a passed in null value");
}

3.2.3 賦值 BackupRegistry

this.backupRegistryProvider = backupRegistryProvider;

3.2.4 初始化 InstanceInfoBasedUrlRandomizer

TODO[0016]：InstanceInfoBasedUrlRandomizer


this.urlRandomizer = new EndpointUtils.InstanceInfoBasedUrlRandomizer(instanceInfo);

3.2.5 初始化 Applications 在本地的緩存

// DiscoveryClient.java 變量
/
* Applications 在本地的緩存
/
private final AtomicReference<Applications> localRegionApps = new AtomicReference<Applications>();
/
 拉取註冊信息次數
* monotonically increasing generation counter to ensure stale threads do not reset registry to an older version
*/
private final AtomicLong fetchRegistryGeneration;
// DiscoveryClient.java 構造方法
localRegionApps.set(new Applications());
fetchRegistryGeneration = new AtomicLong(0);

3.2.6 獲取哪些 Region 集合的註冊信息

// DiscoveryClient.java 變量
/
* 獲取哪些區域( Region )集合的註冊信息
/
private final AtomicReference<String> remoteRegionsToFetch;
/
 獲取哪些區域( Region )集合的註冊信息
*/
private final AtomicReference<String[]> remoteRegionsRef;
// DiscoveryClient.java 構造方法
remoteRegionsToFetch = new AtomicReference<>(clientConfig.fetchRegistryForRemoteRegions());
remoteRegionsRef = new AtomicReference<>(remoteRegionsToFetch.get() == null ? null : remoteRegionsToFetch.get().split(","));

3.2.7 初始化拉取、心跳的監控

// DiscoveryClient.java 變量
/
* 最後成功從 Eureka-Server 拉取註冊信息時間戳
/
private volatile long lastSuccessfulRegistryFetchTimestamp = -1;
/
 最後成功向 Eureka-Server 心跳時間戳
/
private volatile long lastSuccessfulHeartbeatTimestamp = -1;
/
 心跳監控
/
private final ThresholdLevelsMetric heartbeatStalenessMonitor;
/
 拉取監控
*/
private final ThresholdLevelsMetric registryStalenessMonitor;
// DiscoveryClient.java 構造方法
if (config.shouldFetchRegistry()) {
  this.registryStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRY_PREFIX + "lastUpdateSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
} else {
  this.registryStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
}
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;
}

  • 每次成功向 Eureka-Serve 心跳或者從從 Eureka-Server 拉取註冊信息後，都會更新相應時間戳。
  • 配合 Netflix Servo 實現監控信息採集。
  • 對 com.netflix.discovery.util.ThresholdLevelsMetric 感興趣的同學可以點擊鏈接查看。本文暫不拓展開，後面另開文章分享。（TODO[0012]：監控相關）

3.2.8 結束初始化，當無需和 Eureka-Server 交互

// DiscoveryClient.java 構造方法
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
}

3.2.9 初始化線程池

// DiscoveryClient.java 變量
/
* 線程池
 A scheduler to be used for the following 3 tasks: 【目前只有兩個】
* - updating service urls
* - scheduling a TimedSuperVisorTask
/
private final ScheduledExecutorService scheduler;
// additional executors for supervised subtasks
/
 心跳執行器
/
private final ThreadPoolExecutor heartbeatExecutor;
/*
* {@link #localRegionApps} 刷新執行器
*/
private final ThreadPoolExecutor cacheRefreshExecutor;
// DiscoveryClient.java 構造方法
// 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

  • scheduler，定時任務線程池，初始化大小爲 2，一個給 heartbeatExecutor，一個給 cacheRefreshExecutor。
  • heartbeatExecutor、cacheRefreshExecutor 在提交給 scheduler 才聲明具體的任務。

3.2.10 初始化 Eureka 網絡通信相關

// DiscoveryClient.java 構造方法
eurekaTransport = new EurekaTransport();
scheduleServerEndpointTask(eurekaTransport, args);

3.2.11 初始化 InstanceRegionChecker

// DiscoveryClient.java 構造方法
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());

  • com.netflix.discovery.AzToRegionMapper，主要用於亞馬遜 AWS，跳過。

  • com.netflix.discovery.InstanceRegionChecker，應用實例信息區域( region )校驗，實現代碼如下：

    public class InstanceRegionChecker {
        // ... 省略和亞馬遜 AWS 相關的屬性和方法
        /**
         * 本地區域( Region )
         */
        private final String localRegion;
        public boolean isLocalRegion(@Nullable String instanceRegion) {
            return null == instanceRegion || instanceRegion.equals(localRegion); // no region == local
        }
        public String getLocalRegion() {
            return localRegion;
        }
    }

3.2.12 從 Eureka-Server 拉取註冊信息

// DiscoveryClient.java 構造方法
if (clientConfig.shouldFetchRegistry() && !fetchRegistry(false)) {
  fetchRegistryFromBackup();
}

  • 調用 #fetchRegistry(false) 方法，從 Eureka-Server 初始拉取註冊信息。在（TO後文鏈接）詳細解析。

  • 調用 #fetchRegistryFromBackup() 方法，若初始拉取註冊信息失敗，從備份註冊中心獲取。實現代碼如下：

    // DiscoveryClient.java
    private void fetchRegistryFromBackup() {
        try {
            @SuppressWarnings("deprecation")
            BackupRegistry backupRegistryInstance = newBackupRegistryInstance();
            if (null == backupRegistryInstance) { // backward compatibility with the old protected method, in case it is being used.
                backupRegistryInstance = backupRegistryProvider.get();
            }
            if (null != backupRegistryInstance) {
                Applications apps = null;
                if (isFetchingRemoteRegionRegistries()) {
                    String remoteRegionsStr = remoteRegionsToFetch.get();
                    if (null != remoteRegionsStr) {
                        apps = backupRegistryInstance.fetchRegistry(remoteRegionsStr.split(","));
                    }
                } else {
                    apps = backupRegistryInstance.fetchRegistry();
                }
                if (apps != null) {
                    final Applications applications = this.filterAndShuffle(apps);
                    applications.setAppsHashCode(applications.getReconcileHashCode());
                    localRegionApps.set(applications);
                    logTotalInstances();
                    logger.info("Fetched registry successfully from the backup");
                }
            } else {
                logger.warn("No backup registry instance defined & unable to find any discovery servers.");
            }
        } catch (Throwable e) {
            logger.warn("Cannot fetch applications from apps although backup registry was specified", e);
        }
    }
    • BackupRegistry 目前暫未提供默認實現，需要自行相關邏輯。


3.2.13 執行向 Eureka-Server 註冊之前的處理器

// DiscoveryClient.java 構造方法
// call and execute the pre registration handler before all background tasks (inc registration) is started
if (this.preRegistrationHandler != null) {
  this.preRegistrationHandler.beforeRegistration();
}

3.2.14 初始化定時任務

// DiscoveryClient.java 構造方法
initScheduledTasks();
// DiscoveryClient.java
private void initScheduledTasks() {
   // 從 Eureka-Server 拉取註冊信息執行器
   if (clientConfig.shouldFetchRegistry()) {
       // registry cache refresh timer
       int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
       int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
       scheduler.schedule(
               new TimedSupervisorTask(
                       "cacheRefresh",
                       scheduler,
                       cacheRefreshExecutor,
                       registryFetchIntervalSeconds,
                       TimeUnit.SECONDS,
                       expBackOffBound,
                       new CacheRefreshThread()
               ),
               registryFetchIntervalSeconds, TimeUnit.SECONDS);
   }
   // 向 Eureka-Server 心跳（續租）執行器
   if (clientConfig.shouldRegisterWithEureka()) {
       int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
       int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
       logger.info("Starting heartbeat executor: " + "renew interval is: " + renewalIntervalInSecs);
       // Heartbeat timer
       scheduler.schedule(
               new TimedSupervisorTask(
                       "heartbeat",
                       scheduler,
                       heartbeatExecutor,
                       renewalIntervalInSecs,
                       TimeUnit.SECONDS,
                       expBackOffBound,
                       new HeartbeatThread()
               ),
               renewalIntervalInSecs, TimeUnit.SECONDS);
       // InstanceInfo replicator
       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) {
               if (InstanceStatus.DOWN == statusChangeEvent.getStatus() ||
                       InstanceStatus.DOWN == statusChangeEvent.getPreviousStatus()) {
                   // log at warn level if DOWN was involved
                   logger.warn("Saw local status change event {}", statusChangeEvent);
               } else &#12#123;
                   logger.info("Saw local status change event {}", statusChangeEvent);
               }
               instanceInfoReplicator.onDemandUpdate();
           }
       };
       if (clientConfig.shouldOnDemandUpdateStatusChange()) {
           applicationInfoManager.registerStatusChangeListener(statusChangeListener);
       }
       instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
   } else {
       logger.info("Not registering with Eureka server per configuration");
   }
}

3.2.15 向 Servo 註冊監控

// DiscoveryClient.java 構造方法
try {
  Monitors.registerObject(this);
} catch (Throwable e) {
  logger.warn("Cannot register timers", e);
}

3.2.16 初始化完成

// DiscoveryClient.java 變量
/*
 初始化完成時間戳
*/
private final long initTimestampMs;
// DiscoveryClient.java 構造方法
// 【3.2.16】初始化完成
// 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());

cyq12345_
發佈了22 篇原創文章 · 獲贊 2 · 訪問量 4萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

（三）java版spring cloud+spring boot+redis多租戶社交電子商務平臺-Spring Cloud實戰隨機端口

我們經常會需要啓動多個實例的情況來測試註冊中心、配置中心等基礎設施的高可用，也會用來測試客戶端負載均衡的調用等。但是，我們一個應用只能有一個端口號，這就使得在本機測試的時候，不得不爲同一個服務設置不同的端口來進行啓動。 在本地用不同端口啓動

原創 2023-10-10 11:05:04

微服務（微服務入門+eureka）

什麼是微服務 大型系統架構中，會拆分多個子系統。簡單來說，這些子系統有兩個功能：提供接口、調用接口，在微服務架構中，將每一個這樣的子系統稱爲一個“微服務”； 每一個服務會部署多個實例（就是多臺機器，且會動態擴容，IP不固定）； 這種情況下

原創 2021-01-30 10:55:25

Spring cloud 使用 Ribbon 來實現客戶端負載均衡

@[toc] Spring cloud 使用 Ribbon 來實現客戶端負載均衡 前言 在Spring cloud 中當統一類型多個服務開始註冊到服務註冊中心中，次數服務即是集羣 消費端（客戶端）消費的時候需要進行選擇調用服務。 服務註冊

原創 2021-01-30 09:26:51

Spring cloud eureka 高可用集羣配置

Spring cloud eureka 高可用集羣配置 前言 eureka 註冊中心單機模式，容災性低，註冊服務多，單個節點性能低，容易發生故障，甚至崩潰等。 生產中我採用集羣模式，也就是eureka的高可用。 如何搭建高可用集羣配置 僅僅

原創 2021-01-30 09:26:50

大話微服務配置中心：Eureka Server與Eureka Client的契約（Lease.class）

Eureka Server與Eureka Client之間簽訂了一個契約（Lease.class），這是它們之間正常運轉的根基。 寒來暑往，年復一年，由於契約的存在，微服務系統得以提供穩定的發現註冊服務。 以心跳續約爲例，Eureka C

春秋战国程序猿 2020-07-08 00:17:07

自己動手，使用Spring Initializr從零開始搭建Spring Cloud項目

  新建Project   這裏使用的開發工具是IDEA，JDK版本1.8。 打開IDEA開發工具，File -> New -> Project    然後一步步往下設置，然後到這一步，選擇Spring Cloud   OK，繼續一路

春秋战国程序猿 2020-07-08 00:17:06

一張圖搞定Eureka Client啓動、註冊、心跳流程

Eureka Client啓動流程圖 註冊流程圖 心跳流程圖

爱上编程的小白 2020-07-05 21:08:18

三、Spring Cloud微服務環境搭建

  ——註冊中心部署（Eureka） 1 代碼獲取  git clone http://172.168.254.12/JAVA/lightapp/lightapp-eureka.git  分支： develop -開發環境      te

djch0319 2020-07-05 15:18:49

SpringCloud學習筆記(三) Eureka服務註冊與發現

Eureka是什麼 Eureka是Netflix的一個子模塊，也是核心模塊之一。 Eureka是一個基於REST的服務，用於定位服務，以實現雲端中間層服務發現和故障轉移。服務註冊與發現對於微服務架構來說是非常重要的，有了服務發現

Shinka_YXS 2020-07-03 15:25:49

Eureka參數詳解，緩存機制，及生產環境最佳配置

Eureka作爲spring cloud微服務架構裏的註冊中心，是非常核心的一個組件，它避免了複雜的選主算法，架構比較簡單，搭個demo也確實很快，但是如果要用於生產環境，還是得注意很多東西，尤其是下線延遲…    服務獲取中的緩存問題

现象挖掘机 2020-07-03 06:14:04

Eureka配置報錯Unable to start web server;

報錯信息如下： org.springframework.context.ApplicationContextException: Unable to start web server; nested exception is org.s

不是吧，阿sir 2020-07-03 06:06:19

spring cloud 在eureka註冊中心中刪除服務與狀態變更

通過eureka註冊中心的註冊的服務，可以通過DELETE來刪除指定的服務，發送地址爲： http://${server}:${port}/eureka/apps/${serviceName}/${instanceId} 如果不是刪除服

大树叶 2020-07-02 20:16:26

SpringCloud微服務架構中的服務註冊與發現——Eureka

1 爲什麼需要服務發現          簡單來說，服務化的核心就是將傳統的一站式應用根據業務拆分成一個一個的服務，而微服務在這個基礎上要更徹底地去耦合（不再共享DB、KV，去掉重量級ESB），並且強調DevOps和快速演化。這就要求我們

Coder-L 2020-07-01 23:56:18

SpringCloud - @EnableDiscoveryClient、@EnableEurekaClient 區別

最近在學習springcloud的時候發現不同的教程裏對於服務註冊使用了兩種註解：@EnableDiscoveryClient與@EnableEurekaClient。 下面簡單介紹下兩種註解的區別 @EnableDiscoveryC

Lux_Sun 2020-06-30 13:47:20

微服務Spring Cloud (一) 註冊中心 Eureka

轉載請表明出處 https://blog.csdn.net/Amor_Leo/article/details/87873898 謝謝 Spring Cloud EurekaSpring Cloud Eureka 概述Sprin

SophiaLeo 2020-06-30 11:53:23