alt

Ribbon 是什么？

Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具,它可以很好地控制HTTP和TCP客户端的行为。相关资料

简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。

在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。

Ribbon能干什么？

LB，即负载均衡(Load Balance)，在微服务或分布式集群中经常用的一种应用。负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA(High Available)。

常见的负载均衡有软件Nginx，LVS，硬件F5等。相应的在中间件，例如：dubbo和SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义。

集中式LB

即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件，如F5, 也可以是软件，如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方。

进程内LB

将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

Ribbon初步的配置

给microservice-cloud-consumer-user-8002消费者模块添加如下依赖

    <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>

修改application.yml 追加eureka的服务注册地址

eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

因为消费者只需从集群Eureka获取服务提供者的信息，本身并不需要注册到注册中心因此register-with-eureka: false

对ConfigBean类进行新注解@LoadBalanced获得Rest时加入Ribbon的配置。

/**
 * @version Version: 1.0
 * @date DateTime: 2018/08/15 20:54:00<br/>
 */
@Configuration
public class ConfigBean {
    /**
     * RestTemplate提供了多种便捷访问远程Http服务的方法，
     * 是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集。
     */
    @Bean
    @LoadBalanced //要求客户端通过Rest去访问微服务的时候自带负载均衡
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

主启动类UserConsumer8002App添加@EnableEurekaClient注解。

@SpringBootApplication
@EnableEurekaClient
public class UserConsumer8002App {
    public static void main(String[] args) {
        SpringApplication.run(UserConsumer8002App.class,args);
    }
}

修改UserControllerConsumer客户端访问类。

@RestController
@RequestMapping("/consumer/user")
public class UserControllerConsumer {
//    private static final String REST_URL_PREFIX = "http://localhost:8001";

    private static final String REST_URL_PREFIX = "http://MICROSERVICECLOUD-USER";

    @Autowired
    private RestTemplate restTemplate;

    @RequestMapping("/add")
    public String add(User user){
        return restTemplate.postForObject(REST_URL_PREFIX + "/user/add",user,String.class);
    }
    @RequestMapping("/get/{name}")
    public User get(@PathVariable("name") String name){
        return restTemplate.getForObject(REST_URL_PREFIX + "/user/get/" + name,User.class);
    }
    @RequestMapping("/list")
    public List<User> list(){
        return restTemplate.getForObject(REST_URL_PREFIX + "/user/list",List.class);
    }
}

使用如下图展示的服务Application Name作为服务提供者的地址，这样可配置一个服提供者集群，通过Ribbon访问服务实现负载均衡。

测试依次启动三个Eureka集群服务，然后分别启动服务提供者和服务消费者，然后在浏览器访问接口

http://127.0.0.1:8002/consumer/user/list
# 可得到返回JSON结果
[
    {
        "id": 1,
        "name": "zhangsan",
        "age": 18,
        "gender": 1,
        "dbSource": "user_db"
    },
    ...
]

后台也发现相关日志

2018-08-28 21:01:01.585  INFO 18615 --- [qtp754617275-20] c.netflix.loadbalancer.BaseLoadBalancer  : Client: MICROSERVICECLOUD-USER instantiated a LoadBalancer: DynamicServerListLoadBalancer:{NFLoadBalancer:name=MICROSERVICECLOUD-USER,current list of Servers=[],Load balancer stats=Zone stats: {},Server stats: []}ServerList:null
2018-08-28 21:01:01.593  INFO 18615 --- [qtp754617275-20] c.n.l.DynamicServerListLoadBalancer      : Using serverListUpdater PollingServerListUpdater
......
2018-08-28 21:01:01.613  INFO 18615 --- [qtp754617275-20] c.n.l.DynamicServerListLoadBalancer      : DynamicServerListLoadBalancer for client MICROSERVICECLOUD-USER initialized: DynamicServerListLoadBalancer:{NFLoadBalancer:name=MICROSERVICECLOUD-USER,current list of Servers=[127.0.0.1:8001],Load balancer stats=Zone stats: {defaultzone=[Zone:defaultzone;	Instance count:1;	Active connections count: 0;	Circuit breaker tripped count: 0;	Active connections per server: 0.0;]
},Server stats: [[Server:127.0.0.1:8001;	Zone:defaultZone;	Total Requests:0;	Successive connection failure:0;	Total blackout seconds:0;	Last connection made:Thu Jan 01 08:00:00 CST 1970;	First connection made: Thu Jan 01 08:00:00 CST 1970;	Active Connections:0;	total failure count in last (1000) msecs:0;	average resp time:0.0;	90 percentile resp time:0.0;	95 percentile resp time:0.0;	min resp time:0.0;	max resp time:0.0;	stddev resp time:0.0]
]}ServerList:org.springframework.cloud.netflix.ribbon.eureka.DomainExtractingServerList@4ae2c843

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

Ribbon负载均衡

alt

因为上面的例子只有一个服务提供者并不能很好的表达Ribbon的负载均衡，下面我们深入的了解一下负载均衡极其策略

Ribbon在工作时分成两步

第一步先选择 EurekaServer ,它优先选择在同一个区域内负载较少的server
第二步再根据用户指定的策略，在从server取到的服务注册列表中选择一个地址。其中Ribbon提供了多种策略：比如轮询、随机和根据响应时间加权。

添加服务提供者

在总父工程下创建microservice-cloud-provider-user-8011的maven Module配置参照microservice-cloud-provider-user-8001
同1一样的步骤创建microservice-cloud-provider-user-8021模块，注意更改配置的端口号

创建模块对应的DB

分别创建两个DB，user_db2、user_db3分别对应microservice-cloud-provider-user-8011和microservice-cloud-provider-user-8021模块

启动并验证

先启动Eureka集群模块，然后启动3个服务提供者模块，然后启动服务消费者模块
访问服务消费者端口验证

# 在浏览器方位以下接口，获取名为zhangsan用户信息
http://127.0.0.1:8002/consumer/user/get/zhangsan

第一次返回结果

{
    "id": 1,
    "name": "zhangsan",
    "age": 18,
    "gender": 1,
    "dbSource": "user_db3"
}

第二次返回结果

{
    "id": 1,
    "name": "zhangsan",
    "age": 18,
    "gender": 1,
    "dbSource": "user_db2"
}

由上结果可知，两次返回的dbSource值不一样，证明两次走的是不同服务提供者的接口，默认的负载均衡策略为轮询。访问http://127.0.0.1:7001可以看到MICROSERVICECLOUD-USER微服务下面挂着三个实例

alt

总结：Ribbon其实就是一个软负载均衡的客户端组件，他可以和其他所需请求的客户端结合使用，和eureka结合只是其中的一个实例。

Ribbon核心组件之IRule

SpringCloud结合Ribbon，它默认出厂自带了7种算法。

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

换成随机的负载均衡算法（RandomRule）算法

我们在microservice-cloud-consumer-user-8002加入以下配置

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

同样的更改为以上AvailabilityFilteringRule 、WeightedResponseTimeRule算法也是一样的。

Ribbon自定义算法

如果上面的7种算法，都不够出来业务逻辑，那么可以来自定义算法。

1.修改microservice-cloud-consumer-user-8002的主启动类，在主启动类上添加一个注解@RibbonClient()

@SpringBootApplication
@EnableEurekaClient
/*在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效。
并且官方文档明确给出了警告：
    这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下，
    否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，也就是说
    我们达不到特殊化定制的目的了。*/
//那么解决方案是重新在java包下再建一个包名，并把MySelfRule类放入该包内。
@RibbonClient(name="MICROSERVICECLOUD-USER",configuration=MyselfRule.class)
public class UserConsumer8002App {
    public static void main(String[] args) {
        SpringApplication.run(UserConsumer8002App.class,args);
    }
}

编写MyselfRule自定义配置类的：

package com.zealzhangz.myrule;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @version Version: 1.0
 * @date DateTime: 2018/09/08 14:56:00<br/>
 */
@Configuration
public class MyselfRule{
    @Bean
    public IRule myRule() {
        //Ribbon默认是轮询，我自定义为随机
        return new RandomRule();

    }
}

深度自定义负载均衡规则

这里说的深度自定义就是继承虚类AbstractLoadBalancerRule实现IRule接口，就和系统实现RoundRobinRule、RandomRule负载均衡规则一样的实现
现在我们实现一个，随机选择一个Server，并且该Server调用5次然后再随机选择下一个Server

package com.zealzhangz.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;

/**
 * @version Version: 1.0
 * @date DateTime: 2018/09/08 16:07:00<br/>
 */
public class MyselfRandomRule extends AbstractLoadBalancerRule {
    //总共被调用的次数，目前要求每台被调用5次
    private int total = 0;
    //当前提供服务的机器号
    private int currentIndex = 0;
    public Server choose(ILoadBalancer lb, Object key) {
        //ILoadBalancer哪一种负载均衡算法如果等于null的话就返回null，那么自然而然，它肯定会加载一种算法，所以它不会变成null。
        if (lb == null) {
            return null;
        }
        //现在还不知道是哪个算法来响应server
        Server server = null;
        //如果说server等于null，那么就看线程是否中断了，如果被中断的话就返回null
        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
//upList的意思就是现在活着的可以对外提供的机器，然后.get()方法通过
//int index = rand.nextInt(serverCount); 那么就是随机到几就返回第几的值
            List<Server> upList = lb.getReachableServers();
            List<Server> allList = lb.getAllServers();
//如果serverCount目前有三台，那么就不等于0，那么就是flase。
            int serverCount = allList.size();
            if (serverCount == 0) {
                /*
                 * No servers. End regardless of pass, because subsequent passes
                 * only get more restrictive.
                 */
                return null;
            }
//这个的意思就是说如果serverCount有三台，那么index就得到了从下标0和1和2数组
// int index = rand.nextInt(serverCount);
// server = upList.get(index);
//当第一次total < 5的时候
//当第二次total < 5的时候
//当第五次total < 5的时候（那么第五次就不小于5），那么if(total < 5)这段里面的代码就不执行了
            if (total < 5) {
//那么第一次的server是0号机
//那么第二次的server也是0号机
                server = upList.get(currentIndex);
//第一次的总的计数次数是加一个1
//第二次的总的计数次数是再加一个1
                total++;
//当第五次total < 5的时候就走else
            } else {
//那么total等于0
                total = 0;
//而currentIndex就加一个1
                currentIndex++;
//那么1大于等于upList.size()，目前假设有三台机器，那么1就不大于等于upList.size()
//那么现在就是给0号机给1号机进行服务了，以此类推。。
//但是如果currentIndex等于下标3的时候并且>= upList.size()，但我们按照数组下标来算的话只               
//有0和1和2的下标，那么当currentIndex等于下标3的时候这样就是超过第三台了，那么                        
//currentIndex就重新等于0。以此类推。。
                if (currentIndex >= upList.size()) {
                    currentIndex = 0;
                }
            }
//如果这个server等于null，那么线程中断一会，下一轮继续
            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;
            }
//如果活着好好的，那么就返回server回去
            if (server.isAlive()) {
                return (server);
            }
// Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }
//返回对应该响应服务是8001，还是8002还是8003
        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) {
    }
}

配置使用该随机规则

package com.zealzhangz.myrule;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @version Version: 1.0
 * @date DateTime: 2018/09/08 14:56:00<br/>
 */
@Configuration
public class MyselfRule{
    @Bean
    public IRule myRule() {
        //Ribbon默认是轮询，我自定义为随机
//        return new RandomRule();
        //深度自定义的随机规则，每个Server调用5次
        return new MyselfRandomRule();

    }
}

调用接口测试发现每个Server节点调用5次后换另外一个节点

本文由 zealzhangz 创作，采用知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
最后编辑时间为: 2018/09/09 17:09

SpringCloud篇三之Ribbon