前言
在微服务中，一个服务可能即是服务端也是客户端，当别的服务调用该服务的时候这个服务就是服务端，当这个服务主动调用另外一个服务的时候，那么就是服务端。
作为客户端通过服务注册与发现获取某个服务的注册列表后，那么如何均衡负载呢？前面我们提及到了，那么eureka客户端中自带了均衡负载策略，这个均衡负载组件就是ribbon。
为什么需要一个独立组件来均衡负载呢？一个是均衡负载的算法有很多，比如说轮询算法，但是通用轮询算法也有问题，比如说两台不同量级的机器，如果分配同等的工作量，那么有一个满了，另外一台还是空闲很多。
这里介绍一个ribbon客户端均衡负载的组件，其他的也一样，看文档就好。
正文
首先引入包:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
然后再订单模块中加入一个请求。
@GetMapping("/consumer/payment/getForEntity/{id}")
public CommonResult<Payment> getPayment2(@PathVariable("id") Long id){
ResponseEntity<CommonResult> entity = restTemplate.getForEntity(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
if (entity.getStatusCode().is2xxSuccessful()){
return entity.getBody();
}else{
return new CommonResult<>(444,"error request for payment");
}
}
然后调用一下:
两次请求都不一样。这里是效果。
查看结构图ribbon 结构图:
从上图可以看出ribbon 有7种方式进行负载均衡方式。
如果是网上有详细介绍的，一般不自己写，这里贴一下别人写好的:
https://blog.csdn.net/whiteBearClimb/article/details/108703356
我们可以根据不同场景进行选择，这些都是看情况讨论。
比如说，4台机器的响应速度和配置都差不多，那么轮询就好，这样开销小，如果是不同，那么可以考虑其他的方式来更大的利用资源。
那么如何替换规则:
自定义一个类:
package myrule;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MySelfRule {
@Bean
public IRule myRule(){
return new RandomRule();
}
}
然后在启动类上进行声明:
@RibbonClient(name="CLOUD-PROVIDER-SERVICE",configuration = MySelfRule.class)
效果:两次访问都是8001，随机访问任意一台。
那么这个RibbonClient 是如何实现的呢?
这里直接说原理：RibbonClient 会直接读取eureka的该服务的注册表，通过服务的注册表来实现均衡负载。
打开类继承关系:
在右边找到RoundRobinRule这个，然后就可以看到具体轮询的实现了。
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
log.warn("no load balancer");
return null;
}
Server server = null;
int count = 0;
while (server == null && count++ < 10) {
// 获取有效服务
List<Server> reachableServers = lb.getReachableServers();
// 获取全部服务
List<Server> allServers = lb.getAllServers();
int upCount = reachableServers.size();
int serverCount = allServers.size();
// 有效服务为0返回null
if ((upCount == 0) || (serverCount == 0)) {
log.warn("No up servers available from load balancer: " + lb);
return null;
}
// 通过全部服务获取下一个服务
int nextServerIndex = incrementAndGetModulo(serverCount);
server = allServers.get(nextServerIndex);
if (server == null) {
/* Transient. */
Thread.yield();
continue;
}
if (server.isAlive() && (server.isReadyToServe())) {
return (server);
}
// Next.
server = null;
}
if (count >= 10) {
log.warn("No available alive servers after 10 tries from load balancer: "
+ lb);
}
return server;
}
实现选择，直接看choose,里面我注释了一部分。
可以看到选择哪个服务其实是通过incrementAndGetModulo 这个方法来选择的。
private int incrementAndGetModulo(int modulo) {
for (;;) {
// 获取当前的值
int current = nextServerCyclicCounter.get();
// 计算获得新的索引
int next = (current + 1) % modulo;
// 更新新的索引
if (nextServerCyclicCounter.compareAndSet(current, next))
return next;
}
}
nextServerCyclicCounter 是new AtomicInteger(0); 这个的实例。
AtomicInteger 是一个原子操作类，至于其原理需要自己去看，效果是原子操作，就是在并发的时候依然可以保持其本来的面目，故而原子。
上面的注释应该很清楚了。原理还是比较简单的。
通过了解上面的选择方式，那么可以自己去实现对应的接口和写相应的code来实现自己特殊业务需要的均衡负载方式。