Ribbon负载均衡服务调用

Ribbon概念

SpringCloud Ribbon （目前也进入了维护模式）是基于Netflix Ribbon 实现的一套客户端负载均衡工具。简单的说，Ribbon 是Netflix发布的开源项目，主要功能是：提供客户端软件负载均能算法和服务调用。Ribbon客户端组件提供一系列完善的配置项，如：连接超时、重试等，就是在配置文件中列出 Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如：单轮询、随机连接等）去连接这些机器。我们很容易使用 Ribbon 实现自定义的负载均衡算法。

Ribbon作用

1、实现LB负载均衡（Load Balance）
简单的说，就是将用户的请求按照某种规则分配到多个服务器上，从而达到系统HA（高可用）（一句话，负载均衡+RestTemplate）。常见的负载均衡软件有 Nginx、LVS、硬件 F5等。

2、Ribbon本地负载均衡客户端 【进程内LB】 与 Nginx服务端负载均衡 【集中式LB】 的区别
（1）Ribbon 本地负载均衡，在调用微服务接口时候，会在注册中心上获取注册信息服务列表，之后缓存到JVM本地，从而在本地实现RPC远程服务调用技术。
（2）Nginx 是服务器负载均衡，客户端所有的请求都会交给Nginx，然后由Nginx实现转发请求。即：负载均衡是有服务端实现的。

3、进程内LB 与 集中式LB的概念
（1）进程内LB：将LB逻辑集成到消费方，消费方从服务注册中心获取有哪些地址可用个，然后自己在从这些地址中选出一个合适的服务器。Ribbon 就属于进程内LB，它是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方地址。
（2）集中式LB：即在服务的消费方和提供方使用独立的LB设施（可以是硬件，如：F5，也可以是软件，如：Nginx），由该设施负责吧访问请求通过某种策略转发至服务的提供方。

Ribbon调用结构图

1、Ribbon其实就是一个软负载均衡的客户端组件，它可以和其他所需请求的客户端结合使用。

2、Ribbon 在工作是分成两步
（1）选择注册中心，它优先选择在同一区域内选择负载较少的server；
（2）再根据用户指定的策略，在从server中取到的服务注册列表中选择一个地址。
其中，Ribbon提供了多种策略，比如：轮询、随机和根据响应时间加权。

引入Ribbon的依赖

1、Ribbon 的 pom 依赖

<dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

2、注意：在Eureka、zookeeper的依赖引入中，已经整合了Ribbon。如图所示：
（1）引入Eureka

（2）引入Zookeeper

Ribbon核心组件（IRule）

1、Ribbon 自带常见常用的 IRule实现类

IRule实现类	解析
com.netflix.loadbalancer.RoundRobinRule	轮询
com.netflix.loadbalancer.RandomRule	随机
com.netflix.loadbalancer.RetryRule	先按照RoundRobinRule的策略获取服务，如果获取服务失败则在指定时间内会进行重试
WeightedResponseTimeRule	对RoundRobinRule的扩展，响应速度越快的实例选择权重越大，越容易被选择
BestAvailableRule	会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务
AvailabilityFilteringRule	先过滤掉故障实例，再选择并发较小的实例
ZoneAvoidanceRule	默认规则，复合判断server所在区域的性能和server的可用性选择服务器

2、如何替换IRule自带算法
（1）注意配置细节：
官方文档明确给出了警告：这个定义配置类不能放在@ComponentScan所扫描的当前包下以及所有子包下，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，达不到特殊化定制的目的。如图正确配置：

（2）MyselfRule自定义轮询策略

@Configuration
public class MyselfRule {

    @Bean
    public IRule myRule() {
        return new RandomRule(); //定义为随机
    }
}

（3）主启动类配置

@SpringBootApplication
@EnableEurekaClient
/*
    @RibbonClients 可以根据调用不同的服务提供者配置不同负载规则，

*/
@RibbonClients(value = {
        @RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = {MyselfRule.class}),
})
public class EKOrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(EKOrderMain80.class, args);
    }
}

Ribbon负载均衡算法（手动实现）

1、手动实现负载策略：面向接口编程
（1）负载策略接口

public interface LoadBalancer {

    ServiceInstance instances(List<ServiceInstance> serviceInstances);

}

（2）实现类

@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 >= Integer.MAX_VALUE ? 0 : current + 1;

        } while (!this.atomicInteger.compareAndSet(current, next));
        System.out.println("****第几次访问，次数next：" + next);
        return next;
    }

    @Override
    public ServiceInstance instances(List<ServiceInstance> serviceInstances) {
        int index = getAndIncrement() % serviceInstances.size();
        return serviceInstances.get(index);
    }
}

2、ApplicationContextConfig（注意）

/*
	使用 Ribbon 实现自定义负载策略时，注释 Ribbon 自带的 @LoadBalanced 注解
*/
@Configuration
public class ApplicationContextConfig {

    @Bean
//    @LoadBalanced   //使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

3、controller层

@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("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id) {
        URI uri = loadBalancer.instances(discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE")).getUri();
        return restTemplate.getForObject(uri + "/payment/get/" + id, CommonResult.class);
    }

    @GetMapping(value = "/consumer/payment/lb")
    public String getPaymentLB() {
        System.out.println(Integer.MAX_VALUE);
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        if (instances == null || instances.size() <= 0) {
            return null;
        }
        ServiceInstance serviceInstance = loadBalancer.instances(instances);
        URI uri = serviceInstance.getUri();
        return restTemplate.getForObject(uri + "/payment/lb", String.class);
    }
}