不懂Ribbon原理的可以进来看看哦，分析SpringBoot自动装配完成了Ribbon哪些核心操作

阳光穿透心脏的1/2处 2022-09-04 03:55 86阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70]  前面详细的给大家介绍了SpringBoot的核心内容，有了这部分的基础支持的话，我们再来分析SpringCloud中的相关组件就很容器了，本文我们来给大家开始介绍Ribbon的相关内容，首先来介绍下Ribbon项目在启动的时候完成了哪些操作。

# 一、项目案例准备 #

首先我们大家案例环境，通过【RestTemplate】来实现服务调用，通过【Ribbon】实现客户端负载均衡操作。

![在这里插入图片描述][ec5d0a9b6577465e8319b96970712836.png]

## 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/> 
        </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/> 
        </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】默认通过轮询的方式来实现了服务的调用  
![在这里插入图片描述][c9cf093e0fd74fa69c5585399e9f8ccd.png]

# 二、Ribbon原理分析 #

应用比较简单，我们主要是来分析下【Ribbon】的核心原理，先来看看自动装配做了哪些事情。

## 1.RibbonAutoConfiguration ##

Ribbon在系统启动的时候自动装配完成的设置，我们先来看看对应的spring.factories 中的配置信息吧  
![请添加图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70 1]  
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();
        }
    }

项目结构  
![请添加图片描述][9e30496587f24d31a38014380519a8f1.png]

启动SpringBoot项目后我们看效果  
![请添加图片描述][769bf70aed51454dadd1b681e834f1df.png]

搞清楚了【@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系统时的操作  
![请添加图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70 2]

~好了相信大家应该对于在自动装配时完成了 【RestTemplate】植入拦截器的逻辑应该很清楚了，下篇文章我们详细介绍Ribbon具体是怎么来处理负载均衡逻辑的，敬请期待，欢迎一键三连哦!!!

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70]: /images/20220829/fd87fda2f53f492ab8bfc5c9454ad52b.png
[ec5d0a9b6577465e8319b96970712836.png]: /images/20220829/8c4c232301104bcaaf10b7d5d3337940.png
[c9cf093e0fd74fa69c5585399e9f8ccd.png]: /images/20220829/b14aa5e0eea44eceaeb1ce3cab429718.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70 1]: /images/20220829/d3bedc82a46f43fa8030c8f73242ead8.png
[9e30496587f24d31a38014380519a8f1.png]: /images/20220829/e5dbf67ce2d54e64be04f9eaf3f722ff.png
[769bf70aed51454dadd1b681e834f1df.png]: /images/20220829/3ec6b78bcfa2460e950c19709f753f6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70 2]: /images/20220829/2b9803fb7fc04238bc62add86502773a.png