Ribbon负载均衡服务调用
概述
Spring Cloud Ribbon是基于Netflix Ribbon实现的一套 客户端 负载均衡的工具。
简单的来说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。就是在配置文件中列出Load Balance(简称LB)后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们很容易使用Ribbon实现自定义的负载均衡算法。
官网资料：https://github.com/Netflix/ribbon/wiki/Getting-Started
LB(负载均衡)
LB负载均衡（Load Balance）是什么？
简单的来说就是用户的请求平摊的的分配到多个服务上，从而达到系统的HA（高可用）。常见的负载均衡有软件Nginx,LVS,硬件F5等。
Ribbon本地负载均衡客户端VS Nginx服务端负载均衡区别
Nginx是服务器负载均衡，客户端所有请求都会交给nginx,然后有nginx实现转发请求。即负载均衡是由服务端实现的。
Ribbon本地负载均衡，在调用微服务接口时候，会再注册中心上获取注册信息服务列表之后缓存到JVM本地，从而在本地实现RPC运程服务调用技术。
集中式LB
即在服务的消费和提供方之间使用独立的LB设施(可以是硬件，如F5，也可以是软件，如nginx)，由该设施负责把访问请求通过某种策略转发至服务的提供方；
进程内LB
将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择一个合适的服务器。
Ribbon就属于进程内LB，它只是一个类库，集成消费方进程，消费方通过它来获取到服务提供方的地址。
总的来说：负载均衡 + RestTemplate调用
总结： Ribbon其实就是一个软负载均衡的客户端组件，他可以和其他所需请求的客户端结合使用，和eureka结合只是其中的一个实例。
Ribbon在工作时分成两步：
第一步先选择Eureka Server,它优先选择在同一个区域负载较少的server。
第二步在根据用户指定的策略，在server取到的服务注册列表中选择一个地址。
其中Ribbon提供了多种策略：比如轮询、随机和根据响应时间时间加权。
在80服务的pom文件引入：
<!--引入ribbon -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
RestTemplate的使用
官网：https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html
在80服务的控制类加上：
// 返回对象为响应体中数据转化成的对象，基本上可以理解为josn
@GetMapping(value = "/consumer/payment/getForObject/{id}")
public CommonResult<Payment> getForObject(@PathVariable("id") Long id){
return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id,CommonResult.class);
}
// 返回对象为ResponseEntity对象，包含了响应中的一些重要信息，比如响应头、响应状态码，响应体等
@GetMapping(value = "/consumer/payment/getForEntity/{id}")
public Object getForEntity(@PathVariable("id") Long id){
ResponseEntity<CommonResult> responseEntity = restTemplate.getForEntity(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
if(!responseEntity.getStatusCode().is2xxSuccessful()){
return "404 响应失败";
}else {
log.info("*******getStatusCode:{}",responseEntity.getStatusCode());
log.info("*******getHeaders:{}",responseEntity.getHeaders());
log.info("*******getBody:{}",responseEntity.getBody());
return responseEntity.getBody();
}
}
启动：
Ribbon核心组件IRule
IRule: 根据特定算法中从服务列表中选取一个要访问的服务
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.netflix.loadbalancer;
public interface IRule {
/**
* chose one alive server from lb.allServers or
* lb.upServers according to key
*
* @return choosen Server object. NULL is returned if none
* server is alailable
*/
Server choose(Object var1);
void setLoadBalancer(ILoadBalancer var1);
ILoadBalancer getLoadBalancer();
}
com.netflix.loadbalancer.RoundRobinRule
(轮询)
com.netflix.loadbalancer.RandomRule
(随机)
com.netflix.loadbalancer.RetryRule
(先按照RoundRobinRule 的策略获取服务，如果获取的服务失败则在指定时间内会进行重试，获取可用的服务)
com.netflix.loadbalancer.WeightedResponseTimeRule
(对RoundRobinRule 的扩展，响应速度越快的实例选择权越大，越容易被选择）
com.netflix.loadbalancer.BestAvailableRule
(会先过滤由于多次访问故障而处于断路跳闸状态的服务，然后选择一个并发量最小的服务)
com.netflix.loadbalancer.AvailabilityFilteringRule
(会先过滤故障实例，在选择并发较小的实例)
com.netflix.loadbalancer.ZoneAvoidanceRule
(默认规则，复合判断server所在区域的性能和server的可用性选择服务器)
如何替换
修改cloud-order-service-80服务
注：配置类必须用@Configuration注解标注，但是它不应该被包含在Spring的组件扫描路径之中，否则它将被所有的Ribbon客户端共享。如果你使用@ComponentScan（或者@SpringBootApplication），那么你应该采取措施来避免它被包含到扫描范围之中。就是说创建配置类应该不属于在启动类的同级目录或者目录下
新建包（packeage）
MySelfRule配置类：
package com.zzp.myrule;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author zzp
* @create 2021-02-22
*/
@Configuration
public class MySelfRule {
@Bean
public IRule myRule(){
// 定义为随机
return new RandomRule();
}
}
在OrderMain80启动添加@RibbonClient
package com.zzp.springcloud;
import com.zzp.myrule.MyRule;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
/**
* @author zzp
* @create 2021-02-12
*/
@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration = MyRule.class)
public class OrderMain80 {
public static void main(String[] args) {
SpringApplication.run(OrderMain80.class,args);
}
}
启动：
随机获取服务
Ribbon负载均衡的算法
原理
注释cloud-order-service-80服务的@RibbonClient
现在是轮询
负载均衡的算法：rest接口第几次请求 %（取余）服务器集群总数量 = 实际调用服务位置下标，每次服务重启动后rest接口计数从1开始
List instances = discoveryClient.getInstances(“CLOUD-PAYMENT-SERVICE”);//获取两台服务实例
如： List[0] instances = 127.0.0.1:8002
如： List[1] instances = 127.0.0.1:80018001+ 8002 组合成为集群，它们共计2台机器，集群总数为2，按照轮询算法原理：
当总请求数为1时； 1 % 2 = 1 对应下标为1，则获取服务地址为127.0.0.1:8001
当总请求数为2时； 2 % 2 = 0 对应下标为0，则获取服务地址为127.0.0.1:8002
当总请求数为3时；3 % 2 = 1 对应下标为1，则获取服务地址为127.0.0.1:8001
当总请求数为4时；4 % 2 = 1 对应下标为0，则获取服务地址为127.0.0.1:8002
如此类推…
源码
RoundRobinRule继承AbstractLoadBalancerRule
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.netflix.loadbalancer;
import com.netflix.client.config.IClientConfig;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* The most well known and basic load balancing strategy, i.e. Round Robin Rule.
*
*@author stonse
*@author Nikos Michalais <nikos@netflix.com>
*
*/
public class RoundRobinRule extends AbstractLoadBalancerRule {
private AtomicInteger nextServerCyclicCounter;
private static final boolean AVAILABLE_ONLY_SERVERS = true;
private static final boolean ALL_SERVERS = false;
private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);
public RoundRobinRule() {
this.nextServerCyclicCounter = new AtomicInteger(0);
}
public RoundRobinRule(ILoadBalancer lb) {
this();
this.setLoadBalancer(lb);
}
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
log.warn("no load balancer");
return null;
} else {
Server server = null;
int count = 0;
while(true) {
if (server == null && count++ < 10) {
// 获取活着的机器
List<Server> reachableServers = lb.getReachableServers();
List<Server> allServers = lb.getAllServers();
int upCount = reachableServers.size();
// 集群总数
int serverCount = allServers.size();
if (upCount != 0 && serverCount != 0) {
//获取当前的下标位置
int nextServerIndex = this.incrementAndGetModulo(serverCount);
server = (Server)allServers.get(nextServerIndex);
if (server == null) {
Thread.yield();
} else {
if (server.isAlive() && server.isReadyToServe()) {
return server;
}
server = null;
}
continue;
}
log.warn("No up servers available from load balancer: " + lb);
return null;
}
if (count >= 10) {
log.warn("No available alive servers after 10 tries from load balancer: " + lb);
}
return server;
}
}
}
private int incrementAndGetModulo(int modulo) {
int current;
int next;
do {
current = this.nextServerCyclicCounter.get();
next = (current + 1) % modulo;
}while(!this.nextServerCyclicCounter.compareAndSet(current, next));// CAS + 自旋锁
return next;
}
public Server choose(Object key) {
return this.choose(this.getLoadBalancer(), key);
}
public void initWithNiwsConfig(IClientConfig clientConfig) {
}
}
/**
* @return Only the servers that are up and reachable (活着的机器)
*/
public List<Server> getReachableServers();
/**
* Atomically sets the value to the given updated value
* if the current value {@code ==} the expected value.
*
* @param expect the expected value
* @param update the new value
* @return {@code true} if successful. False return indicates that
* the actual value was not equal to the expected value.
*/
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
手写一个负载的算法
8001和8002的控制类添加：
@GetMapping(value = "/payment/lb")
public String getPaymentLB(){
return servicePort;
}
80服务改造
RestTemplateConfig类去掉@LoadBalanced
package com.zzp.springcloud.config;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
/**
* @author zzp
* @create 2021-02-12
*/
@Component
public class RestTemplateConfig {
@Bean
// @LoadBalanced
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}
添加配置类
LoadBalancer类：
package com.zzp.springcloud.lb;
import org.springframework.cloud.client.ServiceInstance;
import java.util.List;
/**
* @author zzp
* @create 2021-02-22
*/
public interface LoadBalancer {
//收集活着的机器
ServiceInstance instances(List<ServiceInstance> serviceInstances);
}
MyLB类：
package com.zzp.springcloud.lb;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 参考 RoundRobinRule
* @author zzp
* @create 2021-02-22
*/
@Component
public class MyLB implements LoadBalancer {
private AtomicInteger atomicInteger = new AtomicInteger(0);
public final int getAndIncrement(){
int current;
int next;
do {
current = this.atomicInteger.get();
next = current >= 2147483647 ? 0 : current + 1;
}while (!this.atomicInteger.compareAndSet(current,next));
System.out.println("********第几次访问，次数next: " +next);
return next;
}
// 负载均衡的算法：rest接口第几次请求 %（取余）服务器集群总数量 = 实际调用服务位置下标，每次服务重启动后rest接口计数从1开始
@Override
public ServiceInstance instances(List<ServiceInstance> serviceInstances) {
// 获取下标
int index = getAndIncrement() % serviceInstances.size();
return serviceInstances.get(index);
}
}
OrderController类添加接口getPaymentLB：
package com.zzp.springcloud.controller;
import com.zzp.springcloud.entities.CommonResult;
import com.zzp.springcloud.entities.Payment;
import com.zzp.springcloud.lb.LoadBalancer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
import java.net.URI;
import java.util.List;
/**
* @author zzp
* @create 2021-02-12
*/
@RestController
@Slf4j
public class OrderController {
// public static final String PAYMENT_URL = "http://localhost:8001";
public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";
@Resource
private RestTemplate restTemplate;
@Resource
private LoadBalancer loadBalancer;
@Resource
private DiscoveryClient discoveryClient;
@GetMapping(value = "/consumer/payment/create")
public ResponseEntity<CommonResult> create(Payment payment){
return restTemplate.postForEntity(PAYMENT_URL + "/payment/create",payment, CommonResult.class);
}
@GetMapping(value = "/consumer/payment/get/{id}")
public ResponseEntity<CommonResult> getPayment(@PathVariable("id") Long id){
return restTemplate.getForEntity(PAYMENT_URL + "/payment/get/" + id,CommonResult.class);
}
// 返回对象为响应体中数据转化成的对象，基本上可以理解为josn
@GetMapping(value = "/consumer/payment/getForObject/{id}")
public CommonResult<Payment> getForObject(@PathVariable("id") Long id){
return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id,CommonResult.class);
}
// 返回对象为ResponseEntity对象，包含了响应中的一些重要信息，比如响应头、响应状态码，响应体等
@GetMapping(value = "/consumer/payment/getForEntity/{id}")
public Object getForEntity(@PathVariable("id") Long id){
ResponseEntity<CommonResult> responseEntity = restTemplate.getForEntity(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
if(!responseEntity.getStatusCode().is2xxSuccessful()){
return "404 响应失败";
}else {
log.info("*******getStatusCode:{}",responseEntity.getStatusCode());
log.info("*******getHeaders:{}",responseEntity.getHeaders());
log.info("*******getBody:{}",responseEntity.getBody());
return responseEntity.getBody();
}
}
@GetMapping(value = "/consumer/payment/lb")
public String getPaymentLB(){
List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
if(null == instances || 0 >= instances.size()){
return "无服务";
}
ServiceInstance serviceInstance = loadBalancer.instances(instances);
URI uri = serviceInstance.getUri();
return restTemplate.getForObject(uri + "/payment/lb",String.class);
}
}
启动测试
日记输出：
2574
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
