今天我们来学习下`Spring Cloud`的一个组件`Ribbon`，本篇文章主要内容如下： - 什么是`Ribbon` - `Ribbon`的使用 - `Ribbon`的实现原理对`Ribbon`的使用了解的同学，可以直接跳过前两部分。 ## 1 什么是Ribbon 学习一项技术时，我们应当先了解这项技术有哪些功能，能帮我们实现什么样的需求。在微服务架构的项目中，服务之间的调用是必然存在的，同时为了避免单点故障，每一个服务又会部署多个节点，简单的示例如下所示： ![image-20211019191801736](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a7a271375d94422aa8cb6433ef066a55~tplv-k3u1fbpfcp-zoom-1.image) 上图中service1调用service2的服务时，需要从service2的服务列表中选择出一个节点，拿到其对应的ip和端口，然后再发起对应的请求，这便是所谓的负载均衡算法，`Ribbon`便是一个帮我们实现了这个功能的组件。 ## 2 Ribbon的使用知道了`Ribbon`的功能后，我们通过一个简单的示例来学习下`Ribbon`的使用，项目结构比较简单，有两个模块如下： - `user-service` 一个`SpringBoot`编写的web项目，里面定义了一个接口。 - `ribbon-sample` 一个`SpringBoot`编写的web项目，引入了`Ribbon`，调用`user-service`中的接口我们将`user-service`修改端口后启动两个用来模拟多节点，结果入下图所示： ![image-20211020112231645](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4ca0ef8710fd40c8ba57149b5f0f2702~tplv-k3u1fbpfcp-zoom-1.image) ### 2.1 `user-service`模块这个模块就是一个`SpringBoot`编写的web服务，里面提供了一个接口，如下： ```java @RestController @RequestMapping(value = "/user") public class UserController { @Value("${server.port}") private int port; @GetMapping(value = "/{name}") public String getByName(@PathVariable String name) { System.out.println(port); return name; } } ``` ### 2.2 `ribbon-sample`模块引入如下`Ribbon`的依赖： ```xml org.springframework.cloud spring-cloud-starter-netflix-ribbon 2.2.9.RELEASE ``` 之后也在这个项目中定义一个接口，并使用`RestTemplate`调用`user-service`中的接口，为了简便，我直接将接口定义在了启动类中，代码如下： ```java @RestController @SpringBootApplication public class RibbonServiceBootstrap { public static void main(String[] args) { SpringApplication.run(RibbonServiceBootstrap.class, args); } @Bean @LoadBalanced public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) { return restTemplateBuilder.build(); } @Resource private RestTemplate restTemplate; @GetMapping(value = "/ribbon/user/{name}") public String getUserByName(@PathVariable String name) { return restTemplate.getForObject("http://user-service/user/" + name, String.class); } } ``` 在`application.yml`配置文件中配置上`user-service`的地址，内容如下： ```yaml user-service: ribbon: listOfServers: localhost:8080,localhost:8081 ``` 注意上面的代码哈，在将`RestTemplate`注入`Spring`容器中的方法上添加了`@LoadBalanced`注解，我们访问`user-service`中的接口使用的是服务名，而不是`ip:port`的形式。 ### 2.3 测试代码编写完后，我们启动这两个服务，其中`user-service`需要启动两个，端口分别为`8080`和`8081`，然后在浏览器中输入`ribbon-sample`服务中接口`http://localhost:8082/ribbon/user/zhangsan`，发现可以正常访问： ![image-20211020114059399](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/78bf25a2c8d54e4c85f5184a2fbc0e8a~tplv-k3u1fbpfcp-zoom-1.image) 可以多点几次，观察`user-service`两个服务控制台的输出，会发现这两个服务会交替的打印自己的端口号，大家应该很容易想到这是一种轮询的方式。 ## 3 `Ribbon`的实现原理在上面的示例中我们只需要在`RestTemplate`的创建方法上加一个`@LoadBalanced`注解便可以使用`Ribbon`相应的功能，这个注解的定义如下： ```java @Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @Qualifier public @interface LoadBalanced { } ``` 通过上面的代码我们能够看出在这个注解中有`@Qualifier`注解，这个注解的作用是给加入到`Spring IOC`容器中的对象增加一个标识，然后我们可以获取相应标识的对象。 ### 3.1 加载逻辑 ![启动加载的类](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/81ae3c1a3c014da79d1296c3d664d6dd~tplv-k3u1fbpfcp-zoom-1.image) 了解了`@LoadBalanced`注解后，我们看看服务启动阶段是如何加载相关类的，这个加载的入口为`org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration`，当项目启动时会自动加载这个类，这里涉及到`SpringBoot`的自动装配相关的内容，不了解的同学可以自行去了解下，这个类中会创建`LoadBalancerClient`对象并放入容器中，如下： ```java @Bean @ConditionalOnMissingBean(LoadBalancerClient.class) public LoadBalancerClient loadBalancerClient() { return new RibbonLoadBalancerClient(springClientFactory()); } ``` 在这个类上被`@AutoConfigureBefore`注解进行了修饰，在这个注解中配置的类会先被加载，其源码如下： ```java @AutoConfigureBefore({ LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class }) ``` 通过上面的代码我们看到会加载`org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration`类。在这个类中我们会发现有如下一个变量： ```java @LoadBalanced @Autowired(required = false) private List restTemplates = Collections.emptyList(); ``` 这个变量中存储的是被`@LoadBalanced`注解修饰的变量。这个类里都是创建对象并存入`Spring IOC`容器中，主要实例化的三个类如下： - `LoadBalancerInterceptor` - `RestTemplateCustomizer` - `SmartInitializingSingleton` 其逻辑如下： ```java @Bean public LoadBalancerInterceptor loadBalancerInterceptor(LoadBalancerClient loadBalancerClient, LoadBalancerRequestFactory requestFactory) { return new LoadBalancerInterceptor(loadBalancerClient, requestFactory); } @Bean @ConditionalOnMissingBean public RestTemplateCustomizer restTemplateCustomizer(final LoadBalancerInterceptor loadBalancerInterceptor) { return restTemplate -> { List list = new ArrayList<>(restTemplate.getInterceptors()); list.add(loadBalancerInterceptor); restTemplate.setInterceptors(list); }; } @Bean public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated( final ObjectProvider> restTemplateCustomizers) { return () -> restTemplateCustomizers.ifAvailable(customizers -> { for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) { for (RestTemplateCustomizer customizer : customizers) { customizer.customize(restTemplate); } } }); } ``` 通过上述代码我们可以看到在这个过程中`Spring Cloud`为`RestTemplate`添加上了一个`LoadBalancerInterceptor`对象，这个对象是一个拦截器，这个类中只有一个`intercept()`方法，改方法的逻辑如下： ```java @Override public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException { // 解析出请求的URI对象 final URI originalUri = request.getURI(); // 获取到请求中的host 示例中是user-service String serviceName = originalUri.getHost(); Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri); return this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution)); } ``` ### 3.2 执行阶段使用`RestTemplate`发送请求时会进入上述拦截器的方法中，我们顺着源码往下走会走到`RibbonLoadBalancerClient.execute()`方法中，其逻辑如下： ```java @Override public T execute(String serviceId, LoadBalancerRequest request) throws IOException { return execute(serviceId, request, null); } public T execute(String serviceId, LoadBalancerRequest request, Object hint) throws IOException { // 获取LoadBalancer对象 ILoadBalancer loadBalancer = getLoadBalancer(serviceId); // 获取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); } ``` 在上面的代码中会分别获取`ILoadBalancer`和`Server`对象。 `getLoadBalancer`的代码这里就不进行粘贴了，这里的逻辑是从`Spring`上下文中获取对象，最终返回的是一个`ZoneAwareLoadBalancer`对象。 `getServer()`方法的逻辑如下： ```java protected Server getServer(ILoadBalancer loadBalancer, Object hint) { if (loadBalancer == null) { return null; } // Use 'default' on a null hint, or just pass it on? return loadBalancer.chooseServer(hint != null ? hint : "default"); } ``` 跟随源码发现会调用到`BaseLoadBalancer.chooseServer()`方法，这个方法的逻辑如下： ```java public Server chooseServer(Object key) { if (counter == null) { counter = createCounter(); } counter.increment(); if (rule == null) { return null; } else { try { return rule.choose(key); } catch (Exception e) { logger.warn("LoadBalancer [{}]: Error choosing server for key {}", name, key, e); return null; } } } ``` 通过上面的代码我们发现，实现负载均衡的规则是在`IRule`中实现的，`Ribbon`中提供的规则如下： - `RoundRobbinRule` 轮询 - `RandomRule` 随机 - `WeightedResponseTimeRule` 根据响应权重选择 - `MyGrayBalancerRule` - `RetryRule` 轮询并重试规则 - `BestAvailableRule` 忽略连接失败的服务器 - `ZoneAvoidanceRule` - `AvailabilityFilteringRule` 从可用的服务中进行轮询在`Spring Cloud Ribbon`中默认的负载均衡规则是轮询，我们看看`RoundRobbinRule`中获取某个服务的逻辑，源码如下： ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ce3d3ac4e72141c4830380e65f809f28~tplv-k3u1fbpfcp-watermark.image?) 这里的逻辑比较简单哈，最主要的关注点为用红框框起来的两个字段的获取，这两个字段获取的逻辑比较简单，这里就不进行粘贴了，其对应的是`BaseLoadBalancer`类中的如下两个字段： ```java // 所有的服务列表 @Monitor(name = PREFIX + "AllServerList", type = DataSourceType.INFORMATIONAL) protected volatile List allServerList = Collections .synchronizedList(new ArrayList()); // 存活的服务列表 @Monitor(name = PREFIX + "UpServerList", type = DataSourceType.INFORMATIONAL) protected volatile List upServerList = Collections .synchronizedList(new ArrayList()); ``` ### 3.3 服务列表维护通过上面的内容我们知道了在负载均衡器中维护了两个存放服务列表的字段，接下来我们就了解下`Ribbon`是如何维护服务列表的。大家还记得我们在上面的代码中获取到的`ILoadBalancer`实例是什么吗？是一个`ZoneAwareLoadBalancer`对象，这个对象是在`RibbonClientConfiguration`类中被添加到`Spring`容器中的，代码如下： ```java @Bean @ConditionalOnMissingBean public ILoadBalancer ribbonLoadBalancer(IClientConfig config, ServerList serverList, ServerListFilter serverListFilter, IRule rule, IPing ping, ServerListUpdater serverListUpdater) { if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) { return this.propertiesFactory.get(ILoadBalancer.class, config, name); } return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList, serverListFilter, serverListUpdater); } public ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping, ServerList serverList, ServerListFilter filter, ServerListUpdater serverListUpdater) { super(clientConfig, rule, ping, serverList, filter, serverListUpdater); } public DynamicServerListLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping, ServerList serverList, ServerListFilter filter, ServerListUpdater serverListUpdater) { super(clientConfig, rule, ping); this.serverListImpl = serverList; this.filter = filter; this.serverListUpdater = serverListUpdater; if (filter instanceof AbstractServerListFilter) { ((AbstractServerListFilter) filter).setLoadBalancerStats(getLoadBalancerStats()); } restOfInit(clientConfig); } ``` 根据上面源码我们会看到会调用到`DynamicServerListLoadBalancer.restOfInit`方法中，在这个方法中会维护上述的两个字段，这个方法的源码如下： ```java void restOfInit(IClientConfig clientConfig) { boolean primeConnection = this.isEnablePrimingConnections(); // turn this off to avoid duplicated asynchronous priming done in BaseLoadBalancer.setServerList() this.setEnablePrimingConnections(false); // 启动定时任务定时更新服务列表 enableAndInitLearnNewServersFeature(); // 获取服务列表 updateListOfServers(); if (primeConnection && this.getPrimeConnections() != null) { this.getPrimeConnections() .primeConnections(getReachableServers()); } this.setEnablePrimingConnections(primeConnection); LOGGER.info("DynamicServerListLoadBalancer for client {} initialized: {}", clientConfig.getClientName(), this.toString()); } ``` 在这个方法中主要的逻辑在`enableAndInitLearnNewServersFeature`和`updateListOfServers`两个方法中，接下来我们先看看`updateListOfServers`方法，这个方法的逻辑如下： ```java public void updateListOfServers() { List servers = new ArrayList(); if (serverListImpl != null) { // 从配置文件中获取 ConfigurationBasedServerList servers = serverListImpl.getUpdatedListOfServers(); LOGGER.debug("List of Servers for {} obtained from Discovery client: {}", getIdentifier(), servers); if (filter != null) { servers = filter.getFilteredListOfServers(servers); LOGGER.debug("Filtered List of Servers for {} obtained from Discovery client: {}", getIdentifier(), servers); } } updateAllServerList(servers); } protected void updateAllServerList(List ls) { // other threads might be doing this - in which case, we pass if (serverListUpdateInProgress.compareAndSet(false, true)) { try { for (T s : ls) { s.setAlive(true); // set so that clients can start using these // servers right away instead // of having to wait out the ping cycle. } // 设置allServerList属性如果可以不用Ping的情况，upServerList = allServerList setServersList(ls); // 通过Ping规则用来判断存活的服务 super.forceQuickPing(); } finally { serverListUpdateInProgress.set(false); } } } ``` `enableAndInitLearnNewServersFeature`方法的逻辑如下： ```java public void enableAndInitLearnNewServersFeature() { LOGGER.info("Using serverListUpdater {}", serverListUpdater.getClass().getSimpleName()); serverListUpdater.start(updateAction); } ``` 在往下会调用到`PollingServerListUpdater.start`方法，这个方法中会启动个定时任务，定时调用`updateListOfServers`方法，截图如下： ![image-20220330164246059](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/780474018b87476e8cb9f2714a60cbfe~tplv-k3u1fbpfcp-zoom-1.image) 关于服务是否存活的判断在`IPing`中，由于默认情况都是返回true，我们这里不贴出来了，大家自行查看源码就行。 ## 4 总结今天的文章到这里就结束了，在本文中主要介绍了下如何使用原生的`Ribbon`组件进行服务调用，在本篇文章中的示例我们并没有引入注册中心，是把服务列表写死到配置文件中的，之后介绍注册中心时我们再看看`Ribbon`是如何同注册中心配合使用的。 + 原生`Ribbon`的使用 + 查看源码，找到入口很关键，主要的配置类有`RibbonClientConfiguration`、`RibbonAutoConfiguration`和`LoadBalancerAutoConfiguration` + `Ribbon`中的核心组件 + `ILoadBalancer` 负载均衡器 + `IRule` 负载均衡规则 + `ServerList` 获取服务列表 + `IPing` 用于验证是否存活 + 服务列表的更新规则 > 欢迎关注公众号【Bug搬运小能手】持续更新Java相关知识