SpringCloud(三)学习笔记之Ribbon

spring Cloud Ribbon 是一个客户端的负载均衡器，它提供对大量的HTTP和TCP客户端的访问控制。

客户端负载均衡即是当浏览器向后台发出请求的时候，客户端会向 Eureka Server 读取注册到服务器的可用服务信息列表，然后根据设定的负载均衡策略（没有设置即用默认的），抉择出向哪台服务器发送请求

Eureka默认支持Ribbon 则不需要引入Ribbon 的依赖，后面会介绍单独使用ribbon的案例

一、构建Eureka Server

【基于第二章节创建的Eureka Server】

二、构建Eureka Client提供者集群项目

mhb-cloud-producer 【服务提供者1】

mhb-cloud-producer-extend【服务提供者2】

当两个项目的spring.application.name和eureka.instance.appname相同时，组成一个微服务集群

1：pom文件

加入Eureka Client依赖

mhb-cloud-producer、mhb-cloud-producer-extend

<!--eureka客户端环境支持-->

<dependency>

	<groupId>org.springframework.cloud</groupId>

	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

</dependency>

2：application.yml文件

mhb-cloud-producer 和 mhb-cloud-producer-extend 只有端口不同，其他一致

mhb-cloud-producer：端口 9904

mhb-cloud-producer-extend：端口9905

debug: false #关闭debug模式

spring:

  application:

    name: mhb-cloud-producer #应用的名称

server:

  port: 9904 #应用的端口号

eureka:

  instance:

    appname: producer #eureka application的名称

    prefer-ip-address: true #开启ip显示eureka的主机服务

    #eureka仪表盘的Instances格式

    instance-id: ${spring.application.name}:${spring.cloud.client.ipAddress}:${server.port}

  client:

    service-url:

     #eureka服务开启了认证，要加上用户名和密码

     defaultZone: http://admin:123456@localhost:8761/eureka/

    #从eureka服务器注册表中获取注册表信息的时间间隔，默认30s

    registry-fetch-interval-seconds: 30

    #客户端发送变化同步到eureka服务器的时间间隔 默认30s

    instance-info-replication-interval-seconds: 30

    #询问eureka服务url信息的变化的间隔时间 默认300s

    eureka-service-url-poll-interval-seconds: 300

    #最初同步到eureka服务器的时间 默认40s

    initial-instance-info-replication-interval-seconds: 40

    #注册表是否压缩

    g-zip-content: true

    #eureka等待超时时间 默认是5s

    eureka-server-connect-timeout-seconds: 5

    #eureka等待读取时间 默认是8s

    eureka-server-read-timeout-seconds: 8

    #eureka客户端允许的所有eureka服务器连接的总数 默认200

    eureka-server-total-connections: 200

    #eureka客户端允许的所有eureka服务器主机连接的总数 默认50

    eureka-server-total-connections-per-host: 50

    #心跳执行程序线程池的大小 默认是5

    heartbeat-executor-thread-pool-size: 5

    #心跳重试延迟的最大倍数值 默认是10

    heartbeat-executor-exponential-back-off-bound: 10

    #执行程序缓存刷新线程池的大小 默认是5

    cache-refresh-executor-thread-pool-size: 5

    #执行程序缓存刷新重试延迟的最大倍数值 默认是10

    cache-refresh-executor-exponential-back-off-bound: 10

3：启动类注解

mhb-cloud-producer、mhb-cloud-producer-extend

EnableEurekaClient/*eureka客户端注解*/

4：构建测试controller

mhb-cloud-producer、mhb-cloud-producer-extend

com\applesnt\controller\ProducerController.java

访问路径：http://localhost:端口/producer/get/123

/*类访问路径*/

@RequestMapping("/producer")

/*返回传递过来的id

* 请求路径：http://localhost:端口/producer/get/123

* */

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

public String getId(@PathVariable("id") String id){

    System.out.println("-----"+id);

    return "我是提供者 端口是9904 传递的参数= "+id;

}

三、构建Eureka Client消费者项目

mhb-cloud-consumer ：端口 8802

1：pom文件

Eureka 中已经自带Ribbon支持，所以不用单独引入Ribbon依赖

<!--eureka客户端环境支持-->

<dependency>

	<groupId>org.springframework.cloud</groupId>

	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

</dependency>

2：application.yml文件

包含Ribbon的属性配置

debug: false

spring:

  application:

    name: mhb-cloud-consumer #每一个微服务必须有这个应用名称

server:

  port: 8802 #端口

eureka:

  instance:

    appname: consumer #eureka application的名称

    prefer-ip-address: true #开启ip显示eureka的主机服务

    #eureka仪表盘的Instances格式

    instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${server.port}

  client:

    service-url:

     defaultZone: http://admin:123456@eureka1.com:8762/eureka/,http://admin:123456@eureka2.com:8762/eureka/,http://admin:123456@eureka3.com:8763/eureka/

    #从eureka服务器注册表中获取注册表信息的时间间隔，默认30s

    registry-fetch-interval-seconds: 30

    #客户端发送变化同步到eureka服务器的时间间隔 默认30s

    instance-info-replication-interval-seconds: 30

    #询问eureka服务url信息的变化的间隔时间 默认300s

    eureka-service-url-poll-interval-seconds: 300

    #最初同步到eureka服务器的时间 默认40s

    initial-instance-info-replication-interval-seconds: 40

    #注册表是否压缩

    g-zip-content: true

    #eureka等待超时时间 默认是5s

    eureka-server-connect-timeout-seconds: 5

    #eureka等待读取时间 默认是8s

    eureka-server-read-timeout-seconds: 8

    #eureka客户端允许的所有eureka服务器连接的总数 默认200

    eureka-server-total-connections: 200

#ribbon预加载

ribbon:

  eager-load:

    enabled: true #预加载 服务器启动的时候就加载服务列表 建议开启

    clients: mhb-cloud-producer #预加载哪个微服务  多个话用逗号隔开

#ribbon需要负载均衡的服务属性配置

mhb-cloud-producer: #配置的哪个实例

  ribbon:

    # 代表Ribbon使用的负载均衡策略(轮询)

    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule

    # 每台服务器最多重试次数，但是首次调用不包括在内

    MaxAutoRetries: 1

    # 最多重试多少台服务器

    MaxAutoRetriesNextServer: 1

    # 无论是请求超时或者socket read timeout都进行重试

    OkToRetryOnAllOperations: true

    # 服务列表的更新频率 毫秒

    ServerListRefreshInterval: 2000

    # 连接超时时间

    ConnectTimeout: 3000

    # 读取超时时间

    ReadTimeout: 3000

Ribbon负载均衡策略包括：

[1]BestAvailableRule：选择一个最小的并发请求的server:

[2]AvailabilityFilteringRule：过滤掉那些因为一直连接失败的被标记为circuittripped的后端server，并过滤掉那些高并发的的后端server

[3]WeightedResponseTimeRule：根据响应时间分配一个weight，响应时间越长，weight越小，被选中的可能性越低。

[4]RetryRule：对选定的负载均衡策略机上重试机制

[5]RoundRobinRule：roundRobin方式轮询选择server

[6]RandomRule：随机选择一个server

[7]ZoneAvoidanceRule：复合判断server所在区域的性能和server的可用性选择server

3：启动类配置RestTemplate

@@EnableEurekaClient

balanceRestTemplate：是带负载均衡的RestTemplate

noBalanceRestTemplate：是不带负载均衡的RestTemplate

package com.applesnt;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

import org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration;

import org.springframework.cloud.netflix.ribbon.RibbonClients;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Primary;

import org.springframework.web.client.RestTemplate;

@SpringBootApplication

@EnableEurekaClient

public class MhbCloudConsumerApplication {

	public static void main(String[] args) {

		SpringApplication.run(MhbCloudConsumerApplication.class, args);

	}

	@Bean

	@LoadBalanced/*微服务通讯时需要负载均衡 相同的spring.applincatin.name*/

	public RestTemplate balanceRestTemplate(){

		return new RestTemplate();

	}

	@Primary

	@Bean/*微服务通讯时不需要负载均衡*/

	public RestTemplate noBalanceRestTemplate(){

		return new RestTemplate();

	}

}

4：编写消费者远程调用controller

com\applesnt\controller\RibbonConsumerController.java

注入使用负载均衡和不使用负载均衡的RestTemplate，用@Qualifier来加以区分引入的对象

如果不使用负载均衡的RestTemplate，支持http://localhost:9904这种请求格式，不支持http://mhb-cloud-producer这种请求格式

如果使用负载均衡的RestTemplate, 支持http://mhb-cloud-producer这种请求格式，不支持http://localhost:9904这种请求格式

访问路径：http://localhost:8802/ribbon/get/123

package com.applesnt.controller;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import org.springframework.web.client.RestTemplate;

@RestController

@RequestMapping("/ribbon")

@Slf4j

public class RibbonConsumerController {

    /*注入 RestTemplate  在启动类中已初始化 不使用负载均衡*/

    @Autowired

    @Qualifier("noBalanceRestTemplate")

    private RestTemplate noBalanceRestTemplate;

    /*注入 RestTemplate  在启动类中已初始化 使用负载均衡*/

    @Autowired

    @Qualifier("balanceRestTemplate")

    private RestTemplate balanceRestTemplate;

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

    public String old(@PathVariable("id") String id){

        /*

        * 如果不使用负载均衡的RestTemplate，支持http://localhost:9904这种请求格式

        * 如果使用负载均衡的RestTemplate 则不支持http://localhost:9904这种请求格式

        * */

        String result="";

        /*正确输出*/

        result = noBalanceRestTemplate.getForObject("http://localhost:9904/producer/get/"+id,String.class);

        log.info("不使用负载均衡noBalanceRestTemplate==result:"+result);

        result = balanceRestTemplate.getForObject("http://mhb-cloud-producer/producer/get/"+id,String.class);

        log.info("使用负载均衡-url为微服务的balanceRestTemplate==result:"+result);

        return  result;

    }

}

5：服务启动

分别启动eureka服务集群、mhb-cloud-producer、mhb-cloud-producer-extend、mhb-cloud-consumer六个服务

http://eureka1.com:8761/

6：Ribbon负载测试

Ribbon使用的是轮询方式

访问路径：http://localhost:8802/ribbon/get/123

第一次访问结果：

第二次访问结果：

四、LoadBalancerClient对象

/*ribbon 注入操作对象*/

@Autowired

private LoadBalancerClient loadBalancerClient;

@GetMapping("/get/lbc/{id}")

public void ribbon(@PathVariable("id") String id){

    /*负载均衡得到当前连接的是集群中的哪一个微服务*/

    ServiceInstance instance = loadBalancerClient.choose("mhb-cloud-producer");

    log.info("ServiceId="+instance.getServiceId()+"  url="+instance.getUri()+" 端口="+instance.getPort());

    try {

        /*根据负载均衡后的服务构建url路径*/

        URI uri1 = loadBalancerClient.reconstructURI(instance,new URI(""));

        log.info("uri1="+uri1);

        /*构建url路径 默认是http*/

        URI uri2 = loadBalancerClient.reconstructURI(instance,new URI("/producer/get/"+id));

        log.info("uri2="+uri2);

        /*构建https url路径*/

        URI uri3 = loadBalancerClient.reconstructURI(instance,new URI("https:/producer/get/"+id));

        log.info("uri3="+uri3);

    }catch (Exception e){

    }

}

五：Ribbon脱离Eureka的使用

Eureka之外的服务调用比如第三方

mhb-cloud-consumer-ribbon【端口：8803】

1：pom文件【不在引入eureka的依赖】

<!--引入ribbon的依赖-->

<dependency>

	<groupId>org.springframework.cloud</groupId>

	<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>

</dependency>

2：application.yml文件

debug: false

spring:

  application:

    name: mhb-cloud-consumer-ribbon #每一个微服务必须有这个应用名称

server:

  port: 8803 #端口

mhb-cloud-producer: #配置的哪个实例

  ribbon:

    listOfServers: 127.0.0.1:9904,127.0.0.1:9905

    # 代表Ribbon使用的负载均衡策略

    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule

3：启动类：【不在使用@EnableEurekaClient注解】

package com.applesnt;

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.web.client.RestTemplate;

@SpringBootApplication

public class MhbCloudConsumerRibbonApplication {

	public static void main(String[] args) {

		SpringApplication.run(MhbCloudConsumerRibbonApplication.class, args);

	}

	@Bean

	@LoadBalanced/*微服务通讯时需要负载均衡 相同的spring.applincatin.name*/

	public RestTemplate balanceRestTemplate(){

		return new RestTemplate();

	}

}

4：业务测试类：

com\applesnt\controller\RibbonConsumerController.java

package com.applesnt.controller;

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.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import org.springframework.web.client.RestTemplate;

/**

 * @author: menghaibin

 * @create: 2020-03-08 20:15

 * @description: Ribbon消费者控制层

 **/

@RestController

@RequestMapping("/ribbon")

public class RibbonConsumerController {

    /*注入 RestTemplate  在启动类中已初始化 使用负载均衡*/

    @Autowired

    private RestTemplate balanceRestTemplate;

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

    public String old(@PathVariable("id") String id){

        String result = null;

        /*获取配置文件中mhb-cloud-producer的服务列表*/

        result = balanceRestTemplate.getForObject("http://mhb-cloud-producer/producer/get/"+id,String.class);

        return  result;

    }

}

测试：

http://127.0.0.1:8803/ribbon/get/123

第一次访问：

第二次访问：