聊聊SpringCloud中的Ribbon进行服务调用的问题

第聊聊SpringCloud中的Ribbon进行服务调用的问题目录1、Robbon1.1、Ribbon概述1.2、Ribbon负载均衡演示1.3、Ribbon核心组件IRule1.4、Ribbon负载均衡算法1.4.1、轮询算法原理负载均衡算法：1.4.2、RoundRobinRule源码1.4.3、手写轮询算法前置内容

（1）、微服务理论入门和手把手带你进行微服务环境搭建及支付、订单业务编写

（2）、SpringCloud之Eureka服务注册与发现

（3）、SpringCloud之Zookeeper进行服务注册与发现

（4）、SpringCloud之Consul进行服务注册与发现

1、Robbon

1.1、Ribbon概述

（1）、Ribbon是什么？

SpringCloud-Ribbon是基于NetflixRibbon实现的一套客户端负载均衡的工具。简单来说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置如连接超时、重拾等。简单的说，就是在配置文件中列出LoadBalancer（简称LB）后面的所有机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随即连接等）去连接这些机器。我们很容易使用Ribbon实现自定义的负载均衡算法。一句话就是负载均衡+RestTemplate调用。

（2）、Ribbon的官网

官网地址

且目前也进入了维护模式

（3）、负载均衡（LB）

负载均衡就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）。常见的负载均衡由软件nginx、LVS、F5。

1.集中式LB：就是在服务的消费方和提供方之间使用独立的LB设施（可以是硬件，如F5，也可以是软件，如nginx），由该设施负责把访问请求通过某种策略转发至服务的提供方。

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

（4）、Ribbon本地负载均衡客户端和Nginx服务端负载均衡的区别

Nginx是服务器负载均衡，客户端所有请求都会交给nginx实现转发请求。即负载均衡是由服务端实现的。Ribbon本地负载均衡，在调用微服务接口的时候，会在注册中心获取注册信息列表之后缓存到JVM本地，从而在本地实现RPC远程服务调用技术。

1.2、Ribbon负载均衡演示

（1）、架构说明

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

Ribbon在工作时分为两步

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

（2）、POM文件

所以在引入Eureka的整合包中就包含了整合Ribbon的jar包。

所以我们前面实现的8001和8002交替访问的方式就是所谓的负载均衡。

（3）、RestTemplate的说明

getForObject：返回对象为响应体中数据转化成的对象，基本上可以理解为Json。getForEntity：返回对象为ResponseEntity对象，包含了响应中的一些重要信息，比如响应头、响应状态码、响应体等。postForObjectpostForEntity

1.3、Ribbon核心组件IRule

1.主要的负载规则

RoundRobinRule：轮询RandomRule：随机RetryRule：先按照RoundRobinRule的策略获取服务，如果获取服务失败则在指定时间内会进行重试WeightedResponseTimeRule：对RoundRobinRule的扩展，响应速度越快的实例选择权重越大，越容易被选择BestAvailableRule：会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务AvailabilityFilteringRule：先过滤掉故障实例，再选择并发较小的实例ZoneAvoidanceRule：默认规则，复合判断server所在区域的性能和server的可用性选择服务器

2.如何替换负载规则

对cloud-consumer-order80包下的配置进行修改。我们自己自定义的配置类不能放在@ComponentScan所扫描的当前包以及子包下，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，达不到特殊化定制的目的了。在com.xiao的包下新建一个myrule的子包。

在myrule的包下新建一个MySelfRule配置类

​​​​​​​

importflix.loadbalancer.IRule;

importflix.loadbalancer.RandomRule;

importorg.springframework.context.annotation.Bean;

importorg.springframework.context.annotation.Configuration;

@Configuration

publicclassMySelfRule{

@Bean

publicIRulegetRandomRule(){

returnnewRandomRule();//新建随机访问负载规则

}

对主启动类进行修改，修改为如下：

importcom.xiao.myrule.MySelfRule;

importorg.springframework.boot.SpringApplication;

importorg.springframework.boot.autoconfigure.SpringBootApplication;

importflix.eureka.EnableEurekaClient;

importflix.ribbon.RibbonClient;

@SpringBootApplication

@EnableEurekaClient

@RibbonClient(name="CLOUD-PAYMENT-SERVICE",configuration=MySelfRule.class)

publicclassOrderMain80{

publicstaticvoidmain(String[]args){

SpringApplication.run(OrderMain80.class,args);

}

6.测试结果结果就是以我们最新配置的随机方式进行访问的。

1.4、Ribbon负载均衡算法

1.4.1、轮询算法原理负载均衡算法：

rest接口第几次请求数%服务器集群总数量=实际调用服务器位置下标，每次服务重新启动后rest接口计数从1开始。

1.4.2、RoundRobinRule源码

importflix.client.config.IClientConfig;

importjava.util.List;

importjava.util.concurrent.atomic.AtomicInteger;

importorg.slf4j.Logger;

importorg.slf4j.LoggerFactory;

publicclassRoundRobinRuleextendsAbstractLoadBalancerRule{

privateAtomicIntegernextServerCyclicCounter;

privatestaticfinalbooleanAVAILABLE_ONLY_SERVERS=true;

privatestaticfinalbooleanALL_SERVERS=false;

privatestaticLoggerlog=LoggerFactory.getLogger(RoundRobinRule.class);

publicRoundRobinRule(){

this.nextServerCyclicCounter=newAtomicInteger(0);

publicRoundRobinRule(ILoadBalancerlb){

this();

this.setLoadBalancer(lb);

publicServerchoose(ILoadBalancerlb,Objectkey){

if(lb==null){

log.warn("noloadbalancer");

returnnull;

}else{

Serverserver=null;

intcount=0;

while(true){

if(server==nullcount++10){

//获取状态为up的服务提供者

ListServerreachableServers=lb.getReachableServers();

//获取所有的服务提供者

ListServerallServers=lb.getAllServers();

intupCount=reachableServers.size();

intserverCount=allServers.size();

if(upCount!=0serverCount!=0){

//对取模获得的下标进行获取相关的服务提供者

intnextServerIndex=this.incrementAndGetModulo(serverCount);

server=(Server)allServers.get(nextServerIndex);

if(server==null){

Thread.yield();

}else{

if(server.isAlive()server.isReadyToServe()){

returnserver;

server=null;

continue;

log.warn("Noupserversavailablefromloadbalancer:"+lb);

returnnull;

if(count=10){

log.warn("Noavailablealiveserversafter10triesfromloadbalancer:"+lb);

returnserver;

privateintincrementAndGetModulo(intmodulo){

intcurrent;

intnext;

do{

//先加一再取模

current=this.nextServerCyclicCounter.get();

next=(current+1)%modulo;

//CAS判断，如果判断成功就返回true，否则就一直自旋

}while(!this.nextServerCyclicCpareAndSet(current,next));

returnnext;

}

1.4.3、手写轮询算法

1.修改支付模块的Controller

添加以下内容

@GetMapping(value="/payment/lb")

publicStringgetPaymentLB(){

returnServerPort;

}

2.ApplicationContextConfig去掉@LoadBalanced注解

3.LoadBalancer接口

importorg.springframework.cloud.client.ServiceInstance;

importjava.util.List;

publicinterfaceLoadBalancer{

//收集服务器总共有多少台能够提供服务的机器，并放到list里面

ServiceInstanceinstances(ListServiceInstanceserviceInstances);

}

4.编写MyLB类

importorg.springframework.cloud.client.ServiceInstance;

importorg.springframework.stereotype.Component;

importjava.util.List;

importjava.util.concurrent.atomic.AtomicInteger;

@Component

publicclassMyLBimplementsLoadBalancer{

privateAtomicIntegeratomicInteger=newAtomicInteger(0);

//坐标

privatefinalintgetAndIncrement(){

intcurrent;

intnext;

do{

current=this.atomicInteger.get();

next=current=21474836470:current+1;

}while(!this.atomicIpareAndSet(current,next));//第一个参数是期望值，第二个参数是修改值是

System.out.println("*******第几次访问，次数next:"+next);

returnnext;

@Override

publicServiceInstanceinstances(ListServiceInstanceserviceInstances){//得到机器的列表

intindex=getAndIncrement()%serviceInstances.size();//得到服务器的下标位置

returnserviceInstances.get(index);

}

5.修改OrderController类

importcom.xiao.cloud.entities.CommonResult;

importcom.xiao.cloud.entities.Payment;

importcom.xiao.cloud.lb.LoadBalancer;

importlombok.extern.slf4j.Slf4j;

importorg.springframework.beans.factory.annotation.Autowired;

importorg.springframework.cloud.client.ServiceInstance;

importorg.springframework.cloud.client.discovery.DiscoveryClient;

importorg.springframework.http.ResponseEntity;

importorg.springframework.web.bind.annotation.GetMapping;

importorg.springframework.web.bind.annotation.PathVariable;

importorg.springframework.web.bind.annotation.RestController;

importorg.springframework.web.client.RestTemplate;

importjavax.annotation.Resource;

import.URI;

importjava.util.List;

@RestController

@Slf4j

publicclassOrderController{

//publicstaticfinalStringPAYMENT_URL="http://localhost:8001";

publicstaticfinalStringPAYMENT_URL="http://CLOUD-PAYMENT-SERVICE";

@Resource

privateRestTemplaterestTemplate;

@Resource

privateLoadBalancerloadBalancer;

@Resource

privateDiscoveryClientdiscoveryClient;

@GetMapping("/consumer/payment/create")

publicCommonResultPaymentcreate(Paymentpayment){

returnrestTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);//写操作

@GetMapping("/consumer/payment/get/{id}")

publicCommonResultPaymentgetPayment(@PathVariable("id")Longid){

returnrestTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);

@GetMapping("/consumer/payment/g