【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

　　　　結果：返回結果以達到輪詢的目的