springcloud 负载均衡之 ribbon。

package com.aaa.zxf.config;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.cloud.client.loadbalancer.LoadBalanced;import org.springframework.context.annotation.Bean;import org.springframework.web.client.RestTemplate;@SpringBootApplicationpublic class ConfigRest {    @Bean    @LoadBalanced       //开启负载均衡  轮循的模式    public RestTemplate getRestTemplate(){        return  new RestTemplate();    }}

package com.aaa.zxf.controller;import com.aaa.zxf.model.User;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import org.springframework.web.client.RestTemplate;import java.util.List;@RestControllerpublic class UserController {   //   private static final String URL = "http://USER-PROVIDER";    private static final String URL ="http://USER-PROVIDER";    @Autowired    private RestTemplate restTemplate;    @RequestMapping("/userAll")    public List<User> selectAllUser(){        return  restTemplate.getForObject(URL+"/userAll",List.class);    }}

1.4 真正的负载均衡            需要创建provider-8082和8083项目1.5 进行配置            8081,8082,8083三个项目中的所有的controller都必须要一致(@RequestMapping("/userAll"))
            8081,8082,8083项目的application.properties配置文件必须要更改
                 【eureka的实例id:因为eureka的实例id是不能重复的，所以必须更改】                    eureka.instance.instance-id=user-provider-8082

                spring.application.name不能改变，也就是说8081,8082,8083三个项目的application.name都必须要一样1.6 启动顺序            首先启动三台eureka(7081,7082,7083)            再启动三台provider(8081,8082,8083)            最后启动consumer(6082)

1.7 ribbon的负载均衡算法            如果不指定ribbon的算法，则ribbon使用的是轮询！！！            如何指定ribbon的算法？1.8 负载均衡源码解析            IRule:接口            ILoadBalancer:接口            AbstractLoadBalancer(抽象类) --> 实现了ILoadBalancer接口            AbstractLoadBalancerRule(抽象类) --> 实现了IRule接口                有一个属性:ILoadBalance-->getter/setter方法            RandomRule(最终所实现随机算法的地方)--->继承了AbstractLoadBalancerRule                -->实现了IRule接口            RoundRobbinRule--->继承了AbstractLoadBalancerRule                -->实现了IRule接口            IRule:                public Server choose(Object key):选择出一个服务-->提供给consumer使用                public void setLoadBalancer(ILoadBalancer lb):ILoadBalancer-->实现类(AbstractLoadBalancer)                public ILoadBalancer getLoadBalancer()            ILoadBalancer:                ！！其实就是和每一个服务打交道！！                getServer(Object key):所有的获取服务都必须要通过key来进行获取            虽然已经实现了ribbon算法自定义配置，但是ribbon框架是不知道的，但是自己已经实现了负载均衡算法，需要告诉ribbon，只需要在主启动类上添加注解@RibbonClient(name,configuration)                name:通过eureka的Application的值来映射到真正的provider(8081,8082,8083)                name = "USER-PROVIDER"                configuration:指向的是自己自定义的算法配置类                @Configuration                public class RibbonRuleMine {                    @Bean                    public IRule randoms() {                        return new RandomRule();                    }                }

package com.aaa.lee.springcloud.config;import com.netflix.loadbalancer.ILoadBalancer;import java.util.concurrent.ThreadLocalRandom;public class Test {    // 随机算法    public Server choose(ILoadBalancer lb, Object key) {        // 如果负载均衡器为null的时候，直接返回(其实就是标识了该consumer开启了负载均衡@LoadBalance)        if (lb == null) {            return null;        }        // 创建Server对象，没有初始化        Server server = null;        // 循环进入条件是server为null-->也就是说第一次一定会进入循环        while (server == null) {            // Thread.interrupted():标识线程所处于的状态，如果线程的状态为存在,返回值就是true，如果不存在返回值就是false            // 什么时候线程会断开？？-->网络故障，网络延迟，各种阻塞            if (Thread.interrupted()) {                return null;            }            // getReachableServers():获取当前正在存活的服务(一共有20个服务，其中有4个宕机，存活的服务就是16个)            // getAllServers():获取所有的服务个数(包含宕机的)            List<Server> upList = lb.getReachableServers();            List<Server> allList = lb.getAllServers();            // allList.size() == 0 说明没有服务，直接return null            int serverCount = allList.size();            if (serverCount == 0) {                return null;            }            // serverCount:就是所有服务的个数(包含宕机的服务)            // 假设:30台            int index = chooseRandomInt(serverCount);            // upList:存活的服务            server = upList.get(index);            if (server == null) {                            /**                 * Thread.yield():线程谦让                 *      什么叫多线程之间的谦让呢？                 *          当并发出现的时候，线程和线程是互不相让的(线程阻塞)，其中一个线程就会出现问题,就会处于等待状态(线程阻塞会更严重)                 *          当调用yield()方法的时候，出现问题的线程就开始谦让,这个线程会再次被唤醒处于就绪状态，需要重新抢夺客户端所发送过来的并发                 */                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;    }    protected int chooseRandomInt(int serverCount) {        // Math.random.nextInt(999):随机获取到从1到999的随机数        // ThreadLocalRandom.current().nextInt(30):就是获取的是随机数(从1到30进行随机数)        //         /*         * Random和ThreadLocalRandom都是随机数，那么为什么使用ThreadLocalRandom不使用Random？         *  !!Random就是线程安全的!!         *  ThreadLocalRandom:是jdk7的新特性！！         *  虽然random是线程安全的，但是在多线程的情况，Random效率就会非常低         *      random在处理多线程的情况下是线程安全的，会受到线程保护，就会降低效率(队列)         *  Random所随机出来的数字是可以预测的(Random有规律)         *         *  TreadLocalRandom官方给出的解释，当项目期望在多线程中运行的时候，如果使用到了随机数，可以直接使用该类，因为该         *  类就是针对于并发所开发的，和Random相比TreadLocalRandom可以减少线程之间的竞争，性能可以达到最优！         *         *         */        return ThreadLocalRandom.current().nextInt(serverCount);    }}