【SpringCloud】自定义Ribbon均衡策略（七）

　　本章介绍Ribbon自定义规则

Ribbon自带随机均衡策略

　　1、搭建项目，参考：【SpringCloud】服务提供者集群与服务发现Discovery（三） 

　　2、新增配置类，配置类中注入IRule的实现类

　　　　在调用者项目（test-springcloud-order8000）中，新增一个配置类com.test.myrule.MySelfRule

package com.test.myrule;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MySelfRule {

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

　　　注意，官方文档明确给出警告：

　　　　这个自定义配置类不能放在@Configuration所扫描的当前包及子包下，否则我们自定义的这个配置类就会被所有Ribbon客户端共享，达不到特殊化定制的目的了

　　　　如果想要Ribbon客户端共享，那边就放在@Configuration所扫描的地方

　　　　

　　3、使用新增的配置类对“CLOUD-PAYMENT-SERVICE”服务生效，在启动类com.test.springcloud.Application上增加注解

　　　　@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)

　　　　name指定针对哪个服务 进行负载均衡，而configuration指定负载均衡的算法具体实现类。

package com.test.springcloud;

import com.test.myrule.MySelfRule;
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;

@EnableEurekaClient
@SpringBootApplication
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration = MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class, args);
    }
}

　　4、启动项目，测试项目

　　　　使用地址：http://localhost:8000/consumer/payment/get/1

　　　　可以看到，的到的响应内容是从提供者的2个节点中，随机的到的。

自定义Ribbon均衡策略

　　1、新增一个IRule的实现类

package com.test.myrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;

public class MyCustomeRule extends AbstractLoadBalancerRule {

    private int total = 0;             // 总共被调用的次数，目前要求每台被调用5次
    private int currentIndex = 0;    // 当前提供服务的下标

    public Server choose(ILoadBalancer loadBalancer, Object key) {

        if (loadBalancer == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = loadBalancer.getReachableServers(); //当前存活的服务
            List<Server> allList = loadBalancer.getAllServers();  //获取全部的服务

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

            //int index = rand.nextInt(serverCount);
            //server = upList.get(index);
            if(total < 5)
            {
                server = upList.get(currentIndex);
                total++;
            }else {
                total = 0;
                currentIndex++;
                if(currentIndex >= upList.size())
                {
                    currentIndex = 0;
                }
            }

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

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

            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }
        return server;
    }

    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }
    public void initWithNiwsConfig(IClientConfig clientConfig) {

    }
}

　　2、修改配置类，在配置类中注入新编写的实现类，同上

　　@RibbonClient(name = "CLOUD-PAYMENT-SERVICE", configuration =MyCustomeRule.class)

　　3、启动项目，测试

　　使用地址：http://localhost:8000/consumer/payment/get/1

　　结果：每5次访问，之后切换节点

自定义均衡器

　　流程：使用DiscoveryClient发现服务—》通过自定义均衡器筛选服务—》使用RestTemplate调用

　　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.getAndIncrement();
            next = current >= Integer.MAX_VALUE ? 0 : current + 1;
        } while (this.atomicInteger.compareAndSet(current, next));
        System.out.println("=======next:" + next);
        return next;
    }

    public ServiceInstance instances(List<ServiceInstance> serviceInstances) {

        int index = getAndIncrement() % serviceInstances.size();
        return serviceInstances.get(index);
    }
}

　　3、编写controller方法

@RestController
@Slf4j
public class OrderController {

    @Autowired
    private LoadBalancer loadBalancer;

    @Autowired
    private DiscoveryClient discoveryClient;

    // 未使用Ribbon包装restTemplate
    private RestTemplate restTemplate = new RestTemplate();


    @GetMapping("/consumer/payment/get/{id}/lb")
    public CommonResult<Payment> getPaymentLB(@PathVariable("id") Long id){
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        if(instances == null || instances.size() == 0) {
            return null;
        }

        ServiceInstance instance = loadBalancer.instances(instances);
        URI uri = instance.getUri();

        return restTemplate.getForObject(uri + "/payment/get/" + id, CommonResult.class);
    }
}

　　　　注意：

　　　　1）restTemplate对象，未被Ribbon包装

　　　　2）此处的instance.getUri()获取的url地址，可能是主机名称+端口，需要改成是IP+端口。而要获取到的是IP+端口，需要服务提供者，在Eureka注册的时候，使用ip注册

　　　　服务端注册增加配置如下：

eureka:
  instance:
    #  instance:
    instance-id: ${spring.cloud.client.ip-address}:${server.port}
    # 访问路径可以显示IP地址
    prefer-ip-address: true

　　4、启动项目，测试

　　　　访问地址：http://localhost:8000/consumer/payment/get/1/lb

　　　　结果：返回结果以达到轮询的目的