# EurekaServer地址
eureka.client.service-url.defaultZone=http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
}

/**
 * @author bruceliu
 * @create 2019-05-02 15:52
 * @description
 */
@RestController
@RequestMapping("consumer")
public class ConsumerController {

    //改成下面这行
    private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-DEMO-SERVICE";

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient client;// Eureka客户端，可以获取到服务实例信息

    @RequestMapping("/test")
    public List<User> consumerTest(){
        List<String>list=client.getServices();
        System.out.println("*服务列表*"+list);
        List<ServiceInstance> srvList=client.getInstances("springcloud-demo-service");
        for(ServiceInstance element:srvList){
            System.out.println(element.getServiceId()+"\t"+element.getHost()+"\t"+element.getPort()+"\t" +element.getUri());
        }
        // 因为只有一个UserService,因此我们直接get(0)获取
        ServiceInstance instance = srvList.get(0);

        // 获取ip和端口信息
        String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/all";
        System.out.println("访问地址:"+baseUrl);

        return this.restTemplate.getForObject(REST_URL_PREFIX+"/all",List.class);
    }
}

package com.bruceliu.test;

import com.bruceliu.SpringcloudDemoConsumerApplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author bruceliu
 * @create 2019-05-04 11:33
 * @description 负载均衡算法测试
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringcloudDemoConsumerApplication.class)
public class LoadBalanceTest {

    @Autowired
    RibbonLoadBalancerClient client;

    @Test
    public void test1(){
        for (int i = 0; i <10 ; i++) {
            ServiceInstance instance = this.client.choose("SPRINGCLOUD-DEMO-SERVICE");
            System.out.println(instance.getHost() + ":" + instance.getPort());
        }
    }
}

SPRINGCLOUD-DEMO-SERVICE:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

spring:
  cloud:
    loadbalancer:
      retry:
        enabled: true # 开启Spring Cloud的重试功能
SPRINGCLOUD-DEMO-SERVICE:
  ribbon:
    ConnectTimeout: 250 # Ribbon的连接超时时间
    ReadTimeout: 1000 # Ribbon的数据读取超时时间
    OkToRetryOnAllOperations: true # 是否对所有操作都进行重试
    MaxAutoRetriesNextServer: 1 # 切换实例的重试次数
    MaxAutoRetries: 1 # 对当前实例的重试次数

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

/**
 * @author bruceliu
 * @create 2019-05-04 13:52
 * @description
 */

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

/**
 * 该配置类不可以放在与注解 @ComponentScan 的同包或者子包下，否则不起作用 （自定义算法也是一样）
 */
@Configuration
public class MySelfRule {

    /*
     * 切换 访问的算法 很简单只需要换成我们要返回算法的实例即可
     * 默认有七个算法，可以自定义自己的算法
     * */
    @Bean
    public IRule myRule()
    {
        //如果 突然间一个服务挂了 访问带挂的服务器会报错，出现错误页面
        //return new RoundRobinRule();
        //return new RandomRule(); //达到的目的，用我们重新选择的随机算法替代默认的轮询。
        //如果 突然间一个服务挂了 访问带挂的服务器会报错，出现错误页面，但是过一下子他不会再访问挂的机器，不会显示出错误的页面,这也是重试的另外一种配置方式！
        return new RetryRule();
    }
}

@SpringBootApplication
@EnableDiscoveryClient // 开启EurekaClient功能
@RibbonClient(name="SPRINGCLOUD-DEMO-SERVICE",configuration=MySelfRule.class)
public class SpringcloudDemoConsumerApplication {

  public static void main(String[] args) {
    SpringApplication.run(SpringcloudDemoConsumerApplication.class, args);
  }
}

/**
 * @author bruceliu
 * @create 2019-05-04 13:59
 * @description
 */
@Configuration
public class MySelfRule1 {

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

/**
 * @author bruceliu
 * @create 2019-05-04 14:01
 * @description
 */
/*
 * 参考随机数的源码来修改
 * https://github.com/Netflix/ribbon/blob/master/ribbon-loadbalancer/src/main/java/com/netflix/loadbalancer/RandomRule.java
 * */
public class MyRandomRule 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);

            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

    }
}