SpringCloud篇三之Ribbon

/ SpringCloudJava技术 / 没有评论 / 91浏览

alt

Ribbon 是什么?

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

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

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

Ribbon能干什么?

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

常见的负载均衡有软件NginxLVS,硬件F5等。相应的在中间件,例如:dubboSpringCloud中均给我们提供了负载均衡,SpringCloud的负载均衡算法可以自定义。

集中式LB

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

进程内LB

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

Ribbon初步的配置

  1. 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>
  1. 修改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

  1. 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();
    }
}
  1. 主启动类UserConsumer8002App添加@EnableEurekaClient注解。
@SpringBootApplication
@EnableEurekaClient
public class UserConsumer8002App {
    public static void main(String[] args) {
        SpringApplication.run(UserConsumer8002App.class,args);
    }
}
  1. 修改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);
    }
}
  1. 测试 依次启动三个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在工作时分成两步

添加服务提供者

  1. 在总父工程下创建microservice-cloud-provider-user-8011maven Module配置参照microservice-cloud-provider-user-8001

  2. 同1一样的步骤创建microservice-cloud-provider-user-8021模块,注意更改配置的端口号

创建模块对应的DB

  1. 分别创建两个DBuser_db2、user_db3分别对应microservice-cloud-provider-user-8011microservice-cloud-provider-user-8021模块

启动并验证

  1. 先启动Eureka集群模块,然后启动3个服务提供者模块,然后启动服务消费者模块

  2. 访问服务消费者端口验证

# 在浏览器方位以下接口,获取名为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种算法。

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

换成随机的负载均衡算法(RandomRule)算法

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

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

Ribbon自定义算法

  1. 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);
    }
}
  1. 编写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();

    }
}

深度自定义负载均衡规则

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();

    }
}