前面詳細的給大家介紹了SpringBoot的核心內容，有了這部分的基礎支援的話，我們再來分析SpringCloud中的相關元件就很容器了，本文我們來給大家開始介紹Ribbon的相關內容，首先來介紹下Ribbon專案在啟動的時候完成了哪些操作。

一、專案案例準備

  首先我們大家案例環境，通過【RestTemplate】來實現服務呼叫，通過【Ribbon】實現客戶端負載均衡操作。

1.Order服務

  我們的Order服務作為服務提供者。建立SpringBoot專案，並新增相關依賴

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.4.9</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.bobo.springcloud</groupId>

    <artifactId>spring-cloud-order-server</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>spring-cloud-order-server</name>

    <description>Demo project for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

    </properties>

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

        </dependency>

    </dependencies>

    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>org.springframework.cloud</groupId>

                <artifactId>spring-cloud-dependencies</artifactId>

                <version>Hoxton.SR10</version>

                <type>pom</type>

                <scope>import</scope>

            </dependency>

        </dependencies>

    </dependencyManagement>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

  然後在屬性檔案中新增相關的配置

spring.application.name=spring-cloud-order-service

server.port=8081

  然後建立自定義的Controller 提供對外的服務

@RestController

public class OrderController {

    @Value("${server.port}")

    private int port;

    @GetMapping("/orders")

    public String orders(){

        System.out.println("Order 服務埠是："+port);

        return "Order Services ..... ";

    }

}

然後我們可以分別啟動兩個Order服務，埠分別設定為 8081和8082

2.User服務

  User服務作為呼叫用Order服務的客戶端。也是我們要重點介紹【Ribbon】的服務。同樣建立一個SpringBoot專案，新增相關的依賴

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.3.9.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.bobo.springcloud</groupId>

    <artifactId>spring-cloud-user-service2</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>spring-cloud-user-service2</name>

    <description>Demo project for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

    </dependencies>

    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>org.springframework.cloud</groupId>

                <artifactId>spring-cloud-dependencies</artifactId>

                <version>${spring-cloud.version}</version>

                <type>pom</type>

                <scope>import</scope>

            </dependency>

        </dependencies>

    </dependencyManagement>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

然後在屬性檔案中配置相關資訊

spring.application.name=spring-cloud-user-service

spring-cloud-order-service.ribbon.listOfServers=localhost:8081,localhost:8082

然後建立自定義的Controller來實現服務的呼叫

@RestController

public class UserController {

    @Autowired

    public RestTemplate restTemplate;

    @Autowired

    LoadBalancerClient loadBalancerClient;

    @Bean

    @LoadBalanced

    public RestTemplate restTemplate(){

        return new RestTemplate();

    }

    @GetMapping("/users")

    public String users(){

        ServiceInstance choose = loadBalancerClient.choose("spring-cloud-order-service");

        String url = String.format("http://%s:%s",choose.getHost(),choose.getPort()+"/orders");

        //return restTemplate.getForObject(url,String.class);

        return restTemplate.getForObject("http://spring-cloud-order-service/orders",String.class);

    }

}

然後啟動User服務訪問，可以看到【Ribbon】預設通過輪詢的方式來實現了服務的呼叫

二、Ribbon原理分析

  應用比較簡單，我們主要是來分析下【Ribbon】的核心原理，先來看看自動裝配做了哪些事情。

1.RibbonAutoConfiguration

  Ribbon在系統啟動的時候自動裝配完成的設定，我們先來看看對應的spring.factories 中的配置資訊吧



emsp; 所以我們要繼續來看【RibbonAutoConfiguration】配置類，我們貼出【RibbonAutoConfiguration】的關鍵資訊

@Configuration

@Conditional({RibbonAutoConfiguration.RibbonClassesConditions.class})

@RibbonClients

@AutoConfigureAfter(

    name = {"org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration"}

)

// RibbonAutoConfiguration配置類注入容器後會完成 LoadBalancerAutoConfiguration 和 AsyncLoadBalancerAutoConfiguration 的注入

@AutoConfigureBefore({LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class})

@EnableConfigurationProperties({RibbonEagerLoadProperties.class, ServerIntrospectorProperties.class})

public class RibbonAutoConfiguration {

    /**

    *  如果IoC容器中不存在 LoadBalancerClient 型別的物件就注入一個

    *  具體注入的型別為 RibbonLoadBalancerClient 物件

    **/

    @Bean

    @ConditionalOnMissingBean({LoadBalancerClient.class})

    public LoadBalancerClient loadBalancerClient() {

        return new RibbonLoadBalancerClient(this.springClientFactory());

    }

    // 省略其他程式碼

  通過原始碼檢視我們知道在SpringBoot專案啟動的時候完成了【LoadBalancerClient】物件的注入，且具體的型別為【RibbonLoadBalancerClient】，同時還會完成【LoadBalancerAutoConfiguration】這個配置型別的載入。在看【LoadBalancerAutoConfiguration】做了什麼事情之前，我們先來搞清楚【@LoadBalanced】註解的作用

2.LoadBalancerAutoConfiguration

@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@Qualifier

public @interface LoadBalanced {

}

  【@LoadBalanced】本質上就是一個【@Qualifier】註解。作用就是標記，我們通過案例來演示說明。

定義一個簡單的【User】類

public class User {

    String name;

    public User(String name) {

        this.name = name;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return "User{" +

                "name='" + name + '\'' +

                '}';

    }

}

然後定義一個Java配置類,有兩個添加了【@LoadBalanced】註解，有一個沒有加。

@Configuration

public class JavaConfig {

    @LoadBalanced

    @Bean("user1")

    public User user1(){

        return new User("user1");

    }

    @Bean("user2")

    public User user2(){

        return new User("user2");

    }

    @LoadBalanced

    @Bean("user3")

    public User user3(){

        return new User("user3");

    }

}

然後建立我們的控制器，來測試使用

@RestController

public class UsersController {

    @LoadBalanced

    @Autowired

    List<User> list = Collections.emptyList();

    @GetMapping("/querys")

    public String query(){

        return list.toString();

    }

}

專案結構

啟動SpringBoot專案後我們看效果

搞清楚了【@LoadBalanced】的作用後，我們再來看看【LoadBalancerAutoConfiguration】的配置載入做了什麼事情

public class LoadBalancerAutoConfiguration {

    /**

    *   1.

    * 獲取IoC容器中所有的被【@LoadBalanced】註解修飾的RestTemplate物件

    *  這些物件儲存在了一個集合中

    **/

	@LoadBalanced

	@Autowired(required = false)

	private List<RestTemplate> restTemplates = Collections.emptyList();

	@Autowired(required = false)

	private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();

    /**

    *   4.

    *  向容器中注入了 SmartInitializingSingleton 物件，並且實現了 SmartInitializingSingleton 介面中宣告的

    *  afterSingletonsInstantiated 方法，在該方法中 通過3 中的 RestTemplateCustomizer中定義的 customize 方法

    *  實現了 RestTemplate 物件攔截器的植入

    **/

	@Bean

	public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(

			final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {

		return () -> restTemplateCustomizers.ifAvailable(customizers -> {

			for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {

				for (RestTemplateCustomizer customizer : customizers) {

					customizer.customize(restTemplate);

				}

			}

		});

	}

	@Bean

	@ConditionalOnMissingBean

	public LoadBalancerRequestFactory loadBalancerRequestFactory(

			LoadBalancerClient loadBalancerClient) {

		return new LoadBalancerRequestFactory(loadBalancerClient, this.transformers);

	}

	@Configuration(proxyBeanMethods = false)

	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")

	static class LoadBalancerInterceptorConfig {

        /**

        *  2.

        *  建立了一個 LoadBalancerInterceptor 並注入到了容器中

        **/

		@Bean

		public LoadBalancerInterceptor loadBalancerInterceptor(

				LoadBalancerClient loadBalancerClient,

				LoadBalancerRequestFactory requestFactory) {

			return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);

		}

		/**

        *  3.

        *  建立了一個 RestTemplateCustomizer 並注入到了容器中

        *  而且通過內部類的方式定義定義了 RestTemplateCustomizer 介面中的 customize 方法的邏輯

        **/

		@Bean

		@ConditionalOnMissingBean

		public RestTemplateCustomizer restTemplateCustomizer(

				final LoadBalancerInterceptor loadBalancerInterceptor) {

			return restTemplate -> {

                // 獲取 RestTemplate 中原有的 攔截器

				List<ClientHttpRequestInterceptor> list = new ArrayList<>(

						restTemplate.getInterceptors());

                // 在原有的攔截器的基礎上 添加了一個 LoadBalancerInterceptor

				list.add(loadBalancerInterceptor);

                // 然後將新增有新的 攔截器的集合 設定到了 RestTemplate 物件中

				restTemplate.setInterceptors(list);

			};

		}

	}

   // 省略其他程式碼

}

通過對應的備註大家可以搞清楚該配置類的作用是實現了對【RestTemplate】物件(被@LoadBalanced修飾)植入

【LoadBalancerInterceptor】攔截器的功能。

小結Ribbon系統時的操作

~好了相信大家應該對於在自動裝配時完成了 【RestTemplate】植入攔截器的邏輯應該很清楚了，下篇文章我們詳細介紹Ribbon具體是怎麼來處理負載均衡邏輯的，敬請期待，歡迎一鍵三連哦!!!