SpringCloudNetfilxRibbon负载均衡工具使用方法介绍

SpringCloud Netfilx Ribbon Spring Cloud Netfilx Ribbon负载均衡 2022-12-12 09:12:24 394人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录一、介绍二、使用三、springWEB之RestTemplate基于Http协议的远程访问四、调用Application Service集群五、Ribbon负载均衡算法一、介绍

一、介绍

spring cloud Ribbon是一个基于HTTP和tcp的客户端负载均衡工具，它基于Netflix Ribbon实现。通过Spring Cloud的封装，可以让我们轻松地将面向服务的REST模版请求自动转换成客户端负载均衡的服务调用。Spring Cloud Ribbon虽然只是一个工具类框架，它不像服务注册中心、配置中心、api网关那样需要独立部署，但是它几乎存在于每一个Spring Cloud构建的微服务和基础设施中。因为微服务间的调用，API网关的请求转发等内容，实际上都是通过Ribbon来实现的，包括后续我们将要学习的OpenFeign，它也是基于Ribbon实现负载均衡的远程服务调用工具。所以，对Spring Cloud Ribbon的理解和使用，对于我们使用Spring Cloud来构建微服务非常重要.

二、使用

@Service
public class ApplicationClientServiceImpl implements ApplicationClientService {
    
    @Autowired
    private LoadBalancerClient loadBalancerClient;
    @Override
    public String client() {
        ServiceInstance si = loadBalancerClient.choose("application-service");
        // 获取Application Service IP。
        System.out.println(si.getHost());
        // 获取Ip及端口。
        System.out.println(si.getInstanceId());
        // 端口 
        System.out.println(si.getPort());
        // 应用程序名 application-service
        System.out.println(si.getServiceId());
        // URI http://Application Service IP:端口
        System.out.println(si.getUri().toString());
        return null;
    }
}

三、SpringWeb之RestTemplate基于Http协议的远程访问

要想使用RestRemplate必须自己配置

package com.bjsxt.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class MyConfig {
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

（1）控制器

@RestController
public class ServerController {
    @Value("${server.port}")
    private int port;
    
    @RequestMapping("/returnUsers")
    public List<User> returnUsers(int nums){
        List<User> result = new ArrayList<>();
        for(int i = 0; i < nums; i++){
            result.add(new User(100 + i, "姓名-" + i, 20+i));
        }
        return result;
    }
    
    @RequestMapping("/returnList")
    public List<String> returnList(int nums){
        List<String> result = new ArrayList<>();
        for(int i = 0; i < nums; i++){
            result.add("返回结果 - " + i);
        }
        return result;
    }
    
    @RequestMapping("/restfulParams/{name}/{age}")
    public String restfulParams(@PathVariable("name") String name,
                                @PathVariable int age){
        System.out.println("端口号: " + port + ", 任意请求方式，restful参数， name = " +
                name + " ; age = " + age);
        return "restful参数, name = " + name + " ; age = " + age;
    }
    
    @PostMapping("/postBodyParams")
    public String postBodyParams(@RequestBody Map<String, String> params){
        System.out.println("端口号: " + port + " , post请求，有请求体参数, params = " +
                params);
        return "post请求，请求体参数， params = " + params;
    }
    
    @PostMapping("/postWithParams")
    public String postWithParams(String name, int age){
        System.out.println("端口号: " + port + " , post请求，有参数, name = " +
                name + " ; age = " + age);
        return "post请求有参数 ： name = " +
                name + " ; age = " + age;
    }
    
    @PostMapping("/postNoParams")
    public String postNoParams(){
        System.out.println("端口号: " + port + " , post请求，没有参数");
        return "post请求，没有参数";
    }
    
    @GetMapping("/getWithParams")
    public String getWithParams(String name, int age){
        System.out.println("端口号: " + port + " 。 get请求，有参数， name = "
                    + name + " ; age = " + age);
        return "get请求，包含参数 : name = " + name + " ; age = " + age;
    }
    
    @GetMapping("/getNoParams")
    public String getNoParams(){
        System.out.println("端口号：" + port + "。 get请求，无参数。");
        return "get请求，无参数。";
    }
}

（2）无参数GET请求-getForObject

    
    @Test
    public void testGetNoParams(){
        // 定义要访问的地址是什么
        String url = baseUrl + "/getNoParams";
        // 发get请求。没有参数
        String result = restTemplate.getForObject(url, String.class);
        System.out.println("服务器返回：" + result);
    }

（3）有参数GET请求-getForObject

    
    @Test
    public void testGetWithParams(){
        String url = baseUrl + "/getWithParams?name={x}&age={y}";
        String result1 =
                restTemplate.getForObject(url, String.class,
                        "张三", "20");
        System.out.println("可变长数组传递参数，服务器返回：" + result1);
        System.out.println("==========================================");
        Map<String, Object> params = new HashMap<>();
        params.put("x", "李四");
        params.put("y", 25);
        String result2 =
                restTemplate.getForObject(url, String.class, params);
        System.out.println("Map集合传递参数，服务器返回：" + result2);
    }

（4）GET请求-getForEntity

    
    @Test
    public void testGetForEntity(){
        String url = baseUrl + "/getNoParams";
        ResponseEntity<String> entity =
                restTemplate.getForEntity(url, String.class);
        HttpHeaders headers = entity.getHeaders();
        for(String headerName : headers.keySet()){
            System.out.println("响应头： " + headerName + " = "
                    + headers.get(headerName));
        }
        System.out.println("响应状态码： " + entity.getStatusCodeValue());
        System.out.println("响应体数据： " + entity.getBody());
    }

（5）无参数POST请求

    
    @Test
    public void testPostNoParams(){
        String url = baseUrl + "/postNoParams";
        String result =
                restTemplate.postForObject(url, null, String.class);
        System.out.println("post请求，无参数，服务器返回：" + result);
    }

（6）post请求路径地址传递参数

    
    @Test
    public void testPostWithParamsPath(){
        String url = baseUrl + "/postWithParams?name={1}&age={2}";
        String result =
                restTemplate.postForObject(url, null, String.class,
                        "王五", 30);
        System.out.println(result);
    }

（7）post请求表单传递参数

    
    @Test
    public void testPostWithParamsFORM(){
        String url = baseUrl + "/postWithParams";
        // 创建请求体信息。
        // 请求头, 表单请求。  application/x-www-form-urlencoded
        HttpHeaders headers = new HttpHeaders();
        headers.add("content-type", "application/x-www-form-urlencoded");
        // 表单
        MultiValueMap<String, Object> form =
                new LinkedMultiValueMap<>();
        // add 提供一个 请求参数 名 = 值。
        form.add("name", "尼古拉斯.赵四");
        form.add("age", 40);
        // put 提供 键值对
        //form.put("name", Arrays.asList("尼古拉斯.赵四"));
        //List<Object> ages = new ArrayList<>();
        //ages.add(40);
        //form.put("age", ages);
        HttpEntity<MultiValueMap<String, Object>> entity = new HttpEntity<>(form, headers);
        String result =
                restTemplate.postForObject(url, entity, String.class);
        System.out.println(result);
    }

（8）post请求请求体传递参数

    
    @Test
    public void testPostBodyParams(){
        String url = baseUrl + "/postBodyParams";
        // 创建请求参数， 使用JSON格式的字符串，描述一个Map集合。
        String params = "{\"key1\":\"value1\", \"key2\":\"value2\"}";
        // 创建请求时，使用的请求体描述
        HttpHeaders headers = new HttpHeaders();
        headers.add("content-type", "application/json;charset=utf-8");
        HttpEntity<String> entity = new HttpEntity<>(params, headers);
        String result = restTemplate.postForObject(url, entity, String.class);
        System.out.println("返回结果：" + result);
    }
    @Test
    public void testPostBodyParams2(){
        // 可以使用简单的处理方案，实现请求体传递JSON格式的数据
        // 使用postForObject(),第二个参数，直接传递一个Java对象，作为请求体中传递的参数。
        // 参数没有名字，由RestTemplate做数据转换，默认使用JSON格式字符串做转换结果。
        String url = baseUrl + "/postBodyParams";
        // 创建Map类型的参数对象
        Map<String, String> params = new HashMap<>();
        params.put("name", "测试");
        params.put("gender", "男");
        // 请求服务器。 直接传递java对象，默认请求头content-type=application/json;charset=utf-8
        String result = restTemplate.postForObject(url, params, String.class);
        System.out.println("返回结果：" + result);
    }

（9）RestFUL传递参数

    
    @Test
    public void testRestfulParams(){
        String url = baseUrl + "/restfulParams/{name}/{age}";
        // 访问
        String result = restTemplate.getForObject(url, String.class, "restful", "15");
        System.out.println(result);
    }

（10）Exchange通用处理方案（处理相对复杂的结果类型例如自定义类型数组）

    
    @Test
    public void testExchangeMethod(){
        String url = baseUrl + "/returnList?nums={1}";
        // 相对复杂的返回结果类型描述对象
        url = baseUrl + "/returnUsers?nums={1}";
        ParameterizedTypeReference<List<User>> type =
                new ParameterizedTypeReference<List<User>>() {};
        // 访问远程
        ResponseEntity<List<User>> entity =
                restTemplate.exchange(url, HttpMethod.GET, null, type, 3);
        List<User> body = entity.getBody();
        System.out.println(body);
    }

四、调用Application Service集群

基于RestTemplate和Ribbon实现Application Client调用Application Service集群

（1）编写配置类

@Configuration
public class AppClientConfiguration {
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

（2）发起远程调用

@Service
public class ApplicationClientServiceImpl implements ApplicationClientService {
    @Autowired
    private RestTemplate restTemplate;
    //http://服务名
    private final String baseUrl = "http://eureka-client-app-service";
    @Override
    public String getNoParams() {
        String url = baseUrl + "/getNoParams";
        // 访问
        String result = restTemplate.getForObject(url, String.class);
        System.out.println(result);
        return result;
    }
}

五、Ribbon负载均衡算法

Ribbon的负载均衡策略是通过不同的类型来实现的（都是IRule接口的实现），下表详细介绍一些常用负载均衡策略及对应的Ribbon策略类。

编号	策略名称	策略对应的类名	实现原理
1	轮询策略（默认）	RoundRobinRule	轮询策略表示每次都按照顺序取下一个application service，比如一共有5个application service，第1次取第1个，第2次取第2个，第3次取第3个，以此类推
2	权重轮询策略（常用，中小型项目使用）	WeightedResponseTimeRule	1.根据每个application service的响应时间分配一个权重，响应时间越长，权重越小，被选中的可能性越低。 2.原理：一开始为轮询策略，并开启一个计时器，每30秒收集一次每个application service的平均响应时间，当信息足够时，给每个application service附上一个权重，并按权重随机选择application service，权重越高的application service会被高概率选中。
3	随机策略（不推荐，测试使用，开发使用）	RandomRule	从application service列表中随机选择一个
4	最少并发数策略（应用在硬件软件环境一致的情况下，中小型项目使用）	BestAvailableRule	选择正在请求中的并发数最小的application service，除非这个application service在熔断中。
5	重试策略。在“选定的负载均衡策略”基础上进行重试机制	RetryRule	1.“选定的负载均衡策略”这个策略是轮询策略RoundRobinRule 2.该重试策略先设定一个阈值时间段，如果在这个阈值时间段内当选择application service不成功，则一直尝试采用“选定的负载均衡策略：轮询策略”最后选择一个可用的application service
6	可用性敏感策略（一般在同区域内服务集群环境中使用）	AvailabilityFilteringRule	过滤性能差的application service,有2种：第一种：过滤掉在eureka中处于一直连接失败application service 第二种：过滤掉高并发的application service
7	区域敏感性策略（应用在大型的，物理隔离分布式环境中）	ZoneAvoidanceRule	1.以一个区域为单位考察可用性，对于不可用的区域整个丢弃，从剩下区域中选可用的application service 2.如果这个ip区域内有一个或多个实例不可达或响应变慢，都会降低该ip区域内其他ip被选中的权重。

指定负载均衡策略，新增Bean对象管理方法

    @Bean
    public IRule iRule(){
        return new RandomRule();
    }

到此这篇关于SpringCloud Netfilx Ribbon负载均衡工具使用方法介绍的文章就介绍到这了,更多相关SprinGCloud Netfilx Ribbon内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: SpringCloudNetfilxRibbon负载均衡工具使用方法介绍

本文链接: https://www.lsjlt.com/news/174787.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

SpringCloudNetfilxRibbon负载均衡工具使用方法介绍

目录一、介绍二、使用三、SpringWeb之RestTemplate基于Http协议的远程访问四、调用Application Service集群五、Ribbon负载均衡算法一、介绍 ...

99+

2022-12-12

SpringCloud Netfilx Ribbon Spring Cloud Netfilx Ribbon负载均衡
SpringCloudRibbon负载均衡工具使用

目录Spring Cloud Ribbon实操Spring Cloud Ribbon 是一个基于HTTP和TCP的客户端负载均衡工具实操创建两个provider，并且编写两个一样...

99+

2023-02-06

SpringCloud Ribbon SpringCloud Ribbon负载均衡 SpringCloud负载均衡
Ribbon负载均衡算法原理与使用介绍

负载均衡算法：rest接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标，每次服务重启动后rest接口计数从1开始。 List<ServiceInstance...

99+

2024-04-02
Dubbo负载均衡策略介绍

目录1、负载均衡基本配置2、自定义负载均衡器1、负载均衡基本配置负载均衡（Load Balance）, 其实就是将请求分摊到多个操作单元上进行执行，从而共同完成工作任务。负载均衡...

99+

2024-04-02
关于Apache负载均衡介绍

Apache负载均衡（Apache Load Balancer）是一种在多台服务器之间分配工作负载的技术。它通过将客户端请求分发到多...

99+

2023-09-23

Apache
Mycat的负载均衡类型介绍

事务内的SQL，默认走写节点，以注释开头，则会根据balance=“1”或“2”去获取 b. 非事务内的SQL，开启读写分离默认根据balance=“1”或“2”去获取，以注释开头则会走写解决部分已经开启读...

99+

2024-04-02
负载均衡常用的工具有哪些

负载均衡常用的工具有：1、DNS轮循，能够将相同的域名解释到不同的IP中；2、F5 BIG-IP，它是一个著名硬件负载均衡交换机；3、LVS，软件四层交换，它是在Linux内核中作四层交换；4、L7SW，软件七层交换，它是一款类似LVS的新...

99+

2024-04-02
负载均衡的实现方法

这篇文章主要讲解了“负载均衡的实现方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“负载均衡的实现方法”吧！客户端发送多个请求到服务器，服务器...

99+

2023-06-20
JavaWeb 使用nginx负载均衡

要使用nginx负载均衡JavaWeb应用程序，可以按照以下步骤进行操作：1. 安装和配置nginx：首先，需要在服务器上安装ngi...

99+

2023-09-21

JavaWeb
dnspod 负载均衡的设置方法

这篇文章主要介绍“dnspod 负载均衡的设置方法”，在日常操作中，相信很多人在dnspod 负载均衡的设置方法问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”dnspod 负载均衡的设置方法”的疑惑有所帮助！...

99+

2023-06-12
Centos实现负载均衡的方法

这篇文章主要讲解了“Centos实现负载均衡的方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Centos实现负载均衡的方法”吧！为了提高系统的高可用性，我们可以将两个或多个网卡进行绑定，...

99+

2023-06-10
Nginx之负载均衡upstream模块简介和使用

一、upstream模块简介 Nginx的负载均衡功能依赖于ngx_http_upsteam_module模块，所支持的代理方式包括proxy_pass, fastcgi_pass, uwsgi_pa...

99+

2023-09-07

android 前端后端
负载均衡的原理及使用方法是什么

负载均衡是一种用于分配网络请求负载的技术，它通过将网络请求分配给多个后端服务器来提高系统的性能、可靠性和可扩展性。负载均衡的原理是基...

99+

2023-09-01

负载均衡
Nginx配置Tcp负载均衡的方法

本文使用Nginx作为代理服务器，用来做负载均衡。只是一个简单的应用示例，并不涉及原理。（这里主机有限，42.192.22.128主机8000端口用来做代理服务器监听端口，818...

99+

2024-04-02
.NET中负载均衡怎么使用

本篇内容介绍了“.NET中负载均衡怎么使用”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！一、简介负载均衡（Load Balance），简称 ...

99+

2023-07-02
Nginx负载均衡之upstream模块简介与使用详解

目录一、upstream模块简介二、负载均衡算法简介1、轮询2、权重轮询3、IP哈希4、最小连接数5、最短响应时间6、url_hash算法三、配置示例四、负载均衡效果展示1、部署2个...

99+

2024-04-02
负载均衡集群的session处理方法

本篇内容主要讲解“负载均衡集群的session处理方法”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“负载均衡集群的session处理方法”吧!通常面临的问题从用户端来解释，就是当一个用户第一次访...

99+

2023-06-27
负载均衡算法Round Robin是如何工作的

Round Robin负载均衡算法是一种简单而常用的算法。它将所有的请求依次分配给每个服务器，直到所有的服务器都被轮询到一次，然后再...

99+

2024-04-17

负载均衡
MySQL实现负载均衡功能的方法

小编给大家分享一下MySQL实现负载均衡功能的方法，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！前言MySQL是一个高速度、高性能、多线程、开放源代码，建立在客户/服务器(Client/S...

99+

2024-04-02
使用Docker和Nginx进行负载均衡

要使用Docker和Nginx进行负载均衡，可以按照以下步骤操作：创建一个Nginx配置文件，用于配置负载均衡器。例如，创建一个...

99+

2024-04-25

Docker