Ribbon入门学习

Ribbon是一个为客户端提供负载均衡功能的服务，它内部提供了一个叫做ILoadBalance的接口代表负载均衡器的操作，比如有添加服务器操作、选择服务器操作、获取所有的服务器列表、获取可用的服务器列表等等。

需要解决的问题：

① 如何在配置Eureka Client注册中心时不去硬编码Eureka Server的地址？
② 在微服务不同模块间进行通信时，如何不去硬编码服务提供者的地址？
③ 当部署多个相同微服务时，如何实现请求时的负载均衡？
Ribbon是什么？
Ribbon是Netflix发布的云中间层服务开源项目，其主要功能是提供客户端实现负载均衡算法（当然也有服务器端的）。

负载均衡器的内部基本实现原理

先熟悉一下负载均衡器LoadBalancer的实现原理图：

 

 

Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，Ribbon是一个客户端负载均衡器，我们可以在配置文件中Load Balancer后面的所有机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器，我们也很容易使用Ribbon实现自定义的负载均衡算法。

下图展示了Eureka使用Ribbon时的大致架构：

SpringCloud之Ribbon入门案例

① 首先引入Ribbon依赖，Ribbon的使用依赖Eureka：

   <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-eureka</artifactId>
   </dependency>
   <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-ribbon</artifactId>
   </dependency>

② 如何使用Ribbon

使用RestTemplate进行Eureka Client(包括服务提供者以及服务消费者，在这里其实是服务消费者使用RestTemplate)之间的通信，为RestTemplate配置类添加@LoadBalanced注解即可，如下所示：

@Bean
@LoadBalanced
  public RestTemplate restTemplate() {
  return new RestTemplate();
}

主程序：

@SpringBootApplication
@EnableEurekaClient
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
@RibbonClient(name="MICROSERVICECLOUD-DEPT")
public class DeptConsumer80_App{
    public static void main(String[] args){
        SpringApplication.run(DeptConsumer80_App.class, args);
    }
}

③ 如何解决硬编码

使用添加@LoadBalanced注解后的RestTemplate调用服务提供者的接口时，可以使用虚拟IP替代真实IP地址。所谓的虚拟IP就是服务提供者在application.properties或yml文件中配置的spring.application.name属性的值。示例如下：

以前：

@RestController
public class DeptController_Consumer
{
    private static final String REST_URL_PREFIX = "http://localhost:8001"; //需要ip+端口
 
    @Autowired
    private RestTemplate restTemplate;
 
    @RequestMapping(value = "/consumer/dept/add")
    public boolean add(Dept dept)
    {
        return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
    }
}

使用Ribbon后：

@RestController
public class DeptController_Consumer
{
    private static final String REST_URL_PREFIX = "http://MICROSERVICECLOUD-DEPT"; //微服务的虚拟id
 
    @Autowired
    private RestTemplate restTemplate;
 
    @RequestMapping(value = "/consumer/dept/add")
    public boolean add(Dept dept)
    {
        return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
    }
}

小总结：Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心ip地址和端口号

微服务（服务提供者）集群搭建：

机器1
server:
  port: 8001
 
spring:
   application:
    name: microservicecloud-dept 
   datasource:
    type: com.alibaba.druid.pool.DruidDataSource          
    driver-class-name: org.gjt.mm.mysql.Driver            
    url: jdbc:mysql://localhost:3306/cloudDB01            
    username: root
    password: 123456
 
机器2
server:
  port: 8002
 
spring:
   application:
    name: microservicecloud-dept 
   datasource:
    type: com.alibaba.druid.pool.DruidDataSource   
    driver-class-name: org.gjt.mm.mysql.Driver          
    url: jdbc:mysql://localhost:3306/cloudDB02        
    username: root
    password: 123456
 
机器3
server:
  port: 8003
 
spring:
   application:
    name: microservicecloud-dept 
   datasource:
    type: com.alibaba.druid.pool.DruidDataSource         
    driver-class-name: org.gjt.mm.mysql.Driver            
    url: jdbc:mysql://localhost:3306/cloudDB03              
    username: root
    password: 123456

其中{Spring.application.name}都是一样的，不可以变。

Ribbon组件IRule

默认的是RoundBobinRule（轮询）

RetryRule

• 1、先按照RoundRobinRule(轮询)的策略获取服务，如果获取的服务失败侧在指定的时间会进行重试，进行获取可用的服务
• 2、如多次获取某个服务失败，这不会再再次获取该服务如(高德地图上某条道路堵车，司机不会走那条道路)

使用：

@Configuration
public class ConfigBean //boot -->spring   applicationContext.xml --- @Configuration配置   ConfigBean = applicationContext.xml
{ 
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
    
    @Bean
    public IRule myRule(){
        //return new RoundRobinRule();
        //return new RandomRule();//达到的目的，用我们重新选择的随机算法替代默认的轮询。
        return new RetryRule();  //在这里选择负载均衡算法
    }
}

自定义负载均衡算法：
所谓的自定义Ribbon Client的主要作用就是使用自定义配置替代Ribbon默认的负载均衡策略，注意：自定义的Ribbon Client是有针对性的，一般一个自定义的Ribbon Client是对一个服务提供者(包括服务名相同的一系列副本)而言的。自定义了一个Ribbon Client 它所设定的负载均衡策略只对某一特定服务名的服务提供者有效，但不能影响服务消费者与别的服务提供者通信所使用的策略。根据官方文档的意思，推荐在 springboot 主程序扫描的包范围之外进行自定义配置类。其实纯代码自定义RibbonClient的话有两种方式：

方式一：在springboot主程序扫描的包外定义配置类，然后为springboot主程序添加 @RibbonClient 注解引入配置类。

配置类不应该在SpringBoot的包路径下，通过@RibbonClient 注解加载：

@Configuration
public class MySelfRule
{
    @Bean
    public IRule myRule()
    {    
        return new RandomRule_ZY();  // 我自定义为每台机器5次，5次之后在轮询到下一个
    }
}

springboot主程序：

@SpringBootApplication
@EnableEurekaClient
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
public class DeptConsumer80_App
{
    public static void main(String[] args)
    {
        SpringApplication.run(DeptConsumer80_App.class, args);
    }
}

自定义LoadBalance：

public class RandomRule_ZY extends AbstractLoadBalancerRule{
 
    // total = 0 // 当total==5以后，我们指针才能往下走，
    // index = 0 // 当前对外提供服务的服务器地址，
    // total需要重新置为零，但是已经达到过一个5次，我们的index = 1
    // 分析：我们5次，但是微服务只有8001 8002 8003 三台
    
    private int total = 0;         // 总共被调用的次数，目前要求每台被调用5次
    private int currentIndex = 0;        // 当前提供服务的机器号
 
    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) {
                return null;
            }
        
                        if(total < 5){
                        server = upList.get(currentIndex);
                        total++;
                        }else {
                        total = 0;
                        currentIndex++;
                        if(currentIndex >= upList.size()){
                          currentIndex = 0;
                        }
                        }                            
            if (server == null) {
                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;
    }
    @Override
    public Server choose(Object key){
        return choose(getLoadBalancer(), key);
    }
 
    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig){
    }
}

最后记录下Ribbon的配置Spring Cloud Ribbon配置详解

常用配置

1. 禁用 Eureka

当我们在 RestTemplate 上添加 @LoadBalanced 注解后，就可以用服务名称来调用接口了，当有多个服务的时候，还能做负载均衡。

这是因为 Eureka 中的服务信息已经被拉取到了客户端本地，如果我们不想和 Eureka 集成，可以通过下面的配置方法将其禁用。

# 禁用 Eureka
ribbon.eureka.enabled=false

2. 配置接口地址列表

上面我们讲了可以禁用 Eureka，禁用之后就需要手动配置调用的服务地址了，配置如下：

# 禁用 Eureka 后手动配置服务地址
ribbon-config-demo.ribbon.listOfServers=localhost:8081,localhost:8083

这个配置是针对具体服务的，前缀就是服务名称，配置完之后就可以和之前一样使用服务名称来调用接口了。

3. 配置负载均衡策略

Ribbon 默认的策略是轮询，从我们前面讲解的例子输出的结果就可以看出来，Ribbon 中提供了很多的策略，这个在后面会进行讲解。我们通过配置可以指定服务使用哪种策略来进行负载操作。

4. 超时时间

Ribbon 中有两种和时间相关的设置，分别是请求连接的超时时间和请求处理的超时时间，设置规则如下：

# 请求连接的超时时间
ribbon.ConnectTimeout=2000
# 请求处理的超时时间
ribbon.ReadTimeout=5000

也可以为每个Ribbon客户端设置不同的超时时间, 通过服务名称进行指定：
ribbon-config-demo.ribbon.ConnectTimeout=2000
ribbon-config-demo.ribbon.ReadTimeout=5000

5. 并发参数

# 最大连接数
ribbon.MaxTotalConnections=500
# 每个host最大连接数
ribbon.MaxConnectionsPerHost=500

代码配置 Ribbon

配置 Ribbon 最简单的方式就是通过配置文件实现。当然我们也可以通过代码的方式来配置。

通过代码方式来配置之前自定义的负载策略，首先需要创建一个配置类，初始化自定义的策略，代码如下所示。

@Configuration
public class BeanConfiguration {
    @Bean
    public MyRule rule() {
        return new MyRule();
    }
}

创建一个 Ribbon 客户端的配置类，关联 BeanConfiguration，用 name 来指定调用的服务名称，代码如下所示。

@RibbonClient(name = "ribbon-config-demo", configuration = BeanConfiguration.class)
public class RibbonClientConfig {
}

可以去掉之前配置文件中的策略配置，然后重启服务，访问接口即可看到和之前一样的效果。

配置文件方式配置 Ribbon

除了使用代码进行 Ribbon 的配置，我们还可以通过配置文件的方式来为 Ribbon 指定对应的配置：

<clientName>.ribbon.NFLoadBalancerClassName: Should implement ILoadBalancer(负载均衡器操作接口)
<clientName>.ribbon.NFLoadBalancerRuleClassName: Should implement IRule(负载均衡算法)
<clientName>.ribbon.NFLoadBalancerPingClassName: Should implement IPing(服务可用性检查)
<clientName>.ribbon.NIWSServerListClassName: Should implement ServerList(服务列表获取)
<clientName>.ribbon.NIWSServerListFilterClassName: Should implement ServerList­Filter(服务列表的过滤)

重试机制

在集群环境中，用多个节点来提供服务，难免会有某个节点出现故障。用 Nginx 做负载均衡的时候，如果你的应用是无状态的、可以滚动发布的，也就是需要一台台去重启应用，这样对用户的影响其实是比较小的，因为 Nginx 在转发请求失败后会重新将该请求转发到别的实例上去。

由于 Eureka 是基于 AP 原则构建的，牺牲了数据的一致性，每个 Eureka 服务都会保存注册的服务信息，当注册的客户端与 Eureka 的心跳无法保持时，有可能是网络原因，也有可能是服务挂掉了。

在这种情况下，Eureka 中还会在一段时间内保存注册信息。这个时候客户端就有可能拿到已经挂掉了的服务信息，故 Ribbon 就有可能拿到已经失效了的服务信息，这样就会导致发生失败的请求。

这种问题我们可以利用重试机制来避免。重试机制就是当 Ribbon 发现请求的服务不可到达时，重新请求另外的服务。

1. RetryRule 重试

解决上述问题，最简单的方法就是利用 Ribbon 自带的重试策略进行重试，此时只需要指定某个服务的负载策略为重试策略即可：

ribbon-config-demo.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RetryRule

2. Spring Retry 重试

除了使用 Ribbon 自带的重试策略，我们还可以通过集成 Spring Retry 来进行重试操作。

在 pom.xml 中添加 Spring Retry 的依赖，代码如下所示。

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

配置重试次数等信息：

# 对当前实例的重试次数
ribbon.maxAutoRetries=1
# 切换实例的重试次数
ribbon.maxAutoRetriesNextServer=3
# 对所有操作请求都进行重试
ribbon.okToRetryOnAllOperations=true
# 对Http响应码进行重试
ribbon.retryableStatusCodes=500,404,502

ref:Spring Cloud Ribbon设计原理 - 简书 (jianshu.com)