[Java知识库]【Java】SpringCloud:Eureka、Ribbon、OpenFeign、Hystrix

SpringCloud

概述

1. Spring Cloud是一系列框架的有序集合。
2. Spring Cloud的本质是在 Spring Boot 的基础上，增加了一堆微服务相关的规范，并对应用上下文 （Application Context ）进行了功能增强。
3. 它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。

注意

微服务之间传递参数时 @RequestBody @PathVariable 不能省略！

spring:
  application:
    name: eureka  #微服务项目的名字，会在注册中心中出现

RestTempalte

代码：

消费者代码：

package com.sms.controller;

import com.sms.entity.RespEntity;
import com.sms.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * @Author songmingsong
 * @Version V1.0.0
 * @Date 2022-09-23 17:44
 */
@RestController
@RequestMapping("/conStudent")
public class StudentController {
    @Autowired
    RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;


    /**
     * eureka 获取实例地址方法
     * 
     * @return
     */
    public String serviceUri() {
        // provider-student 服务提供者
        List<ServiceInstance> serviceInstances = discoveryClient.getInstances("provider-student");
        if (serviceInstances != null && serviceInstances.size() > 0) {
            return serviceInstances.get(0).getUri() + "/student/";
        }
        return null;
    }


    @GetMapping("/{id}")
    public RespEntity getStuInfo(@PathVariable("id") Integer id) {
        System.out.println("获取一个学生信息");
        //远程调用
        return restTemplate.getForObject(serviceUri() + id,
                RespEntity.class);
    }

    @GetMapping("/")
    public RespEntity getAllStudent() {
        System.out.println("获取所有学生信息");
        //远程调用
        return restTemplate.getForObject(serviceUri(),
                RespEntity.class);
    }

    @PostMapping("/")
    public RespEntity addStudent(@RequestBody Student student) {
        System.out.println("添加学生");
        System.out.println(student);
        return restTemplate.postForObject(serviceUri(), student, RespEntity.class);
    }
}

提供者代码：

package com.sms.controller;

import com.sms.entity.RespEntity;
import com.sms.entity.Student;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;

/**
 * @Author songmingsong
 * @Version V1.0.0
 * @Date 2022-09-23 17:31
 */
@RestController
@RequestMapping("/student")
public class StudentController {
    @Value("${server.port}")
    private Integer port;

    @GetMapping("/{id}")
    public RespEntity getStudent(@PathVariable("id") Integer id) {
        if (id == 1) {
            return new RespEntity(1, "ok"+port, new Student(1, "test1", 12));
        }
        return new RespEntity(2, "ok"+port, new Student(2, "test2", 11));
    }

    @GetMapping("/")
    public RespEntity getAllStudent() {
        return new RespEntity(2, "ok"+port, Arrays.asList(
                new Student(1, "test1", 12),
                new Student(2, "test2", 11),
                new Student(3, "test3", 13)
        ));
    }

    @PostMapping("/")
    public RespEntity addStudent(@RequestBody Student student) {
        System.out.println(student);
        return new RespEntity(200, "ok"+port, null);
    }
}

Eureka

概述：

Eureka是Net?ix开发的服务发现框架，SpringCloud将它集成在自己的子项目spring-cloud-net?ix中， 实现SpringCloud的服务发现功能。

微服务注册中心

原理：注册中心可以说是微服务架构中的通讯录，它记录了服务和服务地址的映射关系。在分布式架构中，服务会注册到注册中心，当服务需要调用其它服务时，就到注册中心找到服务的地址，进行调用。

常见的注册中心：

CAP：三进二

C：一致性；

A：可用性；

P：分区容错性

在微服务下，分区容错性是必须实现，其一致性和可用性二选一，为了优化用户体验，一般会优先实现可用性，保证服务是可用状态。

基本架构：

Eureka Server ：提供服务注册和发现 ；

Eureka Client：

? Service Provider ：服务提供方（将自身服务注册到Eureka ，从而使服务消费方能够找到 ）

? Service Consumer ： 服务消费方 （从Eureka获取注册服务列表，从而能够消费服务）

1. Eureka Server提供服务发现的能力，各个微服务启动时，会通过Eureka Client向Eureka Server 进行注册自己的信息（例如网络信息），Eureka Server会存储该服务的信息；
2. 微服务启动后，会周期性地向Eureka Server发送心跳（默认周期为30秒）以续约自己的信息。如果Eureka Server在一定时间内没有接收到某个微服务节点的心跳，Eureka Server将会注销该微服 务节点（默认90秒）；
3. 每个Eureka Server同时也是Eureka Client ，多个Eureka Server之间通过复制的方式完成服务注册表的同步；
4. Eureka Client会缓存Eureka Server中的信息。即使所有的Eureka Server节点都宕掉，服务消费者依然可以使用缓存中的信息找到服务提供者

自我保护：

1. 微服务第一次注册成功之后，每30秒会发送一次心跳将服务的实例信息注册到注册中心。通知 Eureka Server该实例仍然存在。
2. 如果超过90秒没有发送更新，则服务器将从注册信息中将此服务移除。
3. Eureka Server在运行期间，会统计心跳失败的比例在15分钟之内是否低于85% ，如果出现低于的情况，Eureka Server会 将当前的实例注册信息保护起来，同时提示这个警告。
4. 保护模式主要用于一组客户端和Eureka Server 之间存在网络分区场景下的保护。一旦进入保护模式，Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据（也就是不会注销任何微服务）

关闭自我保护功能： eureka.service.enableSelfPreservation=false

服务剔除：

lease-renewal-interval-in-seconds: 服务续约(renew)的间隔， 默认为30秒

lease-expiration-duration-in-seconds: 服务失效时间，默认值90秒

也就是说，默认情况下每隔30秒服务会向注册中心发送一次心跳， 证明自己还活着。如果超过90秒没有发送心跳，EurekaServer就会认为该服务宕机，会定时(eureka.server.eviction-interval-timer.in-ms设定的时间，默认60秒) 从服务列表中移除，这两个值在生产环境不要修改,默认即可。

服务续约：

在注册服务完成以后，服务提供者会维持一个心跳(定时向EurekaServer发起Rest请求) 。告诉EurekaServer: “我还活着"。称为服务的续约(renew) ;

服务失效：

lease-expiration-duration-in-seconds: 服务失效时间，默认值90秒

代码

pom:

<!--eureka 依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

yml:

服务端：

server:
  port: 6061
spring:
  application:
    name: eureka #微服务项目的名字，会在注册中心中出现
eureka:
  instance:
    hostname: localhost  #实例名
  client:
#    registerWithEureka: false # 是否将自己挂到注册中心上，单节点可以false，集群true
#    fetchRegistry: false # 是否要去注册获取服务列表
    registerWithEureka: true # 是否将自己挂到注册中心上，单节点可以false，集群true
    fetchRegistry: true # 是否要去注册获取服务列表
    serviceUrl:
      defaultZone: http://localhost:6061/eureka/ #Eureka服务地址
#      defaultZone: http://localhost:6061/eureka/,http://localhost:6062/eureka/ #Eureka服务地址
  server:
    enable-self-preservation: false #禁用自我保护
    #private long evictionIntervalTimerInMs = 60000L;
    #启用删除的默认时间：默认60s启动一次剔除服务，将无效的服务从服务列表删除
    eviction-interval-timer-in-ms: 2000

客户端：

server:
  # 端口
  port: 8081
spring:
  application:
    name: provider-student
eureka:
  client:
    registerWithEureka: true # 是否将自己挂到注册中心上，单节点可以false，集群true
    fetchRegistry: true # 是否要去注册获取服务列表
    serviceUrl:
#      defaultZone: http://localhost:6061/eureka/,http://localhost:6062/eureka/ #Eureka服务地址
      defaultZone: http://localhost:6061/eureka/ #Eureka服务地址
  instance:
    #服务续约时间:客户端每隔30秒发送一个心跳包
    lease-renewal-interval-in-seconds: 1
    #失效时间：  客户端超过90秒没有发送心跳包，服务器就可以认为当前服务下线
    lease-expiration-duration-in-seconds: 2

服务提供者：

package com.sms.controller;

import com.sms.entity.RespEntity;
import com.sms.entity.Student;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;

/**
 * @Author songmingsong
 * @Version V1.0.0
 * @Date 2022-09-23 17:31
 */
@RestController
@RequestMapping("/student")
public class StudentController {
    @Value("${server.port}")
    private Integer port;

    @GetMapping("/{id}")
    public RespEntity getStudent(@PathVariable("id") Integer id) {
        if (id == 1) {
            return new RespEntity(1, "ok"+port, new Student(1, "test1", 12));
        }
        return new RespEntity(2, "ok"+port, new Student(2, "test2", 11));
    }

    @GetMapping("/")
    public RespEntity getAllStudent() {
        return new RespEntity(2, "ok"+port, Arrays.asList(
                new Student(1, "test1", 12),
                new Student(2, "test2", 11),
                new Student(3, "test3", 13)
        ));
    }

    @PostMapping("/")
    public RespEntity addStudent(@RequestBody Student student) {
        System.out.println(student);
        return new RespEntity(200, "ok"+port, null);
    }
}

服务消费者：

package com.sms.controller;

import com.sms.entity.RespEntity;
import com.sms.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * @Author songmingsong
 * @Version V1.0.0
 * @Date 2022-09-23 17:44
 */
@RestController
@RequestMapping("/conStudent")
public class StudentController {
    @Autowired
    RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;


    /**
     * eureka 获取实例地址方法
     *
     * @return
     */
    public String serviceUri() {
        List<ServiceInstance> serviceInstances = discoveryClient.getInstances("provider-student");
        if (serviceInstances != null && serviceInstances.size() > 0) {
            return serviceInstances.get(0).getUri() + "/student/";
        }
        return null;
    }


    @GetMapping("/{id}")
    public RespEntity getStuInfo(@PathVariable("id") Integer id) {
        System.out.println("获取一个学生信息");
        //远程调用
        return restTemplate.getForObject(serviceUri() + id,
                RespEntity.class);
    }

    @GetMapping("/")
    public RespEntity getAllStudent() {
        System.out.println("获取所有学生信息");
        //远程调用
        return restTemplate.getForObject(serviceUri(),
                RespEntity.class);
    }

    @PostMapping("/")
    public RespEntity addStudent(@RequestBody Student student) {
        System.out.println("添加学生");
        System.out.println(student);
        return restTemplate.postForObject(serviceUri(), student, RespEntity.class);
    }
}

Ribbon

概述：

Ribbon是 Net?ix发布的一个负载均衡器，有助于控制 HTTP 和 TCP客户端行为。

在 SpringCloud 中，Eureka一般配合Ribbon进行使用，Ribbon提供了客户端负载均衡的功能，Ribbon利用从Eureka中读取到的服务信息，在调用服务节点提供的服务时，会合理的进行负载。

在SpringCloud中可以将注册中心和Ribbon配合使用，Ribbon自动的从注册中心中获取服务提供者的 列表信息，并基于内置的负载均衡算法，请求服务

主要作用：

负载均衡：

两种方式：

负载均衡策略：

代码：

@Configuration
public class RestTemplateConfiguration {

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

@RequestMapping("/consumerstudent")
public class ConsumerStudent {

    @Autowired
    RestTemplate restTemplate;
    
    // 直接使用服务名（provider-student）服务提供者
    public String serviceUrl() {
        return "http://provider-student/student/";
    }
    
    
    @GetMapping("/{id}")
    public RespEntity getStuInfo(@PathVariable("id") Integer id) {
        System.out.println("获取一个学生信息");
        //远程调用
        return restTemplate.getForObject(serviceUri() + id,
                RespEntity.class);
    }
}

OpenFeign

概述：

1. Feign是Net?ix开发的声明式，模板化的HTTP客户端。
2. Feign可帮助我们更加便捷，优雅的调用HTTP API。
3. 在SpringCloud中，使用Feign非常简单——创建一个接口，并在接口上添加一些注解，代码就完成了。
4. SpringCloud对Feign进行了增强，使Feign支持了SpringMVC注解，并整合了Ribbon和Eureka ，从而让Feign的使用更加方便。

负载均衡：

Feign中本身已经集成了Ribbon依赖和自动配置，因此我们不需要额外引入依赖，也不需要再注册RestTemplate 对象

超时控制：

默认Feign客户端只等待1秒钟，但是服务端处理需要超过1秒钟，导致Feign客户端不想等待了 ，直接返回报错。

为了避免这样的情况，有时候我们需要设置Feign客户端的超时控制。

可以在ymI文件中开启配置

#微服务调用超时配置
feign:
  client:
    config:
      default:  #default指定对所有的微服务有效，可以指定具体的微服务名
        connectTimeout: 5000
        readTimeout: 5000

日志打印：

配置

#微服务调用超时配置
feign:
  client:
    config:
      default:  #default指定对所有的微服务有效，可以指定具体的微服务名
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: full      #OpenFeign输出日志信息
#开启spring日志功能，级别：debug
logging:
  level:
    com.woniuxy.consumer.student.feignclient.StudentFeignClient: debug

代码：

客户端消费者：

pom

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

定义声明式接口：

package com.sms.FeignClient;

import com.sms.entity.RespEntity;
import com.sms.entity.Student;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

/**
 * @Author songmingsong
 * @Version V1.0.0
 * @Date 2022-09-27 11:53
 */
@FeignClient("provider-student")
public interface IStudentFeignClient {
    @GetMapping("/student/{id}")
    RespEntity getStudent(@PathVariable("id") Integer id);

    @GetMapping("/student/")
    RespEntity getAllStudent();

    @PostMapping("/student/")
    RespEntity addStudent(@RequestBody Student student);
}

调用接口

package com.sms.controller;

import com.sms.FeignClient.IStudentFeignClient;
import com.sms.entity.RespEntity;
import com.sms.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @Author songmingsong
 * @Version V1.0.0
 * @Date 2022-09-23 17:44
 */
@RestController
@RequestMapping("/feignstudent")
public class StudentFeignController {
    @Autowired
    IStudentFeignClient iStudentFeignClient;

    @GetMapping("/{id}")
    public RespEntity getStuInfo(@PathVariable("id") Integer id) {
        System.out.println("获取一个学生信息");
        return iStudentFeignClient.getStudent(id);
    }

    @GetMapping("/")
    public RespEntity getAllStudent() {
        System.out.println("获取所有学生信息");
        return iStudentFeignClient.getAllStudent();
    }

    @PostMapping("/")
    public RespEntity addStudent(@RequestBody Student student) {
        System.out.println("添加学生");
        System.out.println(student);
        return iStudentFeignClient.addStudent(student);
    }
}

客户端提供者：

package com.sms.controller;

import com.sms.entity.RespEntity;
import com.sms.entity.Student;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;

/**
 * @Author songmingsong
 * @Version V1.0.0
 * @Date 2022-09-23 17:31
 */
@RestController
@RequestMapping("/student")
public class StudentController {
    @Value("${server.port}")
    private Integer port;

    @GetMapping("/{id}")
    public RespEntity getStudent(@PathVariable("id") Integer id) {
        if (id == 1) {
            return new RespEntity(1, "ok"+port, new Student(1, "test1", 12));
        }
        return new RespEntity(2, "ok"+port, new Student(2, "test2", 11));
    }

    @GetMapping("/")
    public RespEntity getAllStudent() {
        return new RespEntity(2, "ok"+port, Arrays.asList(
                new Student(1, "test1", 12),
                new Student(2, "test2", 11),
                new Student(3, "test3", 13)
        ));
    }

    @PostMapping("/")
    public RespEntity addStudent(@RequestBody Student student) {
        System.out.println(student);
        return new RespEntity(200, "ok"+port, null);
    }
}

Hystrix

概述：

Hystrix是一个用于分布式系统的延迟和容错的开源库。

在分布式系统里，许多依赖不可避免的调用失败，比如超时、异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整个服务失败，避免级联故障，以提高分布式系统的弹性。

解决问题：服务雪崩

在微服务架构中通常会有多个服务层调用，基础服务的故障可能会导致级联故障，进而造成整个系统不可用的情况，这种现象被称为服务雪崩效应。服务雪崩效应是一种因“服务提供者"的不可用导致“服务消费者”的不可用，并将不可用逐渐放大的过程。

服务正常时：

其中一个系统出现问题时：

高流情况下：

主要功能：

熔断是什么？

熔断机制是应对雪崩效应的一种微服务链路保护机制。

当扇出链路的某个微服务出错不可用或者响应时间太长时，会进行服务的降级,进而熔断该节点微服务的调用，快速返回错误的响应信息。

当检测到该节点微服务调用响应正常后，恢复调用链路。

熔断器三种状态？

关闭（Closed）：关闭状态（断路器关闭），所有请求都正常访问。

代理类维护了最近调用失败的次数，如果某次调用失败，则使失败次数加1。如果最近失败次数超过了在给定时间内允许失败的阈值，则代理类切换到断开(Open)状态。此时代理开启了一个超时时钟，当该时钟超过了该时间，则切换到半断开（Half-Open）状态。该超时时间的设定是给了系统一次机会来修正导致调用失败的错误。

打开（Open）：打开状态（断路器打开），所有请求都会被降级。

Hystix会对请求情况计数，当一定时间内失败请求百分比达到阈值，则触发熔断，断路器会完全关闭。默认失败比例的阈值是50%，请求次数最少不低于20次。

半开（Half Open）：半开状态，open状态不是永久的，打开后会进入休眠时间（默认是5S）。

随后断路器会自动进入半开状态。此时会释放1次请求通过，若这个请求是健康的，则会关闭断路器，否则
继续保持打开，再次进行5秒休眠计时。

涉及到断路器的三个重要参数:

1. 快照时间窗:

   ? 断路器确定是否打开需要统计一些请求和错误数据，而统计的时间范围就是快照时间窗，默认为最近的10秒。

2. 请求总数阀值:

   ? 在快照时间窗内,必须满足请求总数阀值才有资格熔断。默认为20,意味着在10秒内,如果该hystrix命令的调用次数不足20次,即使所有的请求都超时或其他原因失败，断路器都不会打开。

3. 错误百分比阀值:

   ? 当请求总数在快照时间窗内超过了阀值，比如发生了30次调用，如果在这30次调用中，有15次发生了超时异常，也就是超过50%的错误百分比，在默认设定50%阀值情况下，这时候就会将断路器打开。

代码：

pom

<!--熔断器依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>

yml

#启用熔断器
feign:
  hystrix:
    enabled: true

启动类

@EnableCircuitBreaker
@EnableFeignClients
@EnableEurekaClient
@SpringBootApplication
public class ConsumerStudentApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerStudentApplication.class, args);
    }
}

定义降级方法

 @HystrixCommand(fallbackMethod = "timeoutfallback")
    @GetMapping("/timeout")
    public ResponseResult timeout() {
        return studentFeignClient.timeout();
    }

    //定义一个降级方法，和对应的方法的方法签名一致(方法名不同，其它都一样)
	// 上面方法出问题时走这个方法
    public ResponseResult timeoutfallback() {
        return new ResponseResult(500, "ttimeout---fallback", null);
    }

降级方法统一配置【局限性较大，不推荐使用】

@DefaultProperties(defaultFallback = "xxxxfallback")
@RestController
@RequestMapping("/consumerstudent")
public class ConsumerStudent {
    
    @HystrixCommand
    @GetMapping("/timeout")
    public ResponseResult timeout() {
        return studentFeignClient.timeout();
    }
    
    @HystrixCommand
    @GetMapping("/timeok")
    public ResponseResult timeok() {
        return studentFeignClient.timeok();
    }
    
    
    public ResponseResult xxxxfallback() {
        return studentFeignClient.timeout();
    }
}

整合OpenFeign

OpenFeign接口指定对应的降级处理类

package com.woniuxy.consumer.student.feignclient;

import com.woniuxy.common.entity.ResponseResult;
import com.woniuxy.common.entity.Student;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author author
 * @create 2022-09-2022/9/27 11:21
 */
@FeignClient( value = "provider-student",fallback = StudentFeignClientFallback.class)
//@RequestMapping("/student")
public interface StudentFeignClient {

    @GetMapping("/student/{sid}")
    public ResponseResult<Student> getStudentBySid(@PathVariable("sid") int sid);

    @GetMapping("/student/")
    public ResponseResult<List<Student>> getAllStudents();


    @PostMapping("/student/")
    public ResponseResult addStudent(Student student);

    @PostMapping("/student/{pageIndex}/{pageSize}")
    public ResponseResult getStudentsPager(
            @PathVariable("pageIndex") int pageIndex,
            @PathVariable("pageSize") int pageSize,
            @RequestBody Student student);

    @GetMapping("/student/timeout")
    public ResponseResult timeout();

    @GetMapping("/student/timeok")
    public ResponseResult timeok();

}

OpenFeign接口的实现类，定义降级业务逻辑

package com.woniuxy.consumer.student.feignclient;

import com.woniuxy.common.entity.ResponseResult;
import com.woniuxy.common.entity.Student;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author author
 * @create 2022-09-2022/9/27 16:32
 */
@Component
public class StudentFeignClientFallback implements StudentFeignClient {
    @Override
    public ResponseResult<Student> getStudentBySid(int sid) {
        return new ResponseResult(500, "getStudentBySid---fallback", null);
    }

    @Override
    public ResponseResult<List<Student>> getAllStudents() {
        return new ResponseResult(500, "getAllStudents---fallback", null);
    }

    @Override
    public ResponseResult addStudent(Student student) {
        return new ResponseResult(500, "addStudent---fallback", null);
    }

    @Override
    public ResponseResult getStudentsPager(int pageIndex, int pageSize, Student student) {
        return new ResponseResult(500, "getStudentsPager---fallback", null);
    }

    @Override
    public ResponseResult timeout() {
        return new ResponseResult(500, "timeout---fallback", null);
    }

    @Override
    public ResponseResult timeok() {
        return new ResponseResult(500, "timeok---fallback", null);
    }
}