92.【SpringCloud NetFilx】（六）

//  设置服务层的前缀为常量
    //private static final String REST_URL_PREFIX="http://localhost:8081";
    // 使用Ribbon负载均衡，我们这里不应该写死。而应该通过id名(服务提供者)，进行获取 SpringCloud-provider-dept
    private static final String REST_URL_PREFIX="http://SpringCloud-provider-dept";

package com.jsxs.controller;
import com.jsxs.pojo.Dept;
import org.springframework.stereotype.Controller;
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 javax.annotation.Resource;
import java.util.List;
@RestController
public class DeptConsumerController {
    //注意: 这里我们只是引入了实体类的数据，并没有引入service接口
    //思考: 消费者界面不应该存在Dao层也不应该存在Service层,该如何使用服务呢
    //RestTemplate  ... 我们直接调用就行，但需要注入到Spring中
    @Resource
    // (URI url, 实体 map,Class<T> responseType) 地址---- 实体 ----返回类型.class
    private RestTemplate restTemplate;   // 提供多种便捷访问远程   访问http服务的方法，简单的Rest
    //  设置服务层的前缀为常量
    //private static final String REST_URL_PREFIX="http://localhost:8081";
    // 使用Ribbon负载均衡，我们这里不应该写死。而应该通过id名(服务提供者)，进行获取 SpringCloud-provider-dept
    private static final String REST_URL_PREFIX="http://SpringCloud-provider-dept";
    //  根据id进行数据的查找
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long deptno){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/queryById/"+deptno,Dept.class);
    }
    //  添加数据
    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
    }
    //  查找全部数据
    @RequestMapping("/consumer/dept/all")
    public List<Dept> all(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/all",List.class);
    }
}

CREATE DATABASE db03;
USE db03;
CREATE TABLE dept(
  deptno BIGINT(20) Not Null PRIMARY KEY AUTO_INCREMENT,
  dname VARCHAR(60) DEFAULT NULL,
  db_source VARCHAR(60) DEFAULT NULL
);
INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('售后部',DATABASE());

@Bean
    public IRule myIRule(){
        return new RandomRule();
    }

package com.jsxs.config;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
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;
@Configuration  //  相当于application.xml文件
public class ConfigBean {
    // IRule :
    /**
     *      1.AvailabilityFilteringRule  先过滤掉奔溃(跳匝)的服务，对剩下的服务进行轮询
     *      2.RoundRobinRule  轮询   《默认》
     *      3  .RoundRobinRule 随机
     *      4. RetryRule 会先按照轮询获取服务~,如果服务获取失败,则会在指定的时间内运行。
     *
     */
    @LoadBalanced   //  配置负载均衡，只需要添加一个注解就可以
    @Bean       //  把RestTemplate注入到Spring中去
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
    // 启用随机作为Ribbon的算法
    @Bean
    public IRule myIRule(){
        return new RandomRule();
    }
}

自定义的算法会覆盖默认的算法均衡
FooConfiguration必须是@Configuration，但请注意，它不在主应用程序上下文的@ComponentScan
中，否则将由所有@RibbonClients共享。如果您使用@ComponentScan（或@SpringBootApplication）
，则需要采取措施避免包含（例如将其放在一个单独的，不重叠的包中，或者指定要在@ComponentScan）。

package com.myrule;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
public class JsxsRandomRule extends AbstractLoadBalancerRule {
    public JsxsRandomRule() {
    }
    @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            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) {
                    return null;
                }
                int index = this.chooseRandomInt(serverCount);   //生成随机数
                server = (Server)upList.get(index);  //从活着的服务中，随机获取一个
                if (server == null) {
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }
                    server = null;
                    Thread.yield();
                }
            }
            return server;
        }
    }
    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }
    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

package com.jsxs;
import com.myrule.JsxsRule;
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;
@SpringBootApplication
@EnableEurekaClient
// 在微服务启动的时候，就会加载我们自定义的均衡算法。
@RibbonClient(name = "SpringCloud-provider-dept",configuration = JsxsRule.class)  // 服务端的ID名 自定义配置的类
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

package com.myrule;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JsxsRule {
    // 启用随机作为Ribbon的算法
    @Bean
    public IRule myIRule(){
        return new JsxsRandomRule();
    }
}