微服务架构专题四：Spring-Cloud组件：ribbon 及自定义负载均衡策略

一、ribbon是什么?

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

二、客户端负载均衡？？ 服务端负载均衡??

我们用一张图来描述一下这两者的区别

这篇文章里面不会去解释nginx，如果不知道是什么的话，可以先忽略， 先看看这张图
服务端的负载均衡是一个url先经过一个代理服务器（这里是nginx），然后通过这个代理服务器通过算法（轮询，随机，权重等等…）反向代理你的服务，来完成负载均衡

而客户端的负载均衡则是一个请求在客户端的时候已经声明了要调用哪个服务，然后通过具体的负载均衡算法来完成负载均衡。

三、如何使用:

首先，我们还是要引入依赖，但是，eureka已经把ribbon集成到他的依赖里面去了，所以这里不需要再引用
ribbon的依赖，如图：
依赖：

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

要使用ribbon，只需要一个注解：

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return  new RestTemplate();
    }
    

在RestTemplate上面加入@LoadBalanced注解，这样子就已经有了负载均衡， 怎么来证明?
我们这里现在启动了eureka 和Power集群（2个power） 和一个服务调用者（User）
配置什么意思就不做过多解释了，前面的专题讲eureka的时候有讲到过

server:
  port: 5000
eureka:
  client:
    serviceUrl:
        defaultZone: http://localhost:3000/eureka/
  instance:
    instance-id: user-1 #此实例注册到eureka服务端的唯一的实例ID
    prefer-ip-address: true #是否显示IP地址
    leaseRenewalIntervalInSeconds: 10
    leaseExpirationDurationInSeconds: 30 

spring:
  application:
    name: client-user #此实例注册到eureka服务端的name
    
    

然后启动起来的页面是这样子的：

我们能看见 微服务名:SERVER-POWER 下面有2个微服务（power-1,power2），现在我们来通过微服务名调用这个服务
这是我们的user项目的调用代码 ：

@RestController
public class UserController {

    @Autowired
    RestTemplate restTemplate;
    private static final String  POWER_URL="http://SERVER-POWER";

    @RequestMapping("/getPower.do")
    public R getPower(){
        return R.success("操作成功",restTemplate.getForObject(POWER_URL+"/getPower.do",Object.class));
    }
}

我们来看看效果:

这里可能有点抽象，需要你们自己去写才能体会到，但是我们已经完成了负载均衡， 他默认的负载均衡是轮询策略，也就是一人一次，下一节我们来讲一下他还有哪些策略。

问题：
当我们SERVER-POWER集群服务有一台power2机器当机故障时，而eureka注册中心未及时发现时会出现：

当在访问该机器之前eureka注册中心发现并注销这台机器时，则此时注册中心只有power1这台机器，再访问该API时，服务只会请求到power1这台机器上

四、核心组件：IRule

IRule是什么? 它是Ribbon对于负载均衡策略实现的接口， 怎么理解这句话？ 说白了就是你实现这个接口，就能自定义负载均衡策略， 自定义我们待会儿来讲， 我们先来看看他有哪些默认的实现。

这里是ribbon负载均衡默认的实现， 由于是笔记的关系，这里不好测试，只能你们自己去测试一下了， 具体怎么使用呢？
看代码:

    @Bean
    public IRule iRule(){
        return new RandomRule();
    }
    

完整class如下：

@ComponentScan("com")
@Configuration
public class AppConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return  new RestTemplate();
    }

    /**
     * ComponentScan可以扫描到实现了IRule的类，那么所有的微服务都会使用这个策略
     */
    @Bean
    public IRule iRule(){
        return new RandomRule();
    }

在Spring 的配置类里面把对应的实现作为一个Bean返回出去就行了。

五、自定义负载均衡策略：

我们刚刚讲过，只要实现了IRule就可以完成自定义负载均衡，至于具体怎么来，我们先看看他随机访问默认的实现。

我们来看看这个类AbstractLoadBalancerRule：

这里我们能发现，还是我们上面所说过的 实现了IRule就能够自定义负载均衡即使是他默认的策略也实现了IRule
我们可以直接把代码copy过来改动一点:
自定义IRule规则

public class CustomRule extends AbstractLoadBalancerRule {
    Random rand;

    private int nowIndex = -1;

    private int lastIndex = -1;

    private int skipIndex = -1;




    public CustomRule() {
        rand = new Random();
    }

    /**
     * 伪随机，当一个下标（微服务） 连续被调用两次， 第三次如果还是它， 那么咱们就再随机一次。
     * Randomly choose from all living servers
     */
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers();
            List<Server> allList = lb.getAllServers();

            int serverCount = allList.size();
            if (serverCount == 0) {
                return null;
            }

            int index = rand.nextInt(serverCount);
            System.out.println("当前下标:"+index);
            if (index==skipIndex){
                System.out.println("跳过");
                index =rand.nextInt(serverCount);
                lastIndex = -1;
                System.out.println("跳过之后的下标:"+index);
            }
            //1 1   0
            skipIndex = -1;
            nowIndex = index;
            if(nowIndex==lastIndex){
                System.out.println("需要跳过的下标："+nowIndex);
                skipIndex = nowIndex;
            }

            server = upList.get(index);

            lastIndex = nowIndex;

            if (server == null) {
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            server = null;
            Thread.yield();
        }

        return server;

    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub

    }
}

这里我们就把自己写的Rule给new出来交给spring 就好了。

    @Bean
    public IRule iRule(){
        //return new RandomRule();
        return new CustomRule();
    }
    

然后启动访问后，访问集群服务，控制台显示：

六、对不同的服务定义其负载均衡策略：

例如，我现在有order和power两个服务；user调用order时负载均衡使用的是随机策略，user调用power时负载均衡使用的是自定义策略；操作如下：

1、OrderRuleConfig：

@Configuration
public class OrderRuleConfig {

    @Bean
    public IRule iRule(){
        return new RandomRule();
    }
}

2、PowerRuleConfig

@Configuration
public class PowerRuleConfig {
    @Bean
    public IRule iRule(){
        return  new CustomRule();
    }
}

3、启动类配置：

@SpringBootApplication
@EnableEurekaClient
@RibbonClients({
        @RibbonClient(name = "SERVER-ORDER",configuration = OrderRuleConfig.class),
        @RibbonClient(name = "SERVER-POWER",configuration = PowerRuleConfig.class)
})
public class AppUserClient {
    public static void main(String[] args) {
        SpringApplication.run(AppUserClient.class);
    }
}

4、UserController

@RestController
public class UserController {

    @Autowired
    RestTemplate restTemplate;
    private static final String  POWER_URL="http://SERVER-POWER";
    private static final String  ORDER_URL="http://SERVER-ORDER";

    @RequestMapping("/getOrder.do")
    public R getOrder(){
        return R.success("操作成功",restTemplate.getForObject(ORDER_URL+"/getOrder.do",Object.class));
    }
    @RequestMapping("/getPower.do")
    public R getPower(){
        return R.success("操作成功",restTemplate.getForObject(POWER_URL+"/getPower.do",Object.class));
    }
}

5、允许启动，当你请求power服务时，会打印出我们自定义策略中的日志输出信息；当你请求order时，是没有相关日志输出的。测试效果希望大家自己写了之后测一下，效果会更好。