Spring Cloud快速开发入门第四篇---客户端负载均衡Ribbon

r囧r小猫 2021-11-09 09:46 257阅读 0赞

本文是Spring Cloud专栏的第四篇文章，了解前三篇文章内容有助于更好的理解本文：

1.  [Spring Cloud快速开发入门第一篇---SpringCloud前言及其常用组件介绍概览][Spring Cloud_---SpringCloud]
2.  [Spring Cloud快速开发入门第二篇---使用并认识Eureka注册中心][Spring Cloud_---_Eureka]
3.  [Spring Cloud快速开发入门第三篇---搭建高可用Eureka注册中心][Spring Cloud_---_Eureka 1]

![20190814093913323.gif][]

# 一、Ribbon是什么 #

Ribbon是一个基于HTTP和TCP的客户端负载均衡器，当使用Ribbon对服务进行访问的时候，他会扩展Eureka客户端的服务发现功能，实现从Eureka注册中心获取服务端列表，并通过Eureka客户端来确定服务端是否已经启动。Ribbon在Eureka客户端服务发现的基础上，实现对服务实例的选择策略，从而实现对服务的负载均衡消费。负载均衡在系统架构中是一个非常重要的内容，因为负载均衡是对系统的高可用、网络的压力的缓冲和处理能力扩容的重要手段之一，我们通常说的负载均衡都是指的是服务端的负载均衡，其中分为硬件负载均衡和软件负载均衡。

**硬件负载均衡：**主要通过服务器节点之间安装专门用于负载均衡的设备，比如F5，深信服，Array等。

**软件负载均衡：**则是通过服务器上安装一些具有负载功能或模块的软件来完成请求分发工作，比如Nginx、LVS、HaProxy等。

硬件负载均衡的设备或是软件负载均衡的软件模块都会维护一个下挂可用的服务端清单，通过心跳检测来剔除故障的服务端节点保证清单中都是可以正常访问的服务端节点。当客户端发送请求到负载均衡的设备时候，该设备按某种算法（比如线性轮询、按权重负载、按流量负载等）从维护的可用服务端清单中取出一台服务端地址，然后进行转发。

Ribbon是Netflix发布的开源项目,主要功能是提供客户端的软件负载均衡算法,是一个基于HTTP和TCP的客户端负载均衡工具。 Spring Cloud对 Ribbon做了二次封装,可以让我们使用 RestTemplate的服务请求,自动转换成客户端负载均衡的服务调用。 Ribbon支持多种负载均衡算法,还支持自定义的负载均衡算法。 Ribbon只是一个工具类框架,比较小巧, Spring Cloud对它封装后使用也非 常方便,它不像服务注册中心、配置中心、AP网关那样需要独立部署, Ribbon 只需要在代码直接使用即可;

Ribbon与 Nginx的区别

都是软负载

Ribbon是客户端负载均衡

Nginx是服务器段负载均衡

区别在于：

服务清单所存储的位置不同，在客户端负载均衡中，所有客户端节点下的服务端清单，需要自己从服务注册中心上获取，比如Eureka服务注册中心。同服务端负载均衡的架构类似，在客户端负载均衡中也需要心跳去维护服务端清单的健康性，只是这个步骤需要与服务注册中心配合完成，在SpringCloud实现的服务治理框架中，默认会创建针对各个服务治理框架到的Ribbon自动化整合配置，比如Eureka中的org.springframework.cloud.netflix.ribbon.eureka.RibbonEurekaAutoConfiguration,在实际使用的时候，我们可以通过查看这个类的实现，以找到他们的配置详情来帮助我们更好的使用它。

通过Spring Cloud Ribbon的封装，我们在微服务架构中使用客户端负载均衡调用非常的简单，只需要如下两步：

1.  服务提供者只需要启动多个服务实例并注册到一个注册中心或是多个相关联的服务注册中心上
2.  服务消费者直接通过调用被@LoadBalanced注解修饰过的RestTemplate来实现面向服务的接口调用。

这样我们就可以将服务提供者的高可用以及服务消费者的负载均衡用一起实现了。

服务端的负载均衡是提前配置好的：Nginx

客户端的负载均衡是从注册中心找的：Ribbon

在SpringCloud中，Ribbon主要与RestTemplate对象配合使用，Ribbon会自动化配置RestTemplate对象，通过@LoadBalance开启RestTemplate对象调用时的负载均衡

![aHR0cHM6Ly90aW1nc2EuYmFpZHUuY29tL3RpbWc_aW1hZ2UmcXVhbGl0eT04MCZzaXplPWI5OTk5XzEwMDAwJnNlYz0xNTY0Nzg3OTg0NTQxJmRpPWQ1OTY5N2Y1MmNjYWI2Y2Y1NDcwMzFkMTRjNmQ5ZDM0JmltZ3R5cGU9MCZzcmM9aHR0cCUzQSUyRiUyRmltYWdlLmJ1YnVrby5jb20lMkZpbmZvJTJGMjAxODA5JTJGMjAxODA5MTExMTA3MDM1OTE3ODEucG5n][]

# 二、Ribbon实现客户端负载均衡 #

2-1、前面提到过，通过Spring Cloud Ribbon的封装，我们在微服务架构中使用客户端负载均衡调用非常的简单，只需要如下两步：

2-2、我们复制服务提供者（springcloud-service-provider）并且命名为springcloud-service-provider-02，修改controlle响应结果内容，区别一服务提供者（springcloud-service-provider）内容。修改服务提供者（springcloud-service-provider-02）端口为8081，具体详细代码查看码云仓库案例代码。注册中心我们以后使用8700单节点，只是为了方便。

2-3、在消费者的RestTemplate中添加如下代码：

//使用Ribbon实现负载均衡调用,默认是轮询
        @LoadBalanced //加入ribbon的支持，那么在调用时，即可改为使用服务名称来访问
        @Bean
        public RestTemplate restTemplate(){
            return new RestTemplate();
        }

2-4、查看Eureka的web页面显示提供者两个实例

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70][]

2-5、启动消费者，进行访问如图：

![20190803065653311.png][]

![20190803065633809.png][]

provider-01和provider-02交替出现，可以看出默认是轮询策略。

# 三、Ribbon负载均衡策略 #

Ribbon的负载均衡策略是由IRule接口定义，该接口由如下实现：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70 1][]

<table> IRule实现类的负载策略含义 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> RandomRule </td> 
 <td style="vertical-align:top;width:213.05pt;"> 随机 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> RoundRobinRule </td> 
 <td style="vertical-align:top;width:213.05pt;"> 轮询 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> AvailabilityFilteringRule </td> 
 <td style="vertical-align:top;width:213.05pt;"> 先过滤掉由于多次访问故障的服务，以及并发连接数超过阀值的服务，然后对剩下的服务按照轮询策略进行访问 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> WeightedResponseTimeRule </td> 
 <td style="vertical-align:top;width:213.05pt;"> 根据平均响应时间计算所有服务的权重，响应时间越快服务权重就越大被选中的概率即越高，如果服务刚启动时间统计信息不足，，则使用RoundRobinRule策略，待统计信息足够，会切换到该WeightedResponseTimeRule策略 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> RetryRule </td> 
 <td style="vertical-align:top;width:213.05pt;"> 先按照RoundRobinRule策略分发，如果分发到的服务不能访问，则在指定的时间内重试，如果不行的话，则分发到其他可用的服务 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> BestAvailableRule </td> 
 <td style="vertical-align:top;width:213.05pt;"> 先过滤掉由于多次访问的故障的服务，然后选择一个并发量最小的服务 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> ZoneAvoidanceRule </td> 
 <td style="vertical-align:top;width:213.05pt;"> 综合判断服务节点所在区域的性能和服务节点的可用性，来决定选择哪个服务 </td> 
 </tr> 
 </tbody> 
</table>

TIP：结合Ribbon负载均衡，默认的是轮询，重新注入IRule可以实现负载均衡的其他策略

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70 2][]

# 四、Rest请求模板类解读 #

当我们从服务消费端去调用服务提供者的服务的时候,使用了一个极其方便的对 象叫 RestTemplate,当时我们只使用了 Rest Template中最简单的一个功能 getForEntity发起了一个get请求去调用服务端的数据,同时,我们还通过配置@ Loadbalanced注解开启客户端负载均衡, RestTemplate的功能非常强大, 那么接下来就来详细的看一下 RestTemplate中几种常见请求方法的使用。 在日常操作中,基于Rest的方式通常是四种情况,它们分表是

**GET请求-查询数据**

**POST请求-添加数据**

**PUT请求-修改数据**

**DELETE-删除数据**

4-1、RestTemplate的GET请求

**Get请求可以有两种方式**

第一种：getForEntity(..)

该方法返回一个ResponseEntity<T>对象，ResponseEntity<T>是Spring对HTTP请求响应的封装，包括了几个重要的元素，比如响应码，contentType，contentLength，响应消息体等

ResponseEntity<String> forEntity = restTemplate.getForEntity("http://SPRINGCLOUD-SERVICE-PROVIDER/provider/hello", String.class);
 String body = forEntity.getBody();
 HttpStatus statusCode = forEntity.getStatusCode();
 int statusCodeValue = forEntity.getStatusCodeValue();
 HttpHeaders headers = forEntity.getHeaders();
 
 System.out.println(body);
 System.out.println(statusCode);
 System.out.println(statusCodeValue);
 System.out.println(headers);

以上代码：

getForEntity方法第—个参数为要调用的服务的地址,即服务提供者提供的[http://SPRINGCLOUD-SERVICE-PROVIDER/provider/hello][http_SPRINGCLOUD-SERVICE-PROVIDER_provider_hello]接口地址,注意这里是通过服务名调用而不是服务地址,如果改为服务地址就无法使用 Ribbon实现客户端负载均衡了。 getForEntity方法第二个参数 String.class表示希望返回的body类型是 String 类型,如果希望返回一个对象,也是可以的，比如User对象

/**
 * 调用get请求,返回一个User对象
 * @return
 */
 @RequestMapping("/user")
 public User user(){
 //逻辑判断省略
 ResponseEntity<User> forEntity = restTemplate.getForEntity("http://SPRINGCLOUD-SERVICE-PROVIDER/provider/user", User.class);
 System.out.println(forEntity.getBody().getId()+""+forEntity.getBody().getName()+""+forEntity.getBody().getPhone());
 return forEntity.getBody();
 }

另外两个重载方法:

第一个重载方法：

@Override
 	public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables)
 			throws RestClientException {
 
 		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
 		ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
 		return nonNull(execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables));
 	}
 
 	@Override
 	public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)
 			throws RestClientException {
 
 		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
 		ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
 		return nonNull(execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables));
 	}

比如：

/**
 * 给服务传参数Get请求
 * @return
 */
 @RequestMapping("/getUser")
 public User getUser(){
 //逻辑判断省略
 String [] arr={"2","xxx","4545645456"};
 Map<String,Object> map=new HashMap<>();
 map.put("id",1);
 map.put("name","wwwwww");
 map.put("phone","1213213213123");
 
 //ResponseEntity<User> forEntity = restTemplate.getForEntity("http://SPRINGCLOUD-SERVICE-PROVIDER/provider/getUser?id={0}&name={1}&phone={2}", User.class,arr);
 //ResponseEntity<User> forEntity = restTemplate.getForEntity("http://SPRINGCLOUD-SERVICE-PROVIDER/provider/getUser?id={id}&name={name}&phone={phone}", User.class,map);
 /*
 * restTemplate.getForObject在getForObject在getForEntity在次封装，直接获取返回值类型，相当于ResponseEntity中的getBody
 */
 User user1 = restTemplate.getForObject("http://SPRINGCLOUD-SERVICE-PROVIDER/provider/getUser?id={id}&name={name}&phone={phone}", User.class, map);
 
 //System.out.println(forEntity.getBody().getId()+""+forEntity.getBody().getName()+""+forEntity.getBody().getPhone());
 System.out.println(user1.getId()+""+user1.getName()+""+user1.getPhone());
 return user1;
 }

可以用一个数字做占位符，最后是一个可变长度的参数，来来替换前面的占位符

也可以前面使用name=\{name\}这种形式，最后一个参数是一个map，map的key即为前边占位符的名字，map的value为参数值

第二种：getForObject(..)

与 getForEntity使用类似,只不过 getForobject是在 getForEntity基础上进行了再次封装,可以将http的响应体body 信息转化成指定的对象,方便我们的代码开发: 当你不需要返回响应中的其他信息,只需要body体信息的时候,可以使用这个更方便; 它也有两个重载的方法,和 getForEntity相似

@Override
 	@Nullable
 	public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
 		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
 		HttpMessageConverterExtractor<T> responseExtractor =
 				new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
 		return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
 	}
 
 	@Override
 	@Nullable
 	public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
 		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
 		HttpMessageConverterExtractor<T> responseExtractor =
 				new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
 		return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
 	}
 
 	@Override
 	@Nullable
 	public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException {
 		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
 		HttpMessageConverterExtractor<T> responseExtractor =
 				new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
 		return execute(url, HttpMethod.GET, requestCallback, responseExtractor);
 	}

上面例子已经涉及到了，此处不再啰嗦。

4-2、RestTemplate的POST请求

restTemplate.postForEntity();
    restTemplate.postForObject();
    restTemplate.postForLocation();

例如：

/**
 * 调用POST请求
 * @return
 */
 @RequestMapping("/addUser")
 public User addUser(){
 //逻辑判断省略
 String [] arr={"2","xxx","4545645456"};
 //不能使用map传递参数
 Map<String,Object> map=new HashMap<>();
 map.put("id",1);
 map.put("name","wwwwww");
 map.put("phone","1213213213123");
 
 /**
 *要传的表单信息，参数数据（很坑人）
 */
 MultiValueMap<String,Object> multiValueMap=new LinkedMultiValueMap<>();
 multiValueMap.add("id",1);
 multiValueMap.add("name","xxxxx");
 multiValueMap.add("phone","000000000");
 
 //使用jdk中的map传参数，接收不到
 ResponseEntity<User> userResponseEntity = restTemplate.postForEntity(
 "http://SPRINGCLOUD-SERVICE-PROVIDER/provider/addUser", multiValueMap, User.class);
 
 System.out.println(userResponseEntity.getBody().getId()+""+userResponseEntity.getBody().getName()+""+userResponseEntity.getBody().getPhone());
 return userResponseEntity.getBody();
 }

4-3、RestTemplate的PUT请求

restTemplate.put();

例如：

/**
 * 调用PUT请求
 * @return
 */
 @RequestMapping("/updateUser")
 public String updateUser(){
 //逻辑判断省略
 String [] arr={"2","xxx","4545645456"};
 //不能使用map传递参数
 Map<String,Object> map=new HashMap<>();
 map.put("id",1);
 map.put("name","wwwwww");
 map.put("phone","1213213213123");
 
 /**
 *要传的表单信息，参数数据（很坑人）
 */
 MultiValueMap<String,Object> multiValueMap=new LinkedMultiValueMap<>();
 multiValueMap.add("id",1);
 multiValueMap.add("name","xxxxx");
 multiValueMap.add("phone","000000000");
 
 //使用jdk中的map传参数，接收不到
 restTemplate.put("http://SPRINGCLOUD-SERVICE-PROVIDER/provider/updateUser", multiValueMap);
 
 return "SUCCESS";
 }

4-4、RestTemplate的DELETE请求

restTemplate.delete();

例如：

/**
 * 调用DELETE请求
 * @return
 */
 @RequestMapping("/deleteUser")
 public String deleteUser(){
 //逻辑判断省略
 String [] arr={"2","xxx","4545645456"};
 Map<String,Object> map=new HashMap<>();
 map.put("id",1);
 map.put("name","wwwwww");
 map.put("phone","1213213213123");
 
 /**
 *要传的表单信息，参数数据（很坑人），只有post,PUT请求采用这种map传参数
 */
 /* MultiValueMap<String,Object> multiValueMap=new LinkedMultiValueMap<>();
 multiValueMap.add("id",1);
 multiValueMap.add("name","xxxxx");
 multiValueMap.add("phone","000000000"); */
 
 //使用jdk中的map传参数，接收不到,不能使用MultiValueMap，接收不到参数
 restTemplate.delete("http://SPRINGCLOUD-SERVICE-PROVIDER/provider/deleteUser?id={id}&name={name}&phone={phone}", map);
 
 return "SUCCESS";
 }

详细代码查看案例源码。

[Spring Cloud_---SpringCloud]: https://blog.csdn.net/qq_39669058/article/details/97896801
[Spring Cloud_---_Eureka]: https://blog.csdn.net/qq_39669058/article/details/98061066
[Spring Cloud_---_Eureka 1]: https://blog.csdn.net/qq_39669058/article/details/98083411
[20190814093913323.gif]: /images/20211109/fbaf41b19ef24515844544563c613bd5.png
[aHR0cHM6Ly90aW1nc2EuYmFpZHUuY29tL3RpbWc_aW1hZ2UmcXVhbGl0eT04MCZzaXplPWI5OTk5XzEwMDAwJnNlYz0xNTY0Nzg3OTg0NTQxJmRpPWQ1OTY5N2Y1MmNjYWI2Y2Y1NDcwMzFkMTRjNmQ5ZDM0JmltZ3R5cGU9MCZzcmM9aHR0cCUzQSUyRiUyRmltYWdlLmJ1YnVrby5jb20lMkZpbmZvJTJGMjAxODA5JTJGMjAxODA5MTExMTA3MDM1OTE3ODEucG5n]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly90aW1nc2EuYmFpZHUuY29tL3RpbWc_aW1hZ2UmcXVhbGl0eT04MCZzaXplPWI5OTk5XzEwMDAwJnNlYz0xNTY0Nzg3OTg0NTQxJmRpPWQ1OTY5N2Y1MmNjYWI2Y2Y1NDcwMzFkMTRjNmQ5ZDM0JmltZ3R5cGU9MCZzcmM9aHR0cCUzQSUyRiUyRmltYWdlLmJ1YnVrby5jb20lMkZpbmZvJTJGMjAxODA5JTJGMjAxODA5MTExMTA3MDM1OTE3ODEucG5n
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70]: /images/20211109/75ebc9513c6746afaad6a582c42fed1e.png
[20190803065653311.png]: /images/20211109/95b39f1078424fa9839320d947ac2687.png
[20190803065633809.png]: /images/20211109/6efcef1cb2574e948b990492b0923195.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70 1]: /images/20211109/c8f2244070f34f7ebffd0de6a99941f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjY5MDU4_size_16_color_FFFFFF_t_70 2]: /images/20211109/87d56f1b75074c3485043c32ccfdf71c.png
[http_SPRINGCLOUD-SERVICE-PROVIDER_provider_hello]: http://SPRINGCLOUD-SERVICE-PROVIDER/provider/hello