【Spring Cloud系列】- Ribbon详解与实战（下）

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import org.springframework.stereotype.Component;
import com.netflix.loadbalancer.Server;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
@Component
public class RandomRule_ZY extends AbstractLoadBalancerRule {
    //定义一个原子类，以保证原子性
    private AtomicInteger atomicInteger =new AtomicInteger(0);
    public void initWithNiwsConfig(IClientConfig iClientConfig) {
    }
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null){
            return null;
        }
        //用于统计获取次数，当达到一定数量就不再去尝试
        int count = 0;
        Server server = null;
        //当服务还没获取到，并且尝试没有超过8次
        while (server == null && count++ < 8){
            //获取服务
            List<Server> allServers = lb.getAllServers();
            List<Server> reachableServers = lb.getReachableServers();
            int allServersSize = allServers.size();
            int reachableServersSize = reachableServers.size();
            //如果获取的服务list都为0就返回null
            if(allServersSize == 0 || reachableServersSize == 0){
                return  null;
            }
            //获取服务下标
            int next = getServerIndex(allServersSize);
            //获取服务
            server = reachableServers.get(next);
            //如果服务为空直接跳过下面的
            if (server == null){
                continue;
            }
            //如果获取到的这个服务是活着的就返回
            if (server.isAlive()){
                return server;
            }
            //如果获取到的服务不是空，但是不是存活状态，需要重新获取
            server=null;
        }
        //最后这里可能会返回null
        return  server;
    }
    //获取服务下标，为了保证原子性，使用了CAS
    public int getServerIndex(int allServersSize){
        //自旋锁
        for (;;) {
            //获取当前值
            int current = this.atomicInteger.get();
            //设置期望值
            int next = (current + 1) % allServersSize;
            //调用Native方法compareAndSet，执行CAS操作
            if (this.atomicInteger.compareAndSet(current, next))
                //成功后才会返回期望值，否则无线循环
                return next;
        }
    }
    public Server choose(Object key) {
        return choose(getLoadBalancer(),key);
    }
}

@Configuration
//针对全局修改
//@RibbonClients(defaultConfiguration = MyRuleConfig.class)
//针对某个服务修改
@RibbonClient(name = "nacos-app-a", configuration = MyRuleConfig.class)
public class MyRuleConfig {
    @Bean
    public IRule rule() {
      //返回上面自定义的规则类
        return new RandomRule_ZY();

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "Client",configuration = MyRuleConfig.class)
public class GoyeerCloudRibbonAppliction {
    public static void main(String[] args){
        SpringApplication.run(GoyeerCloudRibbonAppliction.class);
    }
}

public interface LoadBalancerClient extends ServiceInstanceChooser 
{
  <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;
    <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException;
    URI reconstructURI(ServiceInstance instance, URI original);
}

public interface ServiceInstanceChooser 
{
  ServiceInstance choose(String serviceId);
}

@Override
public ServiceInstance choose(String serviceId) {
  return choose(serviceId, null);
}
/**
 * New: Select a server using a 'key'.
 * @param serviceId of the service to choose an instance for
 * @param hint to specify the service instance
 * @return the selected {@link ServiceInstance}
 */
public ServiceInstance choose(String serviceId, Object hint) {
  Server server = getServer(getLoadBalancer(serviceId), hint);
  if (server == null) {
   return null;
  }
  return new RibbonServer(serviceId, server, isSecure(server, serviceId),serverIntrospector(serviceId).getMetadata(server));
}

protected Server getServer(ILoadBalancer loadBalancer) {
   return getServer(loadBalancer, null);
}
protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
   if (loadBalancer == null) {
     return null;
   }
   // 最终通过 loadBalancer 去做服务实例的选择。
   // Use 'default' on a null hint, or just pass it on?
   return loadBalancer.chooseServer(hint != null ? hint : "default");
}

public interface IRule{ 
    public Server choose(Object key);
    public void setLoadBalancer(ILoadBalancer lb);
    public ILoadBalancer getLoadBalancer();    
}