Spring Cloud Ribbon（一）

阿新 • • 發佈：2020-12-15

一、RestTemplate

1.1簡介

spring框架提供的RestTemplate類可用於在應用中呼叫rest服務，它簡化了與http服務的通訊方式，統一了RESTful的標準，封裝了http連結，我們只需要傳入url及返回值型別即可。相較於之前常用的HttpClient，RestTemplate是一種更優雅的呼叫RESTful服務的方式。

在Spring應用程式中訪問第三方REST服務與使用Spring RestTemplate類有關。RestTemplate類的設計原則與許多其他Spring *模板類(例如JdbcTemplate、JmsTemplate)相同，為執行復雜任務提供了一種具有預設行為的簡化方法。

RestTemplate預設依賴JDK提供http連線的能力（HttpURLConnection），如果有需要的話也可以通過setRequestFactory方法替換為例如 Apache HttpComponents、Netty或OkHttp等其它HTTP library。

考慮到RestTemplate類是為呼叫REST服務而設計的，因此它的主要方法與REST的基礎緊密相連就不足為奇了，後者是HTTP協議的方法:HEAD、GET、POST、PUT、DELETE和OPTIONS。例如，RestTemplate類具有headForHeaders()、getForObject()、postForObject()、put()和delete()等方法。

1.2、實現

首先建兩個專案

RestTemplate包含以下幾個部分：

- HttpMessageConverter 物件轉換器
- ClientHttpRequestFactory 預設是JDK的HttpURLConnection
- ResponseErrorHandler 異常處理
- ClientHttpRequestInterceptor 請求攔截器

spring-cloud-server的配置

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

application.properties

spring.application.name=spring-cloud-server
server.port=8080

RestTemplateServer.class

@RestController
public class RestTemplateServer {
    @Value("${server.port}")
    private int port;

    @GetMapping("/orders")
    public String getAllOrder(){
        System.out.println("port:"+port);
        return "測試成功";
    }
}

啟動專案訪問結果如下

spring-cloud-user的配置檔案

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

server.port=8088

業務程式碼RestTemplateUser.class

@RestController
public class RestTemplateUser {

    @Autowired
    RestTemplate restTemplate;

    //因為RestTemplate不存在所以要注入
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

    @GetMapping("/user")
    public String findById(){
        return restTemplate.getForObject("http://localhost:8080/orders",String.class);
    }
}

啟動專案訪問可得到8080服務的結果

這樣我們初步完成了兩個獨立專案的通訊，如果不想在通過new的方式建立RestTemplate那也可以通過build（）方法建立，修改後如下

@RestController
public class RestTemplateUser {

    @Autowired
    RestTemplate restTemplate;

    //因為RestTemplate不存在所以要注入
//    @Bean
//    public RestTemplate restTemplate(){
//        return new RestTemplate();
//    }
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder){
        return restTemplateBuilder.build();
    }

    @GetMapping("/user")
    public String findById(){

        return restTemplate.getForObject("http://localhost:8080/orders",String.class);
    }
}

但是現在很多服務架構都是多節點的，那麼我們就要考慮多節點負載均衡的問題，這時最先想到的是Ribbon，修改程式碼

修改cloud-cloud-user的pom.xml檔案，增加

 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <version>2.2.3.RELEASE</version>
        </dependency>

為演示負載均衡，啟動兩個spring-cloud-server節點，再配置一個節點並啟動

修改完後，再修改spring-cloud-user配置檔案

server.port=8088

spring-cloud-server.ribbon.listOfServers=\
  localhost:8080,localhost:8081

這樣玩後有心的人就發現了，業務再用return restTemplate.getForObject("http://localhost:8080/orders",String.class);訪問另一個專案就不合適了，更改RestTemplateUser.class類

@RestController
public class RestTemplateUser {

    @Autowired
    RestTemplate restTemplate;

    //因為RestTemplate不存在所以要注入
//    @Bean
//    public RestTemplate restTemplate(){
//        return new RestTemplate();
//    }
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder){
        return restTemplateBuilder.build();
    }
    @Autowired
    LoadBalancerClient loadBalancerClient;


    @GetMapping("/user")
    public String findById(){

        ServiceInstance serviceInstance=loadBalancerClient.choose("spring-cloud-server");
        String url=String.format("http://%s:%s",serviceInstance.getHost(),serviceInstance.getPort()+"/orders");
        return restTemplate.getForObject(url,String.class);
        //通過服務名稱在配置檔案中選擇埠呼叫
       // return restTemplate.getForObject("http://localhost:8080/orders",String.class);
    }
}

訪問下面地址，多點幾次

說到了這裡那我們現在就要來看下Ribbon了

二、Ribbon簡介

需要解決的問題： ①如何在配置Eureka Client註冊中心時不去硬編碼EurekaServer的地址？ ②在微服務不同模組間進行通訊時，如何不去硬編碼服務提供者的地址？
③ 當部署多個相同微服務時，如何實現請求時的負載均衡？
實現負載均衡方式1：通過伺服器端實現負載均衡(nginx)

實現負載均衡方式2：通過客戶端實現負載均衡

Ribbon是什麼？ Ribbon是Netflix釋出的雲中間層服務開源專案，其主要功能是提供客戶端實現負載均衡演算法。Ribbon客戶端元件提供一系列完善的配置項如連線超時，重試等。簡單的說，Ribbon是一個客戶端負載均衡器，我們可以在配置檔案中Load Balancer後面的所有機器，Ribbon會自動的幫助你基於某種規則（如簡單輪詢，隨機連線等）去連線這些機器，我們也很容易使用Ribbon實現自定義的負載均衡演算法。下圖展示了Eureka使用Ribbon時的大致架構：

Ribbon工作時分為兩步：第一步選擇EurekaServer，它優先選擇在同一個Zone且負載較少的Server；第二步再根據使用者指定的策略，再從Server取到的服務註冊列表中選擇一個地址。其中Ribbon提供了很多策略，例如輪詢round robin、隨機Random、根據響應時間加權等。

為了更好的瞭解Ribbon後面肯定是要進入原始碼，在進入原始碼之前做個鋪墊，我再來改造上面的程式碼，引入@LoadBalanced註解，修改下

@RestController
public class RestTemplateUser {

    @Autowired
    RestTemplate restTemplate;

    //因為RestTemplate不存在所以要注入
//    @Bean
//    public RestTemplate restTemplate(){
//        return new RestTemplate();
//    }
//    @Bean
//    public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder){
//        return restTemplateBuilder.build();
//    }
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder){
        return restTemplateBuilder.build();
    }

//    @Autowired
//    LoadBalancerClient loadBalancerClient;


    @GetMapping("/user")
    public String findById(){

//        ServiceInstance serviceInstance=loadBalancerClient.choose("spring-cloud-server");
//        String url=String.format("http://%s:%s",serviceInstance.getHost(),serviceInstance.getPort()+"/orders");
//        return restTemplate.getForObject(url,String.class);
        //通過服務名稱在配置檔案中選擇埠呼叫
       return restTemplate.getForObject("http://spring-cloud-server/orders",String.class);
    }
}

啟動專案後會發現@LoadBalanced也能實現負載均衡，這裡面我們就應該進入看下@LoadBalanced到底做了啥，在沒用@LoadBalanced之前getForObject只能識別ip的路徑，並不能識別服務名進行負載均衡，所以我們要看下@LoadBalanced是怎麼實現的負載均衡

在看碼源前先劇透下，之前某人說我寫的東西不好看懂，那我這次多花點時間畫圖，restTemplate.getForObject("http://spring-cloud-server/orders",String.class);這個方法他呼叫的是一個伺服器名稱，我們知道，如果要訪問一個伺服器我們一個具體的路徑才能訪問，那麼@LoadBalanced是怎麼做到的由一個服務名得到一個具體的路徑呢，這就要說到攔截器，他在呼叫真實路徑前會有攔截器攔截伺服器名，然後拿到伺服器去解析然後拼接得到一個真實的路徑名稱，然後拿真實路徑去訪問服務，詳細的步驟在原始碼講解中具體分析。

我們點選@LoadBalanced進入如下圖

@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Qualifier
public @interface LoadBalanced {

}

我們會發現有一個叫@Qualifier的東西，其實這玩意就是一個標記的作用，但為了後面的原始碼分析，這裡還是說明下@Qualifiler的用法

我們在spring-cloud-user專案中新建一個Qualifier包，在包中建三個類

public class QualifierTest {
    private String name;

    public QualifierTest(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

//@Configuration用於定義配置類，可替換xml配置檔案，
// 被註解的類內部包含有一個或多個被@Bean註解的方法，
// 這些方法將會被AnnotationConfigApplicationContext或
// AnnotationConfigWebApplicationContext類進行掃描，
// 並用於構建bean定義，初始化Spring容器。
@Configuration
public class QualifierConfiguration {
    @Qualifier
    @Bean("QualifierTest1")
    QualifierTest QualifierTest1(){
        return new QualifierTest("QualifierTest1");
    }

    @Qualifier
    @Bean("QualifierTest2")
    QualifierTest QualifierTest2(){
        return new QualifierTest("QualifierTest2");
    }
}

@RestController
public class QualifierController {
    //@Qualifier作用是找到所有申明@Qualifier標記的例項
    @Qualifier
    @Autowired
    List<QualifierTest> testClassList= Collections.emptyList();

    @GetMapping("/qualifier")
    public Object test(){
        return testClassList;
    }
}

啟動專案訪問介面結果如下

除掉QualifierConfiguration.class中其中一個@Qualifier後重新整理介面，會發現結果如下，這兩個結果對比可以證明@Qualifier其實就是一個標記的作用

有了這個概念後我們進入LoadBalancerAutoConfiguration.class這個自動裝配類中會發現有和我剛剛演示一樣的程式碼，其實我就是從這個裝配類中抄的，哈哈；

看到這裡相信大家就明白了，因為紅框的內容加了@LoadBalanced註解就能使RestTemplate生效是因為@Qualifier註解，有了這個概念接著往下走，在上圖這個自動裝配類中會載入注入所有加了@LoadBalanced註解的RestTemplate，這一步很關鍵，因為後面的攔截器載入跟這一步有關聯；竟然我們來到了LoadBalancerAutoConfiguration，這個自動裝配類來了，那就聊聊這裡面的Bean裝配，下面這個圖是Bean的自動裝配過程

首先看自動裝配類攔截器LoadBalancerInterceptor

@Configuration(proxyBeanMethods = false)
    @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
    static class LoadBalancerInterceptorConfig {
        //定義一個Bean
        @Bean
        public LoadBalancerInterceptor ribbonInterceptor(
                LoadBalancerClient loadBalancerClient,
                LoadBalancerRequestFactory requestFactory) {
            return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
        }
        //將定義的Bean作為引數傳入
        @Bean
        @ConditionalOnMissingBean
        public RestTemplateCustomizer restTemplateCustomizer(
                final LoadBalancerInterceptor loadBalancerInterceptor) {
            return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                        restTemplate.getInterceptors());
                //設定攔截器
                list.add(loadBalancerInterceptor);
                //設定到restTemplate中去
                restTemplate.setInterceptors(list);
            };
        }

    }

@Bean
    public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
            final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
        return () -> restTemplateCustomizers.ifAvailable(customizers -> {
            //對restTemplates進行for迴圈，對每一個restTemplate加一個包裝叫RestTemplateCustomizer
            //這個包裝的意義是可以對restTemplate再加一個自定義的攔截
            for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
                for (RestTemplateCustomizer customizer : customizers) {
                    customizer.customize(restTemplate);
                }
            }
        });
    }

有了上面的包裝，才有下面的攔截的加強

        @Bean
        @ConditionalOnMissingBean
        public RestTemplateCustomizer restTemplateCustomizer(
                final LoadBalancerInterceptor loadBalancerInterceptor) {
            return restTemplate -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                        restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            };
        }

說到這裡再將時序圖畫一下，我最初是通過@LoadBalanced註解進入到他的裝配類LoadBalancerAutoConfiguration，然後在LoadBalancerAutoConfiguration裝配類中找到攔截器的載入和增強的，根據這個邏輯畫出的時序圖如下

之前在開篇中還講到過用下面這種方式進行負載均衡訪問，其實針對LoadBalancerClient是一樣的，他裡面有一個RibbonAutoConfiguration

   @Autowired
    LoadBalancerClient loadBalancerClient;

在RibbonAutoConfiguration裝配類中會找到一個程式碼如果下，他在裝配類中對LoadBalancerClient進行初始化

@Bean
    @ConditionalOnMissingBean(LoadBalancerClient.class)
    public LoadBalancerClient loadBalancerClient() {
        return new RibbonLoadBalancerClient(springClientFactory());
    }

我們看標頭檔案，會發現載入了LoadBalancerAutoConfiguration

這時補充下時序圖如下，這就是Bean的載入過程，經過這一過程攔截器就算是載入進去了

有了攔截器後，下一步要看的話肯定就是來看下攔截器到底做了啥，進入LoadBalancerInterceptor攔截器，會發現他會最終進入如下方法

@Override
    public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
            final ClientHttpRequestExecution execution) throws IOException {
        final URI originalUri = request.getURI();
        String serviceName = originalUri.getHost();
        Assert.state(serviceName != null,
                "Request URI does not contain a valid hostname: " + originalUri);
        //將攔截委託給loadBalancer進行實現
        return this.loadBalancer.execute(serviceName,
                this.requestFactory.createRequest(request, body, execution));
    }

跟進loadBalancer看下做了啥（LoadBalancerClient注入是在RibbonAutoConfiguration配置類中完成的），跟蹤進去發現最終還是呼叫了RibbonLoadBalancerClient

進入execute方法，會發現裡面只做了兩件事

public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint)
            throws IOException {
         //獲得負載均衡器
        ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
        //根據負載均衡器返回Server,這個Server返回是指定的某一個地址，其實負載的解析在這裡就完成了
        Server server = getServer(loadBalancer, hint);
        if (server == null) {
            throw new IllegalStateException("No instances available for " + serviceId);
        }
        RibbonServer ribbonServer = new RibbonServer(serviceId, server,
                isSecure(server, serviceId),
                serverIntrospector(serviceId).getMetadata(server));

        return execute(serviceId, ribbonServer, request);
    }

進入getLoadBalancer看看他做了啥，在看之前先看下他的類關係圖

ILoadBalancer介面：定義新增服務，選擇服務，獲取可用服務，獲取所有服務方法

AbstractLoadBalancer抽像類：定義了一個關於服務例項的分組列舉，包含了三種類型的服務：ALL表示所有服務，STATUS_UP表示正常執行的服務，STATUS_NOT_UP表示下線的服務。

BaseLoadBalancer：

1）：類中有兩個List集合，一個List集合用來儲存所有的服務例項，還有一個List集合用來儲存當前有效的服務例項

2）：定義了一個IPingStrategy，用來描述服務檢查策略，IPingStrategy預設實現採用了SerialPingStrategy實現

3）：chooseServer方法中(負載均衡的核心方法)，呼叫IRule中的choose方法來找到一個具體的服務例項,預設實現是RoundRobinRule

4）：PingTask用來檢查Server是否有效，預設執行時間間隔為10秒

5）：markServerDown方法用來標記一個服務是否有效，標記方式為呼叫Server物件的setAlive方法設定isAliveFlag屬性為false

6）：getReachableServers方法用來獲取所有有效的服務例項列表

7）：getAllServers方法用來獲取所有服務的例項列表

8）：addServers方法表示向負載均衡器中新增一個新的服務例項列表

DynamicServerListLoadBalancer：主要是實現了服務例項清單在執行期間的動態更新能力，同時提供了對服務例項清單的過濾功能。

ZoneAwareLoadBalancer:主要是重寫DynamicServerListLoadBalancer中的chooseServer方法，由於DynamicServerListLoadBalancer中負責均衡的策略依然是BaseLoadBalancer中的線性輪詢策略，這種策略不具備區域感知功能

NoOpLoadBalancer：不做任何事的負載均衡實現，一般用於佔位（然而貌似從沒被用到過）。

有了這個概念後我們下面就來重點看BaseLoadBalancer，在嘮嘮之前先補充下時序圖

點選getLoadBalancer進入如下程式碼

在向下寫前，先提前說下ILoadBalancer這個類裡面會幫我們做一件事，他會根據負載均衡的一個演算法進行一個負載的選擇，但是在負載之前他會有一個類的初始化過程，在選擇完成後ILoadBalancer實現返回，然後將ILoadBalancer做為引數傳給Server server = getServer(loadBalancer, hint);在ILoadBalancer中他有一個實現會去呼叫BaseLoadBalancer.chooseServer,它會呼叫rule.choose(),rule的初始化是在ZoneAvoidanceRule中完成的，所以接下來看要分兩部分，ILoadBalancer做為一個負載均衡器，然後getServer會把這個負載均衡器會傳過去後進行一個負載的計算，這個流程說完後可能很多人還在懵逼狀態，那接下來我們就通過程式碼來看他的實現，首先看ILoadBalancer的實現是誰

接著上圖來，點選getLoadBalancer

然後點選getInstance

    @Override
    public <C> C getInstance(String name, Class<C> type) {
        //這裡面通過傳送一個name和一個type得到一個例項，這裡面是一個工廠模式，我們點選getInstance選擇它的NamedContextFactory實現進去
        C instance = super.getInstance(name, type);
        if (instance != null) {
            return instance;
        }
        IClientConfig config = getInstance(name, IClientConfig.class);
        return instantiateWithConfig(getContext(name), type, config);
    }

    public <T> T getInstance(String name, Class<T> type) {
        //工廠模式會載入一個context
        AnnotationConfigApplicationContext context = getContext(name);
        if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,
                type).length > 0) {
            return context.getBean(type);
        }
        return null;
    }

getContext方法裡面是用spring寫的，比較複雜，點選getContext後如下圖，這裡面是有個預設快取的，如果沒有會用createContext(name)根據名稱建立一個快取

回退到AnnotationConfigApplicationContext context = getContext(name);

public <T> T getInstance(String name, Class<T> type) {
        AnnotationConfigApplicationContext context = getContext(name);
        if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,
                type).length > 0) {
            通過type得到一個Bean
            return context.getBean(type);
        }
        return null;
    }

再回退到C instance = super.getInstance(name, type);進行打debug看下他返回的是什麼型別的ILoadBalancer

從上圖可以看到返回的是一個ZoneAwareLoadBalancer的ILoadBalancer，然後就拿著ILoadBalancer傳入getServer(loadBalancer, hint);中，這時的時序圖就如下了

到了這一步獲取負載均衡器這一過程就完成了，下面就是來完成過程2.通過負載均衡器中配置的預設負載均衡演算法選一個合適的Server，我們進入

Server server = getServer(loadBalancer, hint);的getServer方法，點選進去如下，這裡面其實進行的就是針對一個服務節點的選擇，其中loadBalancer.chooseServer(hint != null ? hint : "default");就是一種演算法的選擇，我們這裡面沒有選擇演算法，所以採用預設演算法BaseLoadBalancer

進入預設演算法截圖如下

然後他會呼叫rule.choose(key);方法，我們可以在進入方法前先看下IRule是啥，通過下圖我們可以很清楚的看到IRule裡面所有的實現，之所以在這裡提到IRule是因為IRule是Ribbon中實現負載均衡的一個很重要的規則，他實現了重置規則、輪詢規則、隨機規則及客戶端是否啟動輪詢的規則；在後面我看機會說其中一到兩種比較常用的演算法說明下

我們這裡rule.choose(key);採用的是輪詢演算法，選擇PredicateBasedRule，進去後截圖如下

    @Override
    public Server choose(Object key) {
        ILoadBalancer lb = getLoadBalancer();
        //根據我們的過濾規則過濾之後會根據輪詢去進行篩選，其中lb.getAllServers是獲取一個靜態的服務列表
        Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
        if (server.isPresent()) {
            return server.get();
        } else {
            return null;
        }       
    }
}

我們進入chooseRoundRobinAfterFiltering，下面的輪詢比較簡單，他先把節點數量eligible.size(）傳進去，然後通過incrementAndGetModulo方法獲取一個下標

public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) {
        //得到我們所有的配置資訊
        List<Server> eligible = getEligibleServers(servers, loadBalancerKey);
        //配置數量
        if (eligible.size() == 0) {
            return Optional.absent();
        }
        //進行輪詢計算
        return Optional.of(eligible.get(incrementAndGetModulo(eligible.size())));
    }

可以進入incrementAndGetModulo方法看下

private int incrementAndGetModulo(int modulo) {
        for (;;) {
           //獲取下一個節點的當前值
            int current = nextIndex.get();
            //根據這個值進行取模運算
            int next = (current + 1) % modulo;
           //設定下一個值
            if (nextIndex.compareAndSet(current, next) && current < modulo)
                return current;
        }
    }

上面就是輪詢演算法的實現，這個演算法的實現比較簡單，下面再來看一個隨機演算法的實現

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers();
            //得到所有節點資訊
            List<Server> allList = lb.getAllServers();

            int serverCount = allList.size();
            if (serverCount == 0) {
                /*
                 * No servers. End regardless of pass, because subsequent passes
                 * only get more restrictive.
                 */
                return null;
            }
            //傳入節點數量，然後隨機取值，如果有人想看怎麼取的點選這個chooseRandomInt就可以看到，它實現就一句話，就是把數量傳進去得到一個隨機值
            int index = chooseRandomInt(serverCount);
            server = upList.get(index);

            if (server == null) {
                /*
                 * The only time this should happen is if the server list were
                 * somehow trimmed. This is a transient condition. Retry after
                 * yielding.
                 */
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }

        return server;

    }

隨機實現聊完後，再回到我們跟蹤的程式碼return Optional.of(eligible.get(incrementAndGetModulo(eligible.size())));通過演算法得到具體的節點後eligible.get就可以得到對應下標的服務列表，這時就得到了什麼localhost:8082的具體埠號了，這一步完成後其實Server server = getServer(loadBalancer, hint);的活就做完了，下面的活就是拿著具體埠去重構了，更新下時序圖

專案中所有例子原始碼：https://github.com/ljx958720/spring-cloud-Ribbon-1-.git

Spring Cloud Ribbon（一）

一、RestTemplate

1.1簡介

1.2、實現

二、Ribbon簡介

Spring Cloud Ribbon（一）

Spring Cloud Gateway （一）入門篇

Spring Cloud Alibaba（一）如何使用nacos服務註冊和發現

Java Spring Cloud：（一）Spring Cloud 簡介

Spring Cloud（五）搭建一箇中心配置伺服器Spring Cloud Config（下）

Spring Cloud Alibaba（五）RocketMQ 非同步通訊實現

Spring Cloud Alibaba（四）實現Dubbo服務消費

Spring Cloud Alibaba（三）Sentinel之熔斷降級

Spring Boot實戰（一）：只需兩步！Eclipse+Maven快速構建第一個Spring Boot專案

單機利用 docker映象部署 spring cloud 專案（學習）

Spring Cloud Gateway（二）：Spring Cloud Gateway整合Eureka應用

Spring Boot系列（一）：Spring Boot快速開始

spring 事物系列（一）事物的使用

spring cloud 學習（Feign）分散式配置中心

spring cloud 學習（Gateway）閘道器

spring cloud 學習（Config）分散式配置中心

Spring Boot入門（一）

Spring Security學習（一）：自定義登入認證

Spring Boot 學習（一）檢視自動配置報告

Spring Boot 學習（一）properties和yml 配置檔案的配置

Spring Cloud Ribbon（一）

一、RestTemplate

1.1簡介

1.2、實現

二、Ribbon簡介

相關推薦