在上一篇文章,讲了服务的注册和发现。在微服务架构中,业务都会被拆分成一个独立的服务,服务与服务的通讯是基于http restful的。Spring cloud有两种服务调用方式,一种是ribbon+restTemplate,另一种是feign。在这一篇文章首先讲解下基于ribbon+rest。
一、ribbon是什么?
Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端 负载均衡的工具。 简单的说,Ribbon是Netflix发布的开源项目,主要功能是提供客户端的软件负载均衡算法,将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时,重试等。简单的说,就是在配置文件中 列出Load Balancer(简称LB)后面所有的机器,Ribbon会自动的帮助你基于某种规则(如简单轮询,随机连接 等)去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。
负载均衡又区分了两种类型:
-
客户端负载均衡(Ribbon)
-
服务实例的清单在客户端,客户端进行负载均衡算法分配。
-
(从上面的知识我们已经知道了:客户端可以从Eureka Server中得到一份服务清单,在发送请求时通过负载均衡算法,在多个服务器之间选择一个进行访问)
-
-
服务端负载均衡(Nginx)
-
服务实例的清单在服务端,服务器进行负载均衡算法分配。
-
二、实战
这一篇文章基于上一篇文章的工程,启动eureka-server 工程它的端口为3000;启动order、order01工程,在eureka-server注册了2个实例,这就相当于一个server-order服务小的集群。
我们在写一个消费者server-order集群中的接口。
3.1、建一个服务消费者
重新新建一个spring-boot工程,取名为:user; 在它的pom.xml继承了父pom文件,并引入了以下依赖:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>spring-cloud-test</artifactId>
<groupId>com.dukun.study</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>user</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Finchley.SR2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
在工程的配置文件指定服务的注册中心地址为http://localhost:3000/eureka/,程序名称为client-user,程序端口为5000,application.yml如下:
server:
port: 5000
eureka:
client:
serviceUrl:
defaultZone: http://localhost:3000/eureka/
instance:
instance-id: user-1 #此实例注册到eureka服务端的唯一的实例ID
prefer-ip-address: true #是否显示IP地址
leaseRenewalIntervalInSeconds: 20 #eureka客户需要多长时间发送心跳给eureka服务器,表明它仍然活着,默认为30 秒 (与下面配置的单位都是秒)
leaseExpirationDurationInSeconds: 60 #Eureka服务器在接收到实例的最后一次发出的心跳后,需要等待多久才可以将此实例删除,默认为90秒
spring:
application:
name: client-user #此实例注册到eureka服务端的name
启动类:
/**
* 用户消费端
*
* @Author: dukun0210
* @Date: 2021/1/7 14:00
*/
@SpringBootApplication
@EnableEurekaClient
public class UserApp {
public static void main(String[] args) {
SpringApplication.run(UserApp.class);
}
}
要使用ribbon,只需要在RestTemplate加一个注解:@LoadBalanced
/**
* 配置类
* ribbon 使用ribbon 做客户端复杂均衡
*
* @Author: dukun0210
* @Date: 2021/1/7 14:07
*/
@ComponentScan("com.dukun.*")
@Configuration
public class AppConfig {
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
/**
* 使用轮询 负载均衡算法
* @return
*/
@Bean
public IRule iRule(){
return new RoundRobinRule();
}
}
调用服务:
@RestController
public class UserController {
@Autowired
RestTemplate restTemplate;
//private static final String POWER_URL="http://SERVER-POWER";
private static final String ORDER_URL="http://SERVER-ORDER";
/**
* 获取订单信息
* @param name
* @return
*/
@GetMapping("/getOrder.do")
public R getOrder(@RequestParam String name){
return R.success("操作成功",restTemplate.getForObject(ORDER_URL+"/getOrder.do?name="+name,Object.class));
}
}
如下图:已经完成了负载均衡, 他默认的负载均衡是轮询策 略,两台服务器被分别调用一次
此时的架构:
- 一个服务注册中心,eureka server,端口为3000
- server-order工程跑了两个实例,端口分别为7000,7001,分别向服务注册中心注册
-
client-user端口为5000,向服务注册中心注册
- 当client-user通过restTemplate调用server-orde的接口时,因为用ribbon进行了负载均衡,会轮流的调用server-orde:order和order01 两个服务;
三、Ribbon 负载均衡算法
Ribbon
中有更多的负载均衡调度算法,其默认是使用的RoundRobinRule
轮询策略。
-
RoundRobinRule:轮询策略。
Ribbon
默认采用的策略。若经过一轮轮询没有找到可用的provider
,其最多轮询 10 轮。若最终还没有找到,则返回 null。 -
RandomRule: 随机策略,从所有可用的 provider 中随机选择一个。
-
RetryRule: 重试策略。先按照 RoundRobinRule 策略获取 provider,若获取失败,则在指定的时限内重试。默认的时限为 500 毫秒。
- WeightedResponseTimeRule:响应时间权重策略。响应时间作为选取权重的负载均衡策略,其含义就是,响应时间越短的服务被选中的可能性大。
- AvailabilityFilteringRule:可用过滤策略。过滤掉连接失败的服务节点,并且过滤掉高并发的服务节点,然后从健康的服务节点中,使用轮询策略选出一个节点返回。
- BestAvailableRule:并发量最小可用策略 ,选择一个并发量最小的server返回。如何判断并发量最小呢?ServerStats有个属性activeRequestCount,这个属性记录的就是server的并发量。轮询所有的server,选择其中activeRequestCount最小的那个server,就是并发量最小的服务节点。
- ZoneAvoidanceRule:策略描述:复合判断server所在区域的性能和server的可用性,来选择server返回。
3.1、核心组件:IRule
IRule是什么? 它是Ribbon对于负载均衡策略实现的接口, 怎么理解这句话? 说白了就是你实现这个接口,就能自 定义负载均衡策略,
类继承关系
3.2、自定义负载均衡策略
Ribbon不仅实现了几种负载均衡策略,也为开发者提供了自定义负载均衡策略的支持。
自定义负载均衡策略有3个关键点:
1,继承抽象类AbstractLoadBalancerRule
2,自定义的负载均衡策略类,不能放在@ComponentScan所扫描的当前包和子包下。
3,在主启动类上添加@RibbonClient注解,或者在配置文件中指定哪个微服务使用自定义负载均衡策略。
配置文件中配置项如下:
springboot.微服务名称.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
或者 springboot.微服务名称.NFLoadBalancerRuleClassName=com.xxx.xxx.xxx.自定义负载均衡策略实现类
1、自定义算法RandomRule_ZY 必须继承AbstractLoadBalanceRule类
/**自定义的负载均衡算法*/
public class RandomRule_ZY extends AbstractLoadBalancerRule {
// total = 0 // 当total==5以后,我们指针才能往下走,
// index = 0 // 当前对外提供服务的服务器地址,
// total需要重新置为零,但是已经达到过一个5次,我们的index = 1
// 分析:我们5次,但是微服务只有8001 8002 8003 三台,OK?
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;
}
//private int total = 0; // 总共被调用的次数,目前要求每台被调用5次
//private int currentIndex = 0; // 当前提供服务的机器号
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);
}
server = null;
Thread.yield();
}
return server;
}
@Override
public Server choose(Object key) {
return choose(getLoadBalancer(), key);
}
@Override
public void initWithNiwsConfig(IClientConfig clientConfig) {
}
}
2、如果想使用某个自定义算法则注入到bean中即可 不能放在@ComponentScan所扫描的当前包和子包下
/**
* 使用自定义规则
*/
@Configuration
public class PowerRuleConfig {
@Bean
public IRule iRule(){
return new RandomRule_ZY();
}
}
3、在主启动类中添加ribbon注解
@RibbonClients({
@RibbonClient(name = "SERVER-ORDER",configuration = OrderRuleConfig.class),
@RibbonClient(name = "SERVER-POWER",configuration = PowerRuleConfig.class)
})
特别注意的是@RibbonClients({
@RibbonClient(name = "SERVER-ORDER",configuration = OrderRuleConfig.class),
@RibbonClient(name = "SERVER-POWER",configuration = PowerRuleConfig.class)
})
name指定针对哪个服务 进行负载均衡,而configuration指定负载均衡的算法具体实现类。
到这里ribbon就讲完了。