SpringCloud03：Ribbon与Feign

一、Ribbon负载均衡（基于客户端）

1、什么是Ribbon

• 简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将NetFlix的中间层服务连接在一起。Ribbon的客户端组件提供一系列完整的配置项如：连接超时、重试等等。简单的说，就是在配置文件中列出LoadBalancer（简称LB：负载均衡）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。

2、Ribbon能干什么

• 即负载均衡：简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）。
• Dubbo、SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义负载均衡简单分类：
• 集中式LB：
  • 即在服务的消费方和提供方之间使用独立的LB设施如之前学习的Nginx，由该设施负责把访问请求通过某种策略转发至服务的提供方！
• 进程式LB：
  • 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
    Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址！

3、Ribbon实现负载均衡

• pox.xml文件

 <!--集成Ribbon-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

• application.yml文件

server:
  port: 80
# erueka配置
eureka:
  client:
    register-with-eureka: false  #不向eureka注册自己
    service-url:
      defaultZone: http://eureka7003.com:7003/eureka/,
      http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

• 配置实现负载均衡

@Configuration  //相当于spring中的applicationContext.xml
public class DeptConfig {
    //配置负载均衡实现RestTemplate
    @Bean    //原来是<bean></bean>,注入到Spring
    @LoadBalanced  //配置负载均衡实现RestTemplate
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

• 主启动类

@SpringBootApplication
@EnableEurekaClient
//在微服务启动的时候就能去加载我们自定义的Ribbon类
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRule.class)
public class DeptConsumerStarter {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumerStarter.class,args);
    }
}

4、Ribbon核心组件之IRule

IRule：根据特定算法从服务列表中选取一个要访问的服务。

• RoundRobinRule【轮询】
• RandomRule【随机】
• AvailabilityFilterRule【会先过滤掉由于多次访问故障而处于断路器跳闸的服务，还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问】
• WeightedResponseTimeRule【根据平均响应时间计算所有服务的权重，响应时间越快服务权重越大，被选中的概率越高，刚启动时如果统计信息不足，则使用RoundRobinRule策略，等待统计信息足够，会切换到WeightedResponseTimeRule】
• RetryRule【先按照RoundRobinRule的策略获取服务，如果获取服务失败，则在指定时间内会进行重试，获取可用的服务】
• BestAvailableRule【会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务】
• ZoneAvoidanceRule【默认规则，复合判断server所在区域的性能和server的可用性选择服务器】
• 自定义负载均衡

   /**
     * 每个服务访问5次则换下一个服务(总共3个服务)
     * total=0,默认=0,如果=5,指向下一个服务节点
     * index=0,默认=0,如果total=5,index+1
     */
    private int total = 0;//被调用的次数
    private int currentIndex = 0;//当前在提供服务的节点
    //@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
    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 = chooseRandomInt(serverCount);//生成区间随机数
            //server = upList.get(index);//从活着的服务中,随机获取一个
            //=====================自定义代码=========================
            if (total < 5) {
                server = upList.get(currentIndex);
                total++;
            } else {
                total = 0;
                currentIndex++;
                if (currentIndex > upList.size()) {
                    currentIndex = 0;
                }
                server = upList.get(currentIndex);//从活着的服务中,获取指定的服务来进行操作
            }
            //======================================================
            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;
    }
    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }
    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }
    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub
    }
}

二、Feign负载均衡

1、什么是feign

• feign是声明式的web service客户端，它让微服务之间的调用变得更简单了，类似controller调用service。
• Spring Cloud集成了Ribbon和Eureka，可在使用Feign时提供负载均衡的http客户端。

2、feign能干什么

• Feign旨在使编写Java Http客户端变得更容易。
• 前面在使用Ribbon + RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步封装，由他 来帮助我们定义和实现依赖服务接口的定义，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它（类似于以前Dao接口上标注Mapper注解，现在是一个微服务接口上面标注一个Feign注解即可。）即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon时，自动封装服务调用客户端的开发量。

3、集成feign

• pox.xml文件

<!--Feign相关-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

• 编写接口 DeptClientService，并增加新的注解@FeignClient。

@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {

     @GetMapping("dept/query/{id}")
     Dept queryById(@PathVariable("id") Long id);

     @GetMapping("dept/query/all")
     List<Dept> queryAll();

     @PostMapping("dept/add")
     int addDept(Dept dept);

}

• 调用前Ribbon调用

@RestController
public class DeptConsumerController {

    @Autowired
    //提供多种便捷访问远程http服务的方法，简单的Restful风格
    private RestTemplate restTemplate;

//    public static final String REST_URL_PREFIX="http://localhost:8001/";

    //ribbon负载均衡下使用服务名调用
    private static final String REST_URL_PREFIX="http://SPRINGCLOUD-PROVIDER-DEPT/";

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

    @RequestMapping("consumer/dept/query/all")
    public List<Dept> queryAll(){
        return restTemplate.getForObject(REST_URL_PREFIX+"dept/query/all",List.class);
    }

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

}

• Feign方式调用

@RestController
public class DeptConsumerController {

    @Resource
    private DeptClientService deptClientService=null;

    @RequestMapping("consumer/dept/query/{id}")
    public Dept query(@PathVariable("id")Long id){
        return this.deptClientService.queryById(id);
    }

    @RequestMapping("consumer/dept/query/all")
    public List<Dept> queryAll(){
        return this.deptClientService.queryAll();
    }

    @RequestMapping("consumer/dept/add")
    public int add(Dept dept){
        return this.deptClientService.addDept(dept);
    }

}

• 启动类

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.lc"})
@ComponentScan(basePackages = {"com.lc"})
public class DeptConsumerFeignStarter {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumerFeignStarter.class,args);
    }
}

三、Ribbon与Feign的比较

1、ribbon：

• Ribbon 是一个基于 HTTP 和 TCP 客户端的负载均衡器它可以在客户端配置 ribbonServerList（服务端列表），然后轮询请求以实现均衡负载它在联合 Eureka 使用时ribbonServerList 会被 DiscoveryEnabledNIWSServerList 重写，扩展成从 Eureka 注册中心获取服务端列表同时它也会用 NIWSDiscoveryPing 来取代 IPing，它将职责委托给 Eureka 来确定服务端是否已经启动。 使用 HttpClient 或 RestTemplate 模拟http请求，步骤相当繁琐。
• RestTemplate注入到容器中，@LoadBalanced注解使用默认负载均衡算法（可以使用自定义）。
  2.用 REST_URL_PREFIX 指定请求地址 ， 使用 restTemplate 模拟 http 请求。

2、feign

• 是在 Ribbon的基础上进行了一次改进，是一个使用起来更加方便的 HTTP 客户端。采用接口的方式， 只需要创建一个接口，面向接口；然后在上面添加注解即可 ，将需要调用的其他服务的方法定义成抽象方法即可， 不需要自己构建http请求。然后就像是调用自身工程的方法调用，而感觉不到是调用远程方法，使得编写 客户端变得非常容易。类似于 mybatis 的 @Mapper注解 。