92-java-springcloud(05)-负载均衡-Ribbon

Ribbon

一.Ribbon的概述

1.官网
参考文档:
https://cloud.spring.io/spring-cloud-static/spring-cloud-netflix/2.2.3.RELEASE/reference/html/#spring-cloud-ribbon

2.ribbon是什么?

ribbon是一个客户端负载均衡,是调用方得到地址,自己控制访问的算法策略.

3.ribbon和nginx的对比

Ribbon对比Nginx

	Ribbon	Nginx
使用方	客户端负载均衡	服务端负载均衡
范围	单个进程内	进程外
原理	调用方拿到访问地址,自己选择访问哪个请求	调用方请求发过来,服务方决定访问哪个请求
特点	消费方控制负载均衡策略	服务提供方控制负载均衡策略
应用场景	分布式微服务内部客户端的调用	外部请求访问服务

二.Ribbon的使用

1.基本使用

(1)pom 依赖

• Eureka的客户端默认集成了Ribbon,Nacos也是一样的,Feign也一样依赖了RIbbon.
  

(2)yml配置
ribbon默认可以不用任何配置.

(3)主启动类
默认也不需要配置.

(4)业务类

• RestTemplate+Ribbon
  如果是RestTemplate+Ribbon作为客户端调用,则只需要这个注解@LoadBalanced 修饰如下即可

@Configuration
public class ApplicationContextConfig {

    /**
     * 注入一个rest风格调用主体类
     * @return
     */
    @Bean
    //负载均衡策略,使用集群策略,这个注解不能少,少了就会报错
    //这是ribbon的负责均衡注解,因为eureka已经集成了ribbon,所以就可以直接用此注解
    @LoadBalanced  
    public RestTemplate getRestTemplate(){
        return  new RestTemplate();
    }
}

• Feign + Ribbon
  如果是Feign+Ribbon来作为调用客户端,则这个注解都可省略.
  具体详情在后续Feign的分享的时候在说.

2.负载均衡策略

(1) Ribbon默认给我们提供了多种负载均衡类.

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

(2) 如何切换使用负载均衡策略.

1) 配置全局的负载均衡策略

• 新建一个配置类.
  #在主启动类能够扫描的范围
  
• 编写一个负载均衡策略配置类

/**
 * @author gl
 * @time 2020-06-17 1:04
 * @function : 切换本项目,所有的服务调用的策略
 * @step :
 * 1.在springboot主启动类扫描到的地方,新建一个配置类
 * 2.在配置类中向容器中注入一个IRule类的实现类
 * 这样就是本项目所有的调用使用的此负载策略.
 */
@Configuration
public class AllRuler {

    /**
     * 这里使用的随机的策略
     * @return
     */
    @Bean
    public IRule getMySelfRule(){
        return new RandomRule();
    }
}

• 注入RestTemplate对象的时候使用@LoadBalanced注解

@Configuration
public class ApplicationContextConfig {

    /**
     * 注入一个rest风格调用主体类
     * @return
     */
    @Bean
    //负载均衡策略,使用集群策略,这个注解不能少,少了就会报错
    //这是ribbon的负责均衡注解,因为eureka已经集成了ribbon,所以就可以直接用此注解
    @LoadBalanced 
    public RestTemplate getRestTemplate(){
        return  new RestTemplate();
    }
}

2) 根据调用的服务名,指定负载均衡策略

• 新建一个配置类.
  #在主启动类能够扫描的范围之外
  
• 编写一个负载均衡策略配置类

/**
 * @author gl
 * @time 2020-06-17 1:04
 * @function : 给指定的服务配置自己的轮询算法,这里使用的是随机的额轮询算法
 * @step :
 * 1.在springboot扫描不到的包下,新建一个配置类
 * 2.在配置类中向容器中注入一个IRule类的实现类
 * 3.启动类上使用注解
 * @RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration = MySelfRuler.class)
 * 指定调用具体的哪个服务,使用我们自定义的本负载均衡策略
 */
@Configuration
public class MySelfRuler {

    /**
     * 这里使用的随机算法
     * @return
     */
    @Bean
    public IRule getMySelfRule(){
        return new RoundRobinRule();
    }
}

• 注入RestTemplate对象的时候使用@LoadBalanced注解

@Configuration
public class ApplicationContextConfig {

    /**
     * 注入一个rest风格调用主体类
     * @return
     */
    @Bean
    //负载均衡策略,使用集群策略,这个注解不能少,少了就会报错
    //这是ribbon的负责均衡注解,因为eureka已经集成了ribbon,所以就可以直接用此注解
    @LoadBalanced 
    public RestTemplate getRestTemplate(){
        return  new RestTemplate();
    }
}

• 主启动类上添加注解@RibbonClient

//启动Eureka的client
@EnableEurekaClient
@SpringBootApplication
//@RibbonClient表示特殊指定,用于指定调用CLOUD-PAYMENT-SERVICE微服务,使用这个类MySelfRuler的负载均衡策略
//name = "CLOUD-PAYMENT-SERVICE",这个表示具体调用哪个微服务
//configuration = MySelfRuler.class ,表示使用哪个负载均衡配置类
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration = MySelfRuler.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}

(3) 如何自定义负载均衡算法

这里以自己实现轮询算法为例

• 定义算法的顶层接口

/**
 * @author gl
 * @time 2020-06-17 22:59
 * @function : 自己手写轮询算法的顶层接口
 * @step :
 */
public interface LoadBalancer {
     /**
     *  根据算法,选择调用具体哪个服务实例
     * @param serviceInstances 传入的是服务实例的集合
     * @return 调用的具体哪个服务实例
     */
    ServiceInstance instances(List<ServiceInstance> serviceInstances);

}

• 编写轮询算法的实现类

/**
 * @author gl
 * @time 2020-06-17 23:00
 * @function :  这是自己手写的轮询算法
 * @step :
 */
@Component
public class MyLb implements LoadBalancer {
    //定义一个原子类
    private AtomicInteger atomicInteger = new AtomicInteger(0);

    //利用CAS原理加锁,来统计访问的次数
    private 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;
    }


    /**
     *  根据算法,选择调用具体哪个服务实例
     * @param serviceInstances 传入的是服务实例的集合
     * @return 调用的具体哪个服务实例
     */
    @Override
    public ServiceInstance instances(List<ServiceInstance> serviceInstances) {
        int index = getAndIncrement() % serviceInstances.size(); //得到服务器的下标位置
        return serviceInstances.get(index);

    }
}

• RestTemplate注入的时候取消使用Ribbon默认的负载均衡策略
  #删除注解@loadBalanced

/**
 * @author gl
 * @time 2020-06-13 15:31
 * @function : applicationContext的配置类
 * @step :
 */
@Configuration
public class ApplicationContextConfig {

    /**
     * 注入一个rest风格调用主体类
     * @return
     */
    @Bean
    //负载均衡策略,使用集群策略,这个注解不能少,少了就会报错
    //这是ribbon的负责均衡注解,因为eureka已经集成了ribbon,所以就可以直接用此注解
    //@LoadBalanced  //因为我们这里要使用自定义的负载均衡算法,所以我们注释掉ribbon的注解
    public RestTemplate getRestTemplate(){
        return  new RestTemplate();
    }
}

• 联机调用服务的时候使用自定义的算法

@RestController
@Slf4j
public class OrderController {

    //public static final String PAYMENT_URL = "http://localhost:8001";  单机版,写死
    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";  //集群版,根据服务名来选择提供服务的服务
	 @Autowired //调用客户端
    private RestTemplate template;

    @Autowired //springboot自动注入的注册中心连接对象
    private DiscoveryClient discoveryClient;

    @Autowired //自定义的负载均衡算法实现类
    private LoadBalancer loadBalancer;

    //自己实现的轮询算法
    @GetMapping(value = "/consumer/payment/lb")
    public String getPaymentLB(){
        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 template.getForObject(uri+"/payment/lb",String.class);
    }
}