（十）、Ribbon负载均衡和调用

<dependency>
    <groupld>org.springframework.cloud</groupld>
    <artifactld>spring-cloud-starter-netflix-ribbon</artifactid>
</dependency>

@GetMapping("/consumer/payment/getForEntity/{id}")
public CommonResult<Payment> getPayment2(@PathVariable("id") Long id)
{
    ResponseEntity<CommonResult> entity = restTemplate.getForEntity(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    if(entity.getStatusCode().is2xxSuccessful()){
        return entity.getBody();//getForObject()
    }else{
        return new CommonResult<>(444,"操作失败");
    }
}

package com.ylc.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 {
    public IRule myRule()
    {
        return  new RandomRule();//定义为随机
    }
}

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

package com.netflix.loadbalancer;
public interface IRule {
    //集群选择
    Server choose(Object var1);
    void setLoadBalancer(ILoadBalancer var1);
    ILoadBalancer getLoadBalancer();
}

public class RoundRobinRule extends AbstractLoadBalancerRule {
    //AtomicInteger原子整型类，用于计算对应请求调用服务器的下标
    private AtomicInteger nextServerCyclicCounter;
    private static final boolean AVAILABLE_ONLY_SERVERS = true;
    private static final boolean ALL_SERVERS = false;
    private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);
    public RoundRobinRule() {
        //初始为0
        this.nextServerCyclicCounter = new AtomicInteger(0);
    }
    public RoundRobinRule(ILoadBalancer lb) {
        this();
        this.setLoadBalancer(lb);
    }
    //负载均衡核心方法 返回的server对象即为选定使用的调用服务器
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        } else {
            Server server = null;//初始化
            int count = 0;
            while(true) {
                //还没选到执行的server，并且选择的次数没超过10次，进行选择server
                if (server == null && count++ < 10) {
                    //返回所有可用的服务实例，即状态为up的
                    List<Server> reachableServers = lb.getReachableServers();
                    //请求的服务下所有服务实例
                    List<Server> allServers = lb.getAllServers();
                    //实例的数量
                    int upCount = reachableServers.size();
                    int serverCount = allServers.size();
                    //如果有可用的服务
                    if (upCount != 0 && serverCount != 0) {
                        //直接计算返回了调用服务器server的下标
                        int nextServerIndex = this.incrementAndGetModulo(serverCount);
                        //根据下标获取服务器
                        server = (Server)allServers.get(nextServerIndex);
                        if (server == null) {
                            Thread.yield();
                        } else {
                            //当选取的server存活并可用
                            if (server.isAlive() && server.isReadyToServe()) {
                                return server;
                            }
                            server = null;
                        }
                        continue;
                    }
                    //如果没有可用的服务
                    log.warn("No up servers available from load balancer: " + lb);
                    return null;
                }
                    //选择超过10次 无法获取到server，打印日志
                if (count >= 10) {
                    log.warn("No available alive servers after 10 tries from load balancer: " + lb);
                }
                return server;
            }
        }
    }
   //计算返回调用服务器server下标的关键方法
    private int incrementAndGetModulo(int modulo) {
        int current;
        int next;
        do {
            //获取value - CAS中对应旧的预期值 初始为0 
            current = this.nextServerCyclicCounter.get();
            //加1取余 (0+1)%2=1  
            next = (current + 1) % modulo;
            //进行CAS判断，保证上一步计算过程中，没有被其他线程或外部修改。若当前nextServerCyclicCounter与current值相同，则为true并将其设置为计算后的next。
        } while(!this.nextServerCyclicCounter.compareAndSet(current, next));//自旋锁
        return next;
    }
    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

@GetMapping(value = "/payment/lb")
    public String getPaymentLB() {
        return serverPort;//返回服务接口
    }

package com.ylc.cloud.lb;
import org.springframework.cloud.client.ServiceInstance;
import java.util.List;
public interface LoadBalancer {
    ServiceInstance instances(List<ServiceInstance> serviceInstances);
}

package com.ylc.cloud.lb;
import org.springframework.cloud.client.ServiceInstance;
import java.util.List;
public class MyLb implements LoadBalancer{
    @Override
    public ServiceInstance instances(List<ServiceInstance> serviceInstances) {
        return null;
    }
}

@Resource
private LoadBalancer loadBalancer;
@Resource
private DiscoveryClient discoveryClient;
@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 restTemplate.getForObject(uri+"/payment/lb",String.class);
}