import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RetryRule;

@Configuration
public class ConfigBean //boot -->spring   applicationContext.xml --- @Configuration配置   ConfigBean = applicationContext.xml
{ 
  @Bean
  @LoadBalanced//Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端       负载均衡的工具。
  public RestTemplate getRestTemplate()
  {
    return new RestTemplate();
  }
  
  @Bean
  public IRule myRule()
  {
    //return new RoundRobinRule();
    //return new RandomRule();//达到的目的，用我们重新选择的随机算法替代默认的轮询。
    return new RetryRule();
  }
}

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.atguigu.springcloud.entities.Dept;

@RestController
public class DeptController_Consumer
{

 
  private static final String REST_URL_PREFIX = "http://MICROSERVICECLOUD-DEPT";

  /**
   * 使用 使用restTemplate访问restful接口非常的简单粗暴无脑。 (url, requestMap,
   * ResponseBean.class)这三个参数分别代表 REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。
   */
  @Autowired
  private RestTemplate restTemplate;

  @RequestMapping(value = "/consumer/dept/add")
  public boolean add(Dept dept)
  {
    return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
  }

  @RequestMapping(value = "/consumer/dept/get/{id}")
  public Dept get(@PathVariable("id") Long id)
  {
    return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
  }

  @SuppressWarnings("unchecked")
  @RequestMapping(value = "/consumer/dept/list")
  public List<Dept> list()
  {
    return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
  }

  // 测试@EnableDiscoveryClient,消费端可以调用服务发现
  @RequestMapping(value = "/consumer/dept/discovery")
  public Object discovery()
  {
    return restTemplate.getForObject(REST_URL_PREFIX + "/dept/discovery", Object.class);
  }

}

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;

import com.atguigu.myrule.MySelfRule;

@SpringBootApplication
@EnableEurekaClient
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
//@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
public class DeptConsumer80_App
{
  public static void main(String[] args)
  {
    SpringApplication.run(DeptConsumer80_App.class, args);
  }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RoundRobinRule;

@Configuration
public class MySelfRule
{
  @Bean
  public IRule myRule()
  {
    //return new RandomRule();// Ribbon默认是轮询，我自定义为随机
    //return new RoundRobinRule();// Ribbon默认是轮询，我自定义为随机
    
    return new RandomRule_ZY();// 我自定义为每台机器5次
  }
}

import java.util.List;

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

public class RandomRule_ZY extends AbstractLoadBalancerRule
{

  // total = 0 // 当total==5以后，我们指针才能往下走，
  // index = 0 // 当前对外提供服务的服务器地址，
  // total需要重新置为零，但是已经达到过一个5次，我们的index = 1
  // 分析：我们5次，但是微服务只有8001 8002 8003 三台，OK？
  // 
  
  
  private int total = 0;      // 总共被调用的次数，目前要求每台被调用5次
  private int currentIndex = 0; // 当前提供服务的机器号

  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) {
        /*
         * No servers. End regardless of pass, because subsequent passes only get more
         * restrictive.
         */
        return null;
      }

//      int index = rand.nextInt(serverCount);// java.util.Random().nextInt(3);
//      server = upList.get(index);

      
//      private int total = 0;      // 总共被调用的次数，目前要求每台被调用5次
//      private int currentIndex = 0; // 当前提供服务的机器号
            if(total < 5)
            {
              server = upList.get(currentIndex);
              total++;
            }else {
              total = 0;
              currentIndex++;
              if(currentIndex >= upList.size())
              {
                currentIndex = 0;
              }
            }     
      
      
      if (server == null) {
        /*
         * The only time this should happen is if the server list were somehow trimmed.
         * This is a transient condition. Retry after yielding.
         */
        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;

  }

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

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

  }

}

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    service-url: 
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/