[spring-cloud-ribbon]

首先我们了解一下什么是ribbon，ribbon是干什么的？？

一、负载均衡框架，支持可插拔式的负载均衡规则 。

二、支持多种协议，HTTP、UDP。

三、提供负载均衡客户端。

四、ribbon负载均衡支持多种形式的负载。

下边我们尝试一下ribbon能带给我们那些好处。

撸代码入手

1.我们的项目应用于远程过程调用，所以搭建eureka-server环境。两个服务提供端，这两个服务只有端口不通，同时部署在eureka-server上，在实际生产环境中，服务也会集群部署，咱们就搞两个实例。分别启动注册中心和两个服务提供者。

2、访问注册中心 http://localhost:8899

3、圈住的就是我们刚那个启动的两个服务，两个实例端口分别是9998和9999，实例名称为YLT-TEST。

4、下面就是新建一个项目，作为服务的消费方了，引入相关依赖。

        <!--远程调用-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
            <version>${spring-cloud-starter-feign.version}</version>
        </dependency>

        <!--熔断器-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
            <version>${spring-cloud-starter-hystrix.version}</version>
        </dependency>
        <!--hystrix-dashboard 监控-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
            <version>${spring-cloud-starter-hystrix-dashboard.version}</version>
        </dependency>

        <!--客户端负载均衡  测试ribbon主要用到的依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>

5、这里边还加上了熔断器，可以忽略掉。上一篇博客已经信息写过怎么使用了。

再加上配置类，指明使用哪一种负载模式

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * ribbon负载均衡配置
 * 如果使用默认配置。ribbon使用的是轮询策略。
 */
@Configuration
public class RibbonLBConfig {
    /**
     * 根据响应时间分配一个weight，响应时间越长，weight越小，被选中的可能性越低。
     * 一个后台线程定期的从status里面读取评价响应时间，为每个server计算一个weight。Weight的计算也比较简单responsetime 减去每个server自己平均的responsetime是server的权重。当刚开始运行，没有形成status时，使用roubine策略选择server
     *
     * @return
     */
//    @Bean
//    public IRule ribbonRule() {
//        return new WeightedResponseTimeRule();
//    }
    /**
     * 复合判断server所在区域的性能和server的可用性选择server
     * 使用ZoneAvoidancePredicate和AvailabilityPredicate来判断是否选择某个server，
     * 前一个判断判定一个zone的运行性能是否可用，剔除不可用的zone（的所有server），AvailabilityPredicate用于过滤掉连接数过多的Server。
     *
     * @return
     */
//    @Bean
//    public IRule ribbonRule() {
//        return new ZoneAvoidanceRule();
//    }
    /**
     * roundRobin方式轮询选择server
     * 轮询index，选择index对应位置的server
     * @return
     */
//    @Bean
//    public IRule ribbonRule() {
//        return new RoundRobinRule();
//    }
    /**
     * 对选定的负载均衡策略机上重试机制。
     * 在一个配置时间段内当选择server不成功，则一直尝试使用subRule的方式选择一个可用的server
     *
     * @return
     */
//    @Bean
//    public IRule ribbonRule() {
//        return new RetryRule();
//    }
    /**
     * 随机选择一个server
     * 在index上随机，选择index对应位置的server
     */
    @Bean
    public IRule ribbonRule() {
        return new RandomRule();
    }
    /**
     *  过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的的后端server（active connections 超过配置的阈值）
     *  使用一个AvailabilityPredicate来包含过滤server的逻辑，其实就就是检查status里记录的各个server的运行状态
     * @return
     */
//    @Bean
//    public IRule ribbonRule() {
//        return new AvailabilityFilteringRule();
//    }
    /**
     * 选择一个最小的并发请求的server
     * 逐个考察Server，如果Server被tripped了，则忽略，在选择其中ActiveRequestsCount最小的server
     *
     * @return
     */
//    @Bean
//    public IRule ribbonRule() {
//        return new BestAvailableRule();
//    }

}

在贴一下我们的yml配置吧

server:
  port: 9000
eureka:
  client:
    #实例是否在eureka服务器上注册自己的信息以提供其他服务发现,默认为true
    register-with-eureka: false
    service-url:
      defaultZone: http://localhost:8899/eureka  # 指定注册中心的url

feign:
  client:
    config:
      feignName:
        connectTimeout: 5000
        readTimeout: 5000
  hystrix:
    enabled: true

hystrix:
  command:
    default:
      execution:
        timeout:
          #如果enabled设置为false，则请求超时交给ribbon控制,为true,则超时作为熔断根据
          enabled: true
        isolation:
          thread:
            timeoutInMilliseconds: 1000 #线程超时,调用Fallback方法,断路器超时时间，默认1000ms
spring:
  application:
    name: local-client

注册一个bean ,开启负载均衡

    /**
     * 添加LoadBalanced，使RestTemplate已负载均衡的方式调用服务
     * @return
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

6、访问我们的消费项目。访问http://127.0.0.1:9000/hello

可以看到我们的客户端轮询去调用了，同一实例的不同服务。

打完收工。