深入学习Spring Cloud-Ribbon

ribbon简介

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

ribion=负载均衡+重试

ribbon的工作步骤:

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

创建spring ribbon项目

第一步:新建spring项目

第二步:添加Eureka Discovery Client,Spring Web依赖

第三步:添加sp01-commons工具API依赖;eureka-client 中已经包含 ribbon 依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.1.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>cn.tedu</groupId>
  <artifactId>sp06-ribbon</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>sp06-ribbon</name>
  <description>Demo project for Spring Boot</description>

  <properties>
    <java.version>1.8</java.version>
    <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
  </properties>

  <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>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.junit.vintage</groupId>
          <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>cn.tedu</groupId>
      <artifactId>sp01-commons</artifactId>
      <version>0.0.1-SNAPSHOT</version>
    </dependency>
  </dependencies>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>${spring-cloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>

第四步:添加yml配置

spring:
 application:
  name: ribbon #服务器命名

server:
 port: 3001 # 设置服务器端口号

# 配置添加注册中心集群
eureka:
 client:
  service-url:
   defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

远程调用RestTemplate

RestTemplate 是SpringBoot提供的一个Rest远程调用工具。

类似于 HttpClient,可以发送 http 请求,并处理响应。RestTemplate简化了Rest API调用,只需要使用它的一个方法,就可以完成请求、响应、Json转换

方法:

  • getForObject(url, 转换的类型.class, 提交的参数)
  • postForObject(url, 协议体数据, 转换的类型.class)

RestTemplate 和 Dubbo 远程调用的区别:

RestTemplate:

http调用

效率低

Dubbo:

RPC调用,Java的序列化

效率高

第一步:创建RestTemplate实例

RestTemplate 是用来调用其他微服务的工具类,封装了远程调用代码,提供了一组用于远程调用的模板方法,例如: getForObject()postForObject()

package cn.tedu.sp06;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableDiscoveryClient
@SpringBootApplication
public class Sp06RibbonApplication {

  //创建 RestTemplate 实例,并存入 spring 容器
  @Bean
  public RestTemplate getRestTemplate() {
    return new RestTemplate();
  }

  public static void main(String[] args) {
    SpringApplication.run(Sp06RibbonApplication.class, args);
  }

}

第二步:创建RibbonController

package cn.tedu.sp06.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import cn.tedu.sp01.pojo.Item;
import cn.tedu.sp01.pojo.Order;
import cn.tedu.sp01.pojo.User;
import cn.tedu.web.util.JsonResult;

@RestController
public class RibbonController {
  @Autowired
  private RestTemplate rt;

  @GetMapping("/item-service/{orderId}")
  public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
    //向指定微服务地址发送 get 请求,并获得该服务的返回结果
    //{1} 占位符,用 orderId 填充
    return rt.getForObject("http://localhost:8001/{1}", JsonResult.class, orderId);
  }

  @PostMapping("/item-service/decreaseNumber")
  public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    //发送 post 请求
    return rt.postForObject("http://localhost:8001/decreaseNumber", items, JsonResult.class);
  }

  /

  @GetMapping("/user-service/{userId}")
  public JsonResult<User> getUser(@PathVariable Integer userId) {
    return rt.getForObject("http://localhost:8101/{1}", JsonResult.class, userId);
  }

  @GetMapping("/user-service/{userId}/score")
  public JsonResult addScore(
      @PathVariable Integer userId, Integer score) {
    return rt.getForObject("http://localhost:8101/{1}/score?score={2}", JsonResult.class, userId, score);
  }

  /

  @GetMapping("/order-service/{orderId}")
  public JsonResult<Order> getOrder(@PathVariable String orderId) {
    return rt.getForObject("http://localhost:8201/{1}", JsonResult.class, orderId);
  }

  @GetMapping("/order-service")
  public JsonResult addOrder() {
    return rt.getForObject("http://localhost:8201/", JsonResult.class);
  }
}

第三步:启动服务,进行测试

http://localhost:3001/item-service/35

等。。

ribbon负载均衡

第一步:RestTemplate设置@LoadBalanced

@LoadBalanced 负载均衡注解,会对 RestTemplate 实例进行封装,创建动态代理对象,并切入(AOP)负载均衡代码,把请求分发到集群中的服务器

package cn.tedu.sp06;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableDiscoveryClient
@SpringBootApplication
public class Sp06RibbonApplication {

  @LoadBalanced //负载均衡注解
  @Bean
  public RestTemplate getRestTemplate() {
    return new RestTemplate();
  }

  public static void main(String[] args) {
    SpringApplication.run(Sp06RibbonApplication.class, args);
  }
}

第二步:访问路径设置为id

package cn.tedu.sp06.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import cn.tedu.sp01.pojo.Item;
import cn.tedu.sp01.pojo.Order;
import cn.tedu.sp01.pojo.User;
import cn.tedu.web.util.JsonResult;

@RestController
public class RibbonController {
  @Autowired
  private RestTemplate rt;

  @GetMapping("/item-service/{orderId}")
  public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
    //这里服务器路径用 service-id 代替,ribbon 会向服务的多台集群服务器分发请求
    return rt.getForObject("http://item-service/{1}", JsonResult.class, orderId);
  }

  @PostMapping("/item-service/decreaseNumber")
  public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    return rt.postForObject("http://item-service/decreaseNumber", items, JsonResult.class);
  }

  /

  @GetMapping("/user-service/{userId}")
  public JsonResult<User> getUser(@PathVariable Integer userId) {
    return rt.getForObject("http://user-service/{1}", JsonResult.class, userId);
  }

  @GetMapping("/user-service/{userId}/score")
  public JsonResult addScore(
      @PathVariable Integer userId, Integer score) {
    return rt.getForObject("http://user-service/{1}/score?score={2}", JsonResult.class, userId, score);
  }

  /

  @GetMapping("/order-service/{orderId}")
  public JsonResult<Order> getOrder(@PathVariable String orderId) {
    return rt.getForObject("http://order-service/{1}", JsonResult.class, orderId);
  }

  @GetMapping("/order-service")
  public JsonResult addOrder() {
    return rt.getForObject("http://order-service/", JsonResult.class);
  }
}

第三步:访问测试,ribbon 会把请求分发到 8001 和 8002 两个服务端口上

http://localhost:3001/item-service/34 ribbon重试

第一步:添加spring-retry依赖

<dependency>
  <groupId>org.springframework.retry</groupId>
  <artifactId>spring-retry</artifactId>
</dependency>

第二步:application.yml 配置 ribbon 重试

# 06项目用来测试远程调用和ribbon工具
# 等功能测试完成后,直接删除
spring:
 application:
  name: ribbon
server:
 port: 3001
# 连接eureka,从eureka发现其他服务的地址
eureka:
 client:
  service-url:
   defaultZone: http://eureka1:2001/eureka,http://eureka2:2002/eureka
#配置ribbon 重试次数
ribbon:
 # 次数参数没有提示,并且会有黄色警告
 # 重试次数越少越好,一般建议用0,1
 MaxAutoRetries: 1
 MaxAutoRetriesNextServer: 2

第三步:设置 RestTemplate 的请求工厂的超时属性

package cn.tedu.sp06;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
@SpringBootApplication
public class Sp06RibbonApplication {
  public static void main(String[] args) {
   SpringApplication.run(Sp06RibbonApplication.class, args);
  }
  /**
 * 创建RestTemplate实例
 * 放入spring容器
 * @LoadBalanced-对RestTemplate进行增强,封装RestTemplate,添加负载均衡功能
 */
 @LoadBalanced
 @Bean public RestTemplate restTemplate(){
   //设置调用超时时间,超时后认为调用失败
 SimpleClientHttpRequestFactory f =
      new SimpleClientHttpRequestFactory();
   f.setConnectTimeout(1000);//建立连接等待时间
   f.setReadTimeout(1000);//连接建立后,发送请求后,等待接收响应的时间
 return new RestTemplate(f);
  }
}

第四步:ItemController 添加延迟代码

package cn.tedu.sp02.item.controller;
import java.util.List;
import java.util.Random;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import cn.tedu.sp01.pojo.Item;
import cn.tedu.sp01.service.ItemService;
import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@RestController
public class ItemController {
  @Autowired
 private ItemService itemService;
  //配置文件 application.yml中的server.port=8001注入到这个变量
 //是为了后面做负载均衡测试,可以直接看到调用的是那个服务器
 @Value("${server.port}")
  private int port;

  //获取订单的商品列表
 @GetMapping("/{orderId}")
  public JsonResult<List<Item>> getItems(@PathVariable String orderId) throws InterruptedException {
    log.info("server.port="+port+", orderId="+orderId);
    //模拟延迟代码
 if (Math.random()<0.9){
      long t = new Random().nextInt(5000);
      log.info("延迟:"+t);
      Thread.sleep(t);
    }
   List<Item> items = itemService.getItems(orderId);//根据订单id获取商品列表
 return JsonResult.ok(items).msg("port="+port);
  }

  //减少商品库存
 /**
 * @RequestBody 完整接收请求协议体中的数据
 * @param items
 * @return
 */ @PostMapping("/decreaseNumber")
  public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    for (Item item : items){
      log.info("减少商品库存:"+item );
    }
    itemService.decreaseNumbers(items);
    return JsonResult.ok();
  }
}

第五步:测试 ribbon 重试机制

通过 ribbon 访问 item-service,当超时,ribbon 会重试请求集群中其他服务器

http://localhost:3001/item-service/35

到此这篇关于深入学习Spring Cloud-Ribbon的文章就介绍到这了,更多相关Spring Cloud-Ribbon内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • springcloud中Ribbon和RestTemplate实现服务调用与负载均衡

    文件目录结构 文件目录结构很重要,特别注意的是rule文件要放在主启动类上一级位置,才能够扫描. 写pom <dependencies> <!--springboot 2.2.2--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependenc

  • 浅谈Spring Cloud Netflix-Ribbon灰度方案之Zuul网关灰度

    Eureka默认集成了Ribbon,所以Ribbon的灰度实现原理就是借助服务注册到Eureka中的eureka.instance.metadata-map的内容来进行匹配的. Zuul网关的灰度实现也是借助了一个Ribbon的插件来实现,相对比较简单. 项目环境说明:有两个eureka的服务端(eureka-server),有两个相同的后端服务(service-sms),有一个网关服务(cloud-zuul). 1.网关的依赖: <?xml version="1.0" enco

  • 浅谈SpringCloud之Ribbon详解

    一.什么是负载均衡 负载均衡:建立在现有网络结构之上,它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽.增加吞吐量.加强网络数据处理能力.提高网络的灵活性和可用性. 现在网站的架构已经从C/S模式转变为B/S模式,C/S模式是有一个专门的客户端,而B/S模式是将浏览器作为客户端.当用户在浏览器上输入一个网址按下回车键后,就会产生一个请求,在远方的服务器会处理这个请求,根据这个请求来生成用户想要的页面,然后将这个页面响应给浏览器,这样用户就能看到他想要看到的东西.我们知道,一台服务器处理数

  • 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的使用 官网

  • Spring Cloud Ribbon配置详解

    本节我们主要介绍 Ribbon 的一些常用配置和配置 Ribbon 的两种方式. 常用配置 1. 禁用 Eureka 当我们在 RestTemplate 上添加 @LoadBalanced 注解后,就可以用服务名称来调用接口了,当有多个服务的时候,还能做负载均衡. 这是因为 Eureka 中的服务信息已经被拉取到了客户端本地,如果我们不想和 Eureka 集成,可以通过下面的配置方法将其禁用. # 禁用 Eureka ribbon.eureka.enabled=false 当我们禁用了 Eure

  • Spring Cloud调用Ribbon的步骤

    一.简介 1. 是什么 Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具. 简单的说,Ribbon是Netflix发布的开源项目,主要功能是提供客户端的软件负载均衡算法和服务调用. 官方文档 目前已进入维护状态,以后可以通过Open Feign作为替代方案 负载均衡+RestTemplate,实现负载均衡调用 2. 负载均衡 负载均衡(Load Balance,LB),即将用户的请求平摊到多个服务上,从而达到系统的高可用(HA) 负载均衡分为

  • SpringCloud Netflix Ribbon源码解析(推荐)

    SpringCloud Netflix Ribbon源码解析 首先会介绍Ribbon 相关的配置和实例的初始化过程,然后讲解Ribbon 是如何与OpenFeign 集成的,接着讲解负载均衡器LoadBalancerCli ent , 最后依次讲解ILoadB alancer的实现和负载均衡策略Rule 的实现. 配置和实例初始化 @RibbonClient 注解可以声明Ribbon 客户端,设置Ribbon 客户端的名称和配置类,configuration 属性可以指定@Configurati

  • SpringCloud手写Ribbon实现负载均衡

    前言 前面我们学习了 SpringCloud整合Consul,在此基础上我们手写本地客户端实现类似Ribbon负载均衡的效果. 注: order 模块调用者 记得关闭 @LoadBalanced 注解. 我们这里只演示 注册中心 consul,至于 zookeeper 也是一模一样. 生产者 member模块 member 服务需要集群,所以我们copy application-consul.yml 文件命名为 application-consul2.yml 服务别名一致,只需要修改端口号即可.

  • 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 Ribbon 负载均衡通过服务器名无法连接的神坑

    一,问题 采取eureka集群.客户端通过Ribbon调用服务,Ribbon端报下列异常 java.net.UnknownHostException: SERVICE-HI java.lang.IllegalStateException: No instances available for SERVICE-HI java.lang.IllegalStateException: Request URI does not contain a valid hostname: http://SERVI

  • Springcloud ribbon负载均衡算法实现

    一 前言 经过几篇的cloud系列文章,我想大家都有一个坚实的基础,后续的学习就会轻松很多,如果是刚刚来看的读者需要有eureka基础知识,或者查阅知识追寻者的cloud系列专栏:这篇文章主要讲解如何使用ribbon实现web service客户端调用,ribbon默认算法实现负载均衡等! 二 ribbon简介 ribbon是一个客户端负载均衡器,其能够整合不同的协议工具进行web service API 调用: 主要特色如下: 提供可插拔式的负载均衡整合服务发现故障弹性恢复cloud支持客户端

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

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

随机推荐