SpringCloud 服务负载均衡和调用 Ribbon、OpenFeign的方法

1、Ribbon

Spring Cloud Ribbon是基于Netflix Ribbon实现的—套客户端―负载均衡的工具。
简单的说,Ribbon是Netlix发布的开源项目,主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置项如连接超时,重试等。简单的说,就是在配置文件中列出Load Balancer(简称LB)后面所有的机器,Ribbon会自动的帮助你基于某种规则(如简单轮询,随机连接等)去连接这些机器。我们很容易使用Ribbon实现自定义的负载均衡算法。

目前Ribbon和Eureka进入到维护模式。停更不停用

负载均衡:

LB负载均衡(Load Balance)是什么?
简单的说就是将用户的请求平摊的分配到多个服务上,从而达到系统的HA(高可用)。1
常见的负载均衡有软件Nginx,LVS,硬件F5等。
Ribbon本地负载均衡客户端VS Nginx服务端负载均衡区别
Nginx是服务器负载均衡,客户端所有请求都会交给nginx,然后由nginx实现转发请求。即负载均衡是由服务端实现的。
Ribbon本地负载均衡,在调用微服务接口时候,会在注册中心上获取注册信息服务列表之后缓存到VM本地,从而在本地实现RPC远
程服务调用技术。

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

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

负载均衡 +RestTemplate 配合使用

架构

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

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

pom 依赖
spring-cloud-starter-netflix-eureka-client
自身 就集成了 ribbon 。

RestTemplate说明:

Ribbon负载均衡规则

继承结构

自带7种:

如何使用?负载均衡策略替换。

官方文档明确给出了警告:
这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下,
否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享,达不到特殊化定制的目的了。

增加rule配置类

包路径: com.fage.rules

@Configuration
public class MyRibbonRule {
 @Bean
 public IRule randomRule() {
  return new RandomRule();
 }

}

boot启动类增加注解

@RibbonClient(name = "cloud-payment-service", configuration = {MyRibbonRule.class})

负载均衡轮询算法原理

负载均衡算法: rest接口第几次请求数%服务器集群总数量=实际调用服务器位置下标,每次服务重启动后rest接口计数从1开始。
List instances = discoveryClient.getlnstances(CLOUD-PAYMENT-SERVICE");
如:List [o] instances = 127.0.0.1:8002
List [1] instances = 127.0.0.1:8001
8001+8002组合成为集群,它们共计2台机器,集群总数为2,按照轮询算法原理:
当总请求数为1时:1%2=1对应下标位置为1,则获得服务地址为127.0.0.1:8001
当总请求数位2时: 2%2=O对应下标位置为0,则获得服务地址为127.0.0.1:8002
当总请求数位3时:3%2=1对应下标位置为1,则获得服务地址为127.0.0.1:8001
当总请求数位4时:4%2=0对应下标位置为0,则获得服务地址为127.0.0.1:8002
如此类推......

源码:

从0开始取余获取提供者服务。

内部使用cas+自旋锁。

手写一个负载均衡算法,实现轮询

1、服务提供者增加接口

 @GetMapping("/payment/loadBalanced")
 public CommonResult<Object> getLoadBalanced() {
  return new CommonResult<>(200, "调用成功", port);
 }

2、服务消费者改造

将 @LoadBalanced 注解去掉

增加MyLoadBalanced接口,只有一个方法ServiceInstance instance(List serviceInstances);用于得到当前算法后要使用的实例对象。

实现类MyLib源码如下:

@Component
@Slf4j
public class MyLib implements MyLoadBalanced {

 private final AtomicInteger nextServerCyclicCounter = new AtomicInteger(0);

 public final int getAndIncrement() {
  // 方案 1 cas
//  int current;
//  int next;
//  do {
//   current = this.nextServerCyclicCounter.get();
//   next = current >= 2147483647 ? 0 : current + 1;
//  } while (!this.nextServerCyclicCounter.compareAndSet(current, next));
//  log.info("**********第几次访问,次数next:" + next);
//  return next;

  // 方案 2 JUC 提供的 自增方法
  log.info("**********第几次访问,次数next:" + nextServerCyclicCounter.getAndIncrement());
  return nextServerCyclicCounter.get();
 }

 /**
  * 负载均衡算法:rest接口第几次请求书 % 服务器集群总数量 = 实际调用服务器位置下标,每次服务重启动后rest接口计数从1开始
  *
  * @param serviceInstances 集群中的 服务 实例
  * @return 集群中的一个实例
  */
 @Override
 public ServiceInstance instance(List<ServiceInstance> serviceInstances) {
  return serviceInstances.get(getAndIncrement() % serviceInstances.size());
 }
}

3、改造消费者调用方法

@GetMapping(value = "/consumer/payment/loadBalanced")
 public CommonResult getLoadBalanced() {
  ServiceInstance instance = myLoadBalanced.instance(discoveryClient.getInstances(PAYMENT_URL.split("//")[1]));
  return restTemplate.getForObject(instance.getUri()+"/payment/loadBalanced", CommonResult.class);
 }

2、OpenFeign

只需要一个接口并在接口上添加注解即可。

feign不再更新,直接学习openFeign。都是用于负载均衡。

Feign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单。
它的使用方法是定义一个服务接口然后在上面添加注解。Feign也支持可拔括式的编码罴和解码器。Spring Cloud对Feign进行了封装,使其支持了Spring MVC标准注解和HttpMessageConverters。Feign和ribbon组合使用以支持负载均衡。

Feign能干什么

Feign旨在使编写Java Http客户端变得更容易。
前面在使用Ribbon+RestTemplate时,利用RestTemplate对http请求的封装处理,形成了一套模版化的调用方法。但是在实际开发
中,由于对服务依赖的调用可能不止一处,往往一个接口会被多处调用,所以通常都会针对每个微服务自行封装一些客户端类来包装
这些依赖服务的调用。所以,Feign在此基础上做了进一步封装,由他来帮助我们定义和实现依赖服务接口的定义。在Feign的实现下
,我们只需创建一个接口并使用注解的方式来配置它(以前是Dao接口上面标注Mapper注解,现在是一个微服务接口上面标注一个
Feign注解即可),即可完成对服务提供方的接口绑定,简化了使用Spring cloud Ribbon时,自动封装服务调用客户端的开发量。

Feign集成了Ribbon

利用Ribbon维护了Payment的服务列表信息,并且通过轮询实现了客户端的负载均衡。而与Ribbon不同的是,通过feign只需要定义
服务绑定接口且以声明式的方法,优雅而简单的实现了服务调用

Feign和openFeign的区别

搭建openFeign模块 cloud-consumer-openfeign-order80

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-openfeign</artifactId>
  </dependency>

启动类增加注解@EnableFeignClients

增加feign接口

@Component
@FeignClient(value = "cloud-payment-service")
public interface OpenFeignService {
 @GetMapping("/payment/loadBalanced")
 public CommonResult<Object> getLoadBalanced();
}

增加controller

@RestController
@Slf4j
public class OrderController implements OpenFeignService {
 @Resource
 OpenFeignService openFeignService;

 @Override
 @GetMapping("/consumer/payment/loadBalanced")
 public CommonResult<Object> getLoadBalanced() {
  return openFeignService.getLoadBalanced();
 }
}

注册中心使用eureka。跟之前一样。

OpenFeign超时控制

OpenFeign默认等待时间为1ms。

设置超时时间

###设置 超时时间 方式 1
# 设置 feign客户端超时时间 ( openFeign 默认支持 ribbon )
ribbon:
 # 指的是建立连接所用的时间,适用于网络状况正常的情况下,俩端连接所用的时间 单位是秒
 ReadTimeout: 6000
 # 指的是建立连接后从服务器读取到可用资源的时间
 ConnectTimeout: 5000

###设置 超时时间 方式 2
#feign:
# client:
# config:
#  default:
#  connectTimeout: 5000
#  readTimeout: 6000
#  loggerLevel: full 

OpenFeign日志增强

Feign提供了日志打印功能,我们可以通过配置来调整日志级别,从而了解Feign中Http请求的细节。
说白了就是对Feign接口的调用情况进行监控和输出

日志级别:

NONE:默认的,不显示任何日志;
BASIC:仅记录请求方法、URL、响应状态码及执行时间;
HEADERS:除了BASIC中定义的信息之外,还有请求和响应的头信息;
FULL:除HEADERS中定义的信息之外,还有请求和响应的正文及元数据。

配置日志bean:

 @Bean
 Logger.Level feignLoggerLevel() {
  return Logger.Level.FULL;
 }

yml开启日志

# 设置 feign客户端超时时间 ( openFeign 默认支持 ribbon )
ribbon:
 # 指的是简历连接所用的时间,适用于网络状况正常的情况下,俩端连接所用的时间 单位是秒
 ReadTimeout: 8000
 # 指的是建立连接后从服务器读取到可用资源的时间
 ConnectTimeout: 6000

# 开启 feign 日志打印
logging:
 level:
 ## feign 日志 以什么级别 监控那个接口
 com.fage.springcloud.feign.OpenFeignService: debug

结果:

2020-08-25 17:55:26.667 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] ---> GET http://cloud-payment-service/payment/loadBalanced HTTP/1.1

2020-08-25 17:55:26.667 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] ---> END HTTP (0-byte body)

2020-08-25 17:55:26.682 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] <--- HTTP/1.1 200 (14ms)

2020-08-25 17:55:26.682 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] connection: keep-alive

2020-08-25 17:55:26.682 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] content-type: application/json

2020-08-25 17:55:26.682 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] date: Tue, 25 Aug 2020 09:55:26 GMT

2020-08-25 17:55:26.682 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] keep-alive: timeout=60

2020-08-25 17:55:26.682 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] transfer-encoding: chunked

2020-08-25 17:55:26.682 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] 

2020-08-25 17:55:26.683 DEBUG 56624 --- [p-nio-80-exec-2] c.f.springcloud.feign.OpenFeignService   : [OpenFeignService#getLoadBalanced] {"code":200,"message":"调用成功","data":"8001"}

到此这篇关于SpringCloud 服务负载均衡和调用 Ribbon、OpenFeign的方法的文章就介绍到这了,更多相关SpringCloud 服务负载均衡内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • SpringCloud 中使用 Ribbon的方法详解

    在前两章已经给大家讲解了Ribbon负载均衡的规则 以及 如何搭建Ribbon并调用服务,那么在这一章呢 将会给大家说一说如何在SpringCloud中去使用Ribbon.在搭建之前 我们需要做一些准备工作. 1. 搭建Eureka服务器:springCloud-ribbon-server(项目名称) 2. 服务提供者:springCloud-ribbon-police(项目名称) 3. 服务调用者:springCloud-ribbon-person(项目名称) 搭建Eureka服务器 配置 p

  • SpringCloud与Consul集成实现负载均衡功能

    负载均衡(Load Balance,简称LB)是一种服务器或网络设备的集群技术.负载均衡将特定的业务(网络服务.网络流量等)分担给多个服务器或网络设备,从而提高了业务处理能力,保证了业务的高可用性.负载均衡基本概念有:实服务.实服务组.虚服务.调度算法.持续性等,其常用应用场景主要是服务器负载均衡,链路负载均衡. 一.背景 SpringCloud微服务目前比较流行,其中大都在使用的服务注册与发现是Eureka,最近研究了Consul的集群搭建,现使用Consul实现服务的负载均衡.其主要拓扑结构

  • SpringCloud Ribbon 负载均衡的实现

    前言 Ribbon是一个客户端负载均衡器,它提供了对HTTP和TCP客户端的行为的大量控制.我们在上篇(猛戳:SpringCloud系列--Feign 服务调用)已经实现了多个服务之间的Feign调用,服务消费者调用服务提供者,本文记录Feign调用Ribbon负载均衡的服务提供者 GitHub地址:https://github.com/Netflix/ribbon 官方文档:https://cloud.spring.io/spring-cloud-static/spring-cloud-net

  • Springcloud基于OpenFeign实现服务调用代码实例

    1.依赖 <!--引入open feign依赖--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> </dependencies> 2.启动注解 @SpringBootApplication @Enabl

  • SpringCloud 服务负载均衡和调用 Ribbon、OpenFeign的方法

    1.Ribbon Spring Cloud Ribbon是基于Netflix Ribbon实现的-套客户端―负载均衡的工具. 简单的说,Ribbon是Netlix发布的开源项目,主要功能是提供客户端的软件负载均衡算法和服务调用.Ribbon客户端组件提供一系列完善的配置项如连接超时,重试等.简单的说,就是在配置文件中列出Load Balancer(简称LB)后面所有的机器,Ribbon会自动的帮助你基于某种规则(如简单轮询,随机连接等)去连接这些机器.我们很容易使用Ribbon实现自定义的负载均

  • SpringCloud 2020-Ribbon负载均衡服务调用的实现

    1.概述 官网:https://github.com/Netflix/ribbon/wiki/Getting-Started Ribbon目前也进入维护模式,未来替换方案: LB(负载均衡) 集中式LB 进程内LB Ribbon就是负载均衡+RestTemplate调用 2.Ribbon负载均衡演示 1.架构说明 总结:Ribbon其实就是一个软负载均衡的客户端组件,他可以和其他所需请求的客户端结合使用,和eureka结合只是其中的一个实例. 2. 3.二说RestTemplate的使用 官网

  • 详解SpringCloud的负载均衡

    目录 一.什么是负载均衡 二.负载均衡的简单分类 三.为什么需要做负载均衡 四.springCloud如何开启负载均衡 五.IRule 1.RandomRule:表示随机策略,它将从服务清单中随机选择一个服务: 2.ClientConfigEnabledRoundRobinRule:ClientConfigEnabledRoundRobinRule并没有实现什么特殊的处理逻辑,但是他的子类可以实现一些高级策略, 当一些本身的策略无法实现某些需求的时候,它也可以做为父类帮助实现某些策略,一般情况下

  • SpringCloud LoadBalancerClient 负载均衡原理解析

    目录 深入解析 LoadBalancerClient 接口源码: 1.LoadBalancerClient 源码解析: 2.ILoadBalancer 源码解析: LoadBalancerClient 是 SpringCloud 提供的一种负载均衡客户端,Ribbon 负载均衡组件内部也是集成了 LoadBalancerClient 来实现负载均衡.那么 LoadBalancerClient 内部到底是如何做到的呢?我们先大概讲一下 LoadBalancerClient 的实现原理,然后再深入源

  • SpringBoot+Eureka实现微服务负载均衡的示例代码

    1,什么是Eureka,什么是服务注册与发现 Spring Boot作为目前最火爆的web框架.那么它与Eureka又有什么关联呢? Eureka是Netflix开源的一个RESTful服务,主要用于服务的注册发现. Eureka由两个组件组成:Eureka服务器和Eureka客户端.Eureka服务器用作服务注册服务器. Eureka客户端是一个java客户端,用来简化与服务器的交互.作为轮询负载均衡器,并提供服务的故障切换支持. Netflix在其生产环境中使用的是另外的客户端,它提供基于流

  • SpringCloud服务的发现与调用详解

    目录 前言 一.服务提供者 二.服务消费者 总结 相关推荐 上一章:Eureka注册中心 前言 上一章中,我们介绍了Eureka注册中心及集群的搭建,这一节将介绍服务的发现和调用.注意,这个时候我们只有注册中心,并没有引入其他的组件,所以需要使用SpringCloud原生态的服务发现和调用的方式实现,循序渐进的带你走入微服务的世界. 上篇文章我们已经创建好了注册中心,这次我们需要创建一个服务提供者(provider)和一个服务消费者(consumer)两个项目. 一.服务提供者 新建Maven项

  • Spring-cloud 服务发现与消费(以ribbon为例)

    说明: ribbon是spring-cloud中作为服务消费者的一种角色,客户端可以通过它来对服务提供者的服务进行消费, 比如本例中是服务提供者注册到注册中心,服务提供者提供了一个服务接口,返回一个hello字符串,我们通过ribbon将这个接口调用,再不暴露真实服务提供者的地址的同时,获取服务提供者的服务 前提: 按照之前几个教程,搭建出注册中心.服务提供者.这里可以使用分片的注册中心,也可以不使用,这里暂时定为使用之前搭好的分片注册中心,服务提供者仅提供一个即可. 准备工作: 1.启动注册中

  • 详解Spring Cloud负载均衡重要组件Ribbon中重要类的用法

    Ribbon是Spring Cloud Netflix全家桶中负责负载均衡的组件,它是一组类库的集合.通过Ribbon,程序员能在不涉及到具体实现细节的基础上"透明"地用到负载均衡,而不必在项目里过多地编写实现负载均衡的代码. 比如,在某个包含Eureka和Ribbon的集群中,某个服务(可以理解成一个jar包)被部署在多台服务器上,当多个服务使用者同时调用该服务时,这些并发的请求能被用一种合理的策略转发到各台服务器上. 事实上,在使用Spring Cloud的其它各种组件时,我们都能

  • Linux下Nginx负载均衡多个tomcat配置的方法步骤

    Linux下安装nginx和安装多个tomcat的方法这里不过多介绍,不清楚的可参考: Linux安装nginx: https://www.jb51.net/article/159519.htm Linux安装多个tomcat: https://www.jb51.net/article/159521.htm 当我们服务器安装好了nginx,并且安装了多台tomcat,那么我们现在可以试着玩玩nginx的负载均衡. 先简单介绍我的运行环境 一台阿里云服务器, Linux系统,jdk1.8, 已安装

  • 阿里云负载均衡SLB安装SSL证书的方法

    获取证书文件 1.登陆用户中心(如何登陆用户中心?)获取SSL证书(证书管理系统现在有2个版本并存[根据购买SSL证书品牌,类型等随机分配],证书管理系统版本不同,获取证书方式略有差异,最终得到的证书是没有区别的,请按照您现行使用的证书系统版本获取证书文件.) 1-1. 版本1-如何获取SSL证书文件:点击这里 ,找到如下图所示页面,请把SSL证书文件(包括"-----BEGIN CERTIFICATE-----"和"-----END CERTIFICATE-----&quo

随机推荐