一、Ribbon负载均衡服务调用

1. 概述

1.1 是什么

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

1.2 LB负载均衡（Load Balance)是什么

简单的说就是将用户的请求平摊的分到多个服务上，从而达到系统的HA（高可用）。
常见的负载均衡有软件Nginx，LVS，硬件F5等。

集中式LB：即在服务的消费方和提供方之间使用独立的LB设施（可以是硬件如F5，也可以是软件如nginx），由该设施负责把访问请求通过某种策略转发给服务的提供方
进程内LB：将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择一个合适的服务器。Ribbon就属于进程内LB，他只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

1.3 Ribbon本地负载均衡客户端 VS Nginx服务端负载均衡区别

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

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

2. 服务调用示例

使用cloud-consumer-order80调用两个服务提供者cloud-provider-payment8001和cloud-provider-payment8002
可以看到三个服务均已注册到eureka中

对于服务消费者cloud-consumer-order80，需要添加一些操作来调用其他服务。
首先，由于之前添加过spring-cloud-starter-netflix-eureka-client依赖，会包含ribbon的依赖，所以不需要再引入

1. Configuration：加入配置类
由于ribbon使用RestTemplate进行远程调用，所以需要对其进行配置。配置注入 RestTemplate 的 Bean，并通过 @LoadBalanced 注解表明开启负载均衡功能

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

测试

在消费者的controller里使用restTemplate远程调用其他服务的接口，由于开启了分布式服务的负载均衡，所以请求的是服务名，ribbon会选择合适的server。

@RestController
public class OrderController {

    @Autowired
    private RestTemplate restTemplate;

    private final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

    @GetMapping("/order/payment/get/{id}")
    public CommonResult get(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    }

    @PostMapping("/order/payment/save")
    public CommonResult save(@RequestBody Payment payment) {
        return restTemplate.postForObject(PAYMENT_URL + "/payment/save", payment, CommonResult.class);
    }
}

效果

调用消费者的接口，消费者再去调用服务提供者的接口，为了测试负载均衡效果，在服务提供者的controller里返回端口值，多次调用，发现8001和8002交替出现，使用的是轮询的策略

3. RestTemplate

官网： https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html

3.1 getForObject() 和 getForEntity()

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


------------------ getForObject() --------------------------------------
@GetMapping(/consumer/get/payment/{id})
public CommonResult<Payment> get Payment(@PathVariable("id") Long id){
    String url = "http://localhost:8001/get/payment/" + id;

    // 返回对象为响应体中数据转化成的对象，基本上可以理解为JSON
    return restTemplate.getForObject(url,CommonResult.class);
}

------------------ getForEntity() --------------------------------------
@GetMapping("/consumer/get/payment/{id}")
public CommonResult<Payment> get Payment(@PathVariable("id") Long id){
    String url = "http://localhost:8001/get/payment/" + id;

    // 返回对象为ResponseEntity对象，包含了响应中的一些重要信息，比如响应头，响应状态码，响应体等。
    ResponseEntity<CommonResult> responseEntity = restTemplate.getForEntity(url,CommontResult.class);
    // 判断是否成功
    if(responseEntity,getStatusCode.is2xxSuccessful()){
        return responseEntity.getBody();
    }else{
        return new CommonResult(444,"操作失败");
    }
}

3.2 postForObject() 和 postForEntity()

@PostMapping("/consumer/create/payment")
public CommonResult<Payment> create(@RequestBody Payment payment){
    String url = "http://localhost:8001/create/payment";
    // postForObject() 可以直接return回去
    return restTemplate.postForObject(url,payment,CommonResult.class);
    // postForEntity() 需要调用getBody() 在返回
    return restTemplate.postForEntity(url,payment,CommonResult.class).getBody;
}

4. Ribbon核心组件IRule

4.1 负载均衡规则

根据特定算法从服务列表中选取一个要访问的服务

官方提供了以下实现类实现负载规则，也可以自定义实现类进行替换：

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

4.2 替换负载均衡规则

修改消费者服务 consumer：

增加配置类

注意这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包 否则我们自定义的这个配置类旧会被所有的Ribbon客户端所共享，达不到特殊化定制的目的了。

主启动类：com.nic.springcloud.主启动类
负载均衡算法包：com.nic.myRule 在主启动类上一层，就不会被扫描到

@Configuration
public class MySelfRule {
    @Bean
    public IRule iRule(){
        // 随机算法
        return new RandomRule();
    }
}

主启动类

消费者的主启动类
**@RibbonClient(configuration = MySelfRule.class)**

@EnableEurekaClient
@SpringBootApplication
// name 写要负载均衡访问的provider的微服务名字
@RibbonClient(name = "cloud-payment-service",configuration = MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}

5、Ribbon负载均衡算法

5.1 原理

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

List<ServiceInstance> instances = doscoveryClient.getInstances("cloud-payment-service");
List[0] 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 = 0，对应下标为 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
如此类推

5.2 手写规则

8001和8002服务提供者，添加接口返回port

@RequestMapping("/get/lb")
public String getLBid(){
 return port;
}

80消费者RestTemplate去掉@LoadBalanced，不使用自带的负载均衡算法
80消费者创建负载均衡实现接口 ```java package me.nic.cloud.lb;

public interface LoadBalancer { //收集服务器总共有多少台能够提供服务的机器，并放到list里面 ServiceInstance instances(List serviceInstances); }


4. 80消费者创建接口实现类
```java
package me.nic.cloud.lb;

@Component
public class MyLB implements LoadBalancer {

    private AtomicInteger atomicInteger = new AtomicInteger(0);

    /**
     * 获取请求次数
     *
     * @return
     */
    private final int getAndIncrement() {
        int current;
        int next;
        do {
            // 当前请求次数
            current = this.atomicInteger.get();
            // 请求次数加1
            next = current >= 2147483647 ? 0 : current + 1;
            // 多线程并发访问，自旋修改
        } while (!this.atomicInteger.compareAndSet(current, next));  //第一个参数是期望值，第二个参数是修改值是
        System.out.println("*******第几次访问，次数next: " + next);
        return next;
    }

    /**
     * 计算获取机器实例
     *
     * @param serviceInstances
     * @return
     */
    @Override
    public ServiceInstance instances(List<ServiceInstance> serviceInstances) {
        // 得到服务器的下标位置
        // 请求次数与实例数取余
        int index = getAndIncrement() % serviceInstances.size();
        return serviceInstances.get(index);
    }
}

80消费者OrderController

@RestController
public class OrderController {
 @Autowired
 private RestTemplate restTemplate;
 @Autowired
 private DiscoveryClient discoveryClient;
 @Autowired
 private LoadBalancer loadBalancer;

 @GetMapping(value = "/consumer/payment/lb")
 public String getPaymentLB(){
     List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
     if (instances == null || instances.size() <= 0){
         return null;
     }
     ServiceInstance serviceInstance = loadBalancer.instances(instances);
     URI uri = serviceInstance.getUri();
     return restTemplate.getForObject(uri+"/get/lb",String.class);
 }
}

测试

http://localhost/order/payment/lb，可以看到服务提供者8001和8002交替返回结果

二、OpenFeign服务接口调用

1. 概述

1.1 OpenFeign是什么

https://github.com/spring-cloud/spring-cloud-openfeign
Feign是一个声明式WebService客户端，使用Feign能让编写Web Service客户端更加简单，只需要创建一个接口并添加注解即可
他的使用方法是定义一个服务接口然后在上面添加注解，Feign也支持可插拔式的编码器和解码器。Spring Cloud 对Feign进行了封装。使其支持了SpringMVC 标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。

1.2 Feign作用

Feign旨在使编写Java Http客户端变得更加容易。

个人理解：声明式远程方法调用

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

1.3 Feign集成了Ribbon

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

2. OpenFeign使用步骤

Feign 是使用在消费端！

创建cloud-consumer-openfeign-order80 模块

写pom

<!-- OpenFeign 依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

总体pom

<!--openfeign-->
<dependencies>
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
  <groupId>me.nic.cloud</groupId>
  <artifactId>cloud-api-common</artifactId>
  <version>${project.version}</version>
</dependency>
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-devtools</artifactId>
 <scope>runtime</scope>
 <optional>true</optional>
</dependency>

<dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
</dependency>
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
</dependency>
</dependencies>

写yaml ```yaml server: port: 80

eureka: client: register-with-eureka: true fetch-registry: true service-url: defaultZone: http://eureka7001.com:7001/eureka, http://eureka7002.com:7002/eureka

spring: application: name: cloud-feign-consumer


4. **主启动类**

主启动类上添加 `@EableFeignClients`注解
```java
@SpringBootApplication
@EnableFeignClients  // 启用Feign功能
public class OpenFeignMainOrder80 {
    public static void main(String[] args) {
        SpringApplication.run(OpenFeignMainOrder80.class,args);
    }
}

业务类

声明一个远程调用服务接口，这个接口可以在 commons 模块中如果是在一个别的模块中，那么这个远程调用服务接口所在的包结构，必须要能被Springboot扫描到

声明远程调用服务接口
@FeignClient("provider微服务名字")
注意：

这里声明的方法签名，必须和provider服务中的controller中方法的签命一致
如果需要传递参数，那么@RequestParam 和@RequestBody @PathVariable 不能省必加 ```java @Component @FeignClient(“CLOUD-PAYMENT-SERVICE”) public interface RemotePaymentService {

@GetMapping(“/payment/get/{id}”) CommonResult get(@PathVariable(“id”) Long id);

}

consumer的controller<br />直接注入这个 RemotePaymentService 接口对象
```java
@RestController
public class FeignController {

    @Autowired
    private RemotePaymentService remotePaymentService;

    @GetMapping("/consumer/get/payment/{id}")
    public CommonResult<Payment> get(@PathVariable("id") Long id){
        CommonResult<Payment> paymentById = remotePaymentService.get(id);
        return paymentById;
    }
}

provider的controller

这里声明的方法要和远程调用服务接口中的方法签名保持一致

@Slf4j
@RestController
public class PaymentController {
    @GetMapping("/payment/get/{id}")
    public CommonResult<Payment> get(@PathVariable("id") Long id) {
        Payment paymentById = paymentService.getPaymentById(id);
        return new CommonResult<>(200, "查询成功 server port:" + serverPort, paymentById);
    }
}

3. OpenFeign超时控制

3.1 超时情况

故意设置超时演示出错情况

服务提供方8001故意写暂停程序

@RequestMapping("/get/feign/time/out")
public String timeOut() throws InterruptedException {
 Thread.sleep(3000);

 return port;
}

远程调用服务接口

@Component
@FeignClient("CLOUD-PAYMENT-SERVICE")
public interface RemotePaymentService {

 @RequestMapping("/get/feign/time/out")
 public String timeOut() throws InterruptedException;
}

消费方接口

@RequestMapping("/consumer/get/feign/time/out")
public String timeOut() throws InterruptedException{

 String s = remotePaymentService.timeOut();
 return s;
}

页面报错

3.2 超时设置

OpenFeign默认等待时间为1秒钟，超过后报错
默认Feign客户端只等待一秒钟，但是服务段处理需要超过1秒钟，导致Feign客户端不想等待了，直接返回报错。
为了避免这种请况，有时候我们需要设置Feign客户端的超时控制

Feign 默认是支持Ribbon ，Feign依赖里自己带了Ribbon

解决问题
在消费端的配置文件中配置

这里的ReadTimeout 和 ConnectTimeout 没有代码提示，但可以使用

# 设置feign 客户端超时时间(OpenFeign默认支持ribbon)
ribbon:
  # 设置建立连接后从服务器读取到可用资源所用的时间
  ReadTimeout: 5000
  # 设置建立连接所用的时间,适用于网络状况正常的情况下,两端连接所用的时间
  ConnectTimeout: 5000

4. OpenFeign日志打印功能

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

4.1 日志级别

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

4.2 配置日志

配置在消费端

配置日志bean

@Configuration
public class FeignConfig {
 @Bean
 Logger.Level feignLoggerLevel(){
     return Logger.Level.FULL;
 }
}

配置消费端的yaml文件

logging:
level:
 # feign 日志以什么级别监控哪个接口
 me.nic.cloud.service.RemotePaymentService: debug

查看后台日志