<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    <version>2.2.10.RELEASE</version>
</dependency>

package com.bjpowernode;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
public class ConsumerApplication {
    public static void main(String[] args) {
    SpringApplication.run(ConsumerApplication.class, args);
    }
/**
* 用来发请求的
*
* @return
*/
@Bean
public RestTemplate restTemplate() {
    return new RestTemplate();
    }
}

@RestController
public class TestController {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DiscoveryClient discoveryClient;
    static Random random = new Random();

    @RequestMapping("/testBalance")
    public String testBalance(String serviceId) {
        //获取服务列表
        List<ServiceInstance> instances = discoveryClient.getInstances(serviceId);
        if (ObjectUtils.isEmpty(instances)) {
            return "服务列表为空";
        }

        //如果服务列表不为空，先自己做一个负载均衡
        ServiceInstance serviceInstance = loadBalance(instances);
        String host = serviceInstance.getHost();
        int port = serviceInstance.getPort();
        String url = "http://" + host + ":" + port + "/info";
        System.out.println("本次我调用的是" + url);
        String forObject = restTemplate.getForObject(url, String.class);
        System.out.println(forObject);
        return forObject;
    }

    private ServiceInstance loadBalance(List<ServiceInstance> instances) {
        //拼接 url 去调用 ip:port 先自己实现不用 ribbon
        ServiceInstance serviceInstance =
        instances.get(random.nextInt(instances.size()));
        return serviceInstance;
    }
}              

package com.tongda.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
public class ConsumerController {

    @Autowired
    RestTemplate restTemplate;

    /*
     * 思考 ribbon是怎么将http://provider/hello 路径请求成功的
     * http://127.0.0.1:8080/hello
     * 1.拦截这个请求
     * 2.截取主机名称
     * 3.借助eureka来做服务发现list<>
     * 4.通过负载均衡算法，拿到一个服务器ip port
     * 5.reConstructURL 重构路径
     * 6.发起请求
     *
     * @param serviceName
     * @return {@link java.lang.String}
     * @throws
     **/
    @GetMapping("testRibbon")
    public String Ribbon(String serviceName) { // 参数调用，调谁传谁
        // 正常来讲 需要拿到ip和port以及 路径 才可以用
        // http://provider/hello
        String result = restTemplate.getForObject("http://" + serviceName + "/hell", String.class);
        // 只要你给restTemplate加了ribbon的注解，项目中这个对象发起的请求，都会走ribbon的代理
        // 如果你想使用原生的restTemplate 就需要重新创建一个对象
        RestTemplate rtp = new RestTemplate();
        rtp.getForObject("http://localhost:8888/aaa",String.class);
        return result;
    }

    /*轮训的算法 怎么去实现
    * 两台机器 A B
    * A
    * B
    * A
    * B
    * 代码实现轮训的算吗 List<机器>
    * 请求次数
    * int index = 1 % size
    * % 取模 取余好处是一个周期函数 让得到的结果 总是小于 除数的
    * 1 / 2  1 % 2
    * 1%2=1
    * 2%2=0
    * 3%2=1
    * 4%2=0
    * 全局顶一个int i = 0
    * i++ 线程不安全
    * i % size
    * 怎么能做一个线程安全的轮训算法 枷锁 效率极低 CAS 自旋锁 没有线程的等待和唤醒的开锁
    * CAS 优点 性能好 java层面无锁的状态 但是在jvm层面 有锁的是基于CPU对于寄存器的修改指令cmpxch
    * CAS 缺点 会导致短暂时间内CPU 飙升 还有ABA 问题
    *
    * */


    @Autowired
    private LoadBalancerClient loadBalancerClient; // 负载均衡组件

    /*
     * 核心是负载均衡
     * @param serviceName
     * @return {@link java.lang.String}
     * @throws
     */
    @GetMapping("testRibbonRule")
    public String restRibbonRule(String serviceName) {
        ServiceInstance choose = loadBalancerClient.choose(serviceName);
        return choose.toString();
    }
}

**
* 用来发请求的
*
* @return
*/
@Bean
@LoadBalanced //ribbon 的负载均衡注解
    public RestTemplate restTemplate() {
        return new RestTemplate();
}    

/**
* 测试 ribbon 的负载均衡
*
* @param serviceId
* @return
*/
@RequestMapping("/testRibbonBalance")
public String testRibbonBalance(String serviceId) {
    //直接用服务名称替换 ip:port
    String url = "http://" + serviceId + "/info";
    String forObject = restTemplate.getForObject(url,String.class);
    System.out.println(forObject);
    return forObject;
}

@Autowired
private LoadBalancerClient loadBalancerClient;
@RequestMapping("/testChoose")
public String testChoose(String serviceId) {
    ServiceInstance choose = loadBalancerClient.choose(serviceId);
    System.out.println(choose.getHost() + ":" + choose.getPort());
    return choose.toString();
}