实习Day(二)

实习Day(二)

1. OpenFeign 使用

Feign 简介

​ Feign 是一个声明式的Web Service客户端。它的出现使开发Web Service 客户端变得很简单。使用Feign只需要创建一个接口加上对应的注解，比如：FeignClient注解。Feign有可插拔的注解，包括Feign注解和JAX-RS注解。Feign也支持编码器和解码器，Spring Cloud Open Feign 对Feign进行增强支持Spring MVC注解，可以像Spring Web一样使用HttpMessageConverters等。

​ Feign是一种声明式、模板化的HTTP客户端。在Spring Cloud 中使用Feign，可以做到使用HTTP请求访问远程服务，就像调用本地方法一样的。开发者完全感知不到这是远程方法，更感知不到访问HTTP请求。

Spring Cloud OpenFeign

作为Spring Cloud的子项目之一，Spring Cloud OpenFeign以将OpenFeign集成到Spring Boot应用中的方式，为微服务架构下服务之间的调用提供了解决方案。首先，利用了OpenFeign的声明式方式定义Web服务客户端；其次还更进一步，通过集成Ribbon或Eureka或Nacos实现负载均衡的HTTP客户端。

详细用法

在Spring Cloud OpenFeign中，除了OpenFeign自身提供的标注（annotation）之外，还可以使用JAX-RS标注，或者Spring MVC标注。下面还是以OpenFeign标注为例介绍用法。

1. OpenFeign的标注@FeignClient和@EnableFeignClients

1.1 @FeignClient

OpenFeign提供了两个重要标注**@FeignClient和@EnableFeignClients**。

@FeignClient标注用于声明Feign客户端可访问的Web服务。

@EnableFeignClients标注用于修饰Spring Boot应用的入口类，以通知Spring Boot启动应用时，扫描应用中声明的Feign客户端可访问的Web服务。

1. @FeignClient标注的参数

name, value (默认"")，两者等价
qualifier (默认"")
url (默认"")
decode404 (默认false)
configuration (默认FeignClientsConfiguration.class)
fallback (默认void.class)
fallbackFactory (默认void.class)
path (默认"")
primary (默认true)

2. @FeignClient标注的configuration参数

@FeignClient标注的configuration参数，默认是通过FeignClientsConfiguration类定义的，可以配置Client，Contract，Encoder/Decoder等。

FeignClientsConfiguration类中的配置方法及默认值如下：

feignContract: SpringMvcContract
feignDecoder: ResponseEntityDecoder
feignEncoder: SpringEncoder
feignLogger: Slf4jLogger
feignBuilder: Feign.Builder
feignClient: LoadBalancerFeignClient（开启Ribbon时）或默认的HttpURLConnection

3. 定制**@FeignClien标注的configuration**类

@FeignClient标注的默认配置类为FeignClientsConfiguration，我们可以定义自己的配置类如下：

@Configuration
public class MyConfiguration {
	@Bean
	public Contract feignContract(...) {...}
 
	@Bean
	public Encoder feignEncoder() {...}
 
	@Bean
	public Decoder feignDecoder() {...}
 
	...
}

然后在使用@FeignClient标注时，给出参数如下：

@FeignClient(name = "myServiceName", configuration = MyConfiguration.class, ...)
public interface MyService {
    @RequestMapping("/")
    public String getName();
 
    ...
}

当然，定制@FeignClient标注的configuration类还可以有另一个方法，直接配置application.yaml文件即可，示例如下：

feign:
  client:
	config:
	  feignName: myServiceName
		connectTimeout: 5000
		readTimeout: 5000
		loggerLevel: full
		encoder: com.example.MyEncoder
		decoder: com.example.MyDecoder
		contract: com.example.MyContract

1.2 @EnableFeignClients

1.@EnableFeignClients标注的参数

• value, basePackages (默认{})
• basePackageClasses (默认{})
• defaultConfiguration (默认{})
• clients (默认{})

2.使用OkHttpClient作为client的Feign客户端

在FeignAutoConfiguration的预配置基础上，要使用OkHttpClient作为client的Feign客户端非常简单，步骤如下：

1. pom.xml中，加入对OkHttp的依赖

<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>3.10.0</version>
</dependency>

2. application.yaml中

feign:
    okhttp:
        enabled: true

或者application.properties中，

feign.okhttp.enabled = true

3. 必要时，还可以在Spring配置类中定义一个Spring Bean方法，返回OkHttpClient对象，以定制OkHttpClient。

3. 使用Apache HttpComponents HttpClient作为client的Feign客户端

在FeignAutoConfiguration的预配置基础上，要使用Apache HttpComponents HttpClient作为client的Feign客户端非常简单，步骤如下：

1. pom.xml中，加入对Apache HttpClient的依赖 (略)

2. application.yaml中，

feign:
httpclient:
enabled: true
或者application.properties中，

feign.httpclient.enabled = true
3) 必要时，定义Spring Bean定制返回一个ClosableHttpClient对象

4. 应用示例

1. 创建Spring Boot应用

在应用中，通过Feign客户端访问另一个服务（localhost:8888）

2. pom.xml

org.springframework.cloud spring-cloud-openfeign 2.0.1.RELEASE pom import org.springframework.cloud spring-cloud-starter-openfeign 3) 定义服务接口

@FeignClient(name=“myServiceName”, url=“localhost:8888”)
public interface MyService {
@RequestMapping(“/”)
public String getName();
}
4) 定义访问Web服务的REST控制器类

@RestController
public class MyController {
@Autowired
MyService myService;

@RequestMapping("/hello")
public String helloName() {
	return myService.getName();
}

}
5) 编写Spring Boot应用的入口类

@SpringBootApplication
@EnableFeignClients
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
原文链接：https://blog.csdn.net/taiyangdao/article/details/81359394

功能

1. 可插拔的注解支持，包括Feign注解和JAX-RS注解
2. 支持可插拔的HTTP编码器和解码器 (Gson, Jackson, Sax, JAXB, JAX-RS, SOAP)
3. 支持Hystrix 和他的Fallback
4. 支持Ribbon的负载均衡
5. 支持HTTP请求和响应的压缩
6. 灵活的配置：基于name粒度进行配置
7. 支持多种客户端：JDK URLConnection、 apache heepclient、okhttp，ribbon
8. 支持日志
9. 支持错误充实
10. url 支持占位符
11. 可以不依赖注册中心独立运行

实例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TaSjTyZE-1649897755123)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412152217101.png)]

在商品类中调用 优惠卷 Coupon 中的 Controller

package com.atguigu.gulimall.product.feign;

import com.atguigu.common.to.SkuReductionTo;
import com.atguigu.common.to.SpuBoundTo;
import com.atguigu.common.utils.R;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

@FeignClient("gulimall-coupon")
public interface CouponFeignService {


    /**
     * 1、CouponFeignService.saveSpuBounds(spuBoundTo);
     *      1）、@RequestBody将这个对象转为json。
     *      2）、找到gulimall-coupon服务，给/coupon/spubounds/save发送请求。
     *          将上一步转的json放在请求体位置，发送请求；
     *      3）、对方服务收到请求。请求体里有json数据。
     *          (@RequestBody SpuBoundsEntity spuBounds)；将请求体的json转为SpuBoundsEntity；
     * 只要json数据模型是兼容的。双方服务无需使用同一个to
     * @param spuBoundTo
     * @return
     */
    @PostMapping("/coupon/spubounds/save")
    R saveSpuBounds(@RequestBody SpuBoundTo spuBoundTo);


    @PostMapping("/coupon/skufullreduction/saveinfo")
    R saveSkuReduction(@RequestBody SkuReductionTo skuReductionTo);
}

启动类

添加注解 @EnableFeignClients(basePackages = “com.atguigu.gulimall.product.feign”)

发现 nacos 服务 @EnableDiscoveryClient

@EnableFeignClients(basePackages = "com.atguigu.gulimall.product.feign")
@EnableDiscoveryClient
@MapperScan("com.atguigu.gulimall.product.dao")
@SpringBootApplication
public class GulimallProductApplication {

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

}

导入架包

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

2. Spring Cloud Alibab

依托 Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。

作为 Spring Cloud 体系下的新实现，Spring Cloud Alibaba 跟官方的组件或其它的第三方实现如 Netflix, Consul，Zookeeper 等对比，具备了更多的功能:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-929TGMKl-1649897755123)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412162425884.png)]

Spring Cloud Alibaba 包含组件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mjeKh1oH-1649897755124)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412162507313.png)]

阿里开源组件

Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

RocketMQ：开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的、高可靠的消息发布与订阅服务。

Dubbo：这个就不用多说了，在国内应用非常广泛的一款高性能 Java RPC 框架。

Seata：阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。

Arthas：开源的Java动态追踪工具，基于字节码增强技术，功能非常强大。

阿里商业化组件

作为一家商业公司，阿里巴巴推出 Spring Cloud Alibaba，很大程度上市希望通过抢占开发者生态，来帮助推广自家的云产品。所以在开源社区，夹带了不少私货，这部分组件我在阿里工作时都曾经使用过，整体易用性和稳定性还是很高的。

Alibaba Cloud ACM：一款在分布式架构环境中对应用配置进行集中管理和推送的应用配置中心产品。

Alibaba Cloud OSS：阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的云存储服务。

Alibaba Cloud SchedulerX：阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准的定时（基于 Cron 表达式）任务调度服务。

集成 Spring Cloud 组件

Spring Cloud Alibaba 作为整套的微服务解决组件，只依靠目前阿里的开源组件是不够的，更多的是集成当前的社区组件，所以 Spring Cloud Alibaba 可以集成 Zuul，OpenFeign等网关，也支持 Spring Cloud Stream 消息组件。

3. Spring Cloud Alibaba 功能

那么作为微服务解决方案， Spring Cloud Alibaba是如何支持微服务治理的各个功能。

服务注册与发现

Spring Cloud Alibaba 基于 Nacos 提供 spring-cloud-alibaba-starter-nacos-discovery & spring-cloud-alibaba-starter-nacos-config 实现了服务注册 & 配置管理功能。依靠 @EnableDiscoveryClient 进行服务的注册，兼容 RestTemplate & OpenFeign 的客户端进行服务调用。

适配 Spring Cloud 服务注册与发现标准，默认集成了 Ribbon 的支持。

支持多协议的服务调用 OpenFeign

Spring Cloud 默认的服务调用依赖 OpenFeign 或 RestTemplate 使用 REST 进行调用。

使用 @DubboTransported 注解可将底层的 Rest 协议无缝切换成 Dubbo RPC 协议，进行 RPC 调用。

@FeignClient("dubbo-provider")
@DubboTransported(protocol = "dubbo")
public interface DubboFeignRestService {
  @GetMapping(value = "/param")
  String param(@RequestParam("param") String param);

  @PostMapping("/saveB")
  String saveB(@RequestParam("a") int a, @RequestParam("b") String b);
}

服务限流降级 Sentinel

作为稳定性的核心要素之一，服务限流和降级是微服务领域特别重要的一环，Spring Cloud Alibaba 基于 Sentinel，对 Spring 体系内基本所有的客户端，网关进行了适配，

默认支持 WebServlet、WebFlux, OpenFeign、RestTemplate、Spring Cloud Gateway, Zuul, Dubbo 和 RocketMQ 限流降级功能的接入。

Sentinel应用比较简单，只需引入 starter，即可生效，可以在运行时通过控制台实时修改限流降级规则，还支持查看限流降级 Metrics 监控。

Sentinel 详细实例

Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

Sentinel 具有以下特征:

丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
完备的实时监控：Sentinel 同时提供实时的监控功能。您可以在控制台中看到接入应用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。
广泛的开源生态：Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。您只需要引入相应的依赖并进行简单的配置即可快速地接入 Sentinel。
完善的 SPI 扩展点：Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

Sentinel 分为两个部分:

核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。
控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。
重点来 他是一个jar包，所以就操作比较简单 Java -jar…就可以，操作简单
这些Sentinel给的介绍，官网地址：https://github.com/alibaba/Sentinel/wiki/%E4%BB%8B%E7%BB%8D
他和第一版 cloud的SpringCloud-Hystrix熔断器服务降级做对比的话 首先不从代码上讲，SpringCloud-Hystrix的监控需要单独一个符才可以做，而Sentinel他一单独的一个项目运行的，在代码上也简化了不少了 我为什么这么说呢，因为Sentinel都是可视化配置配合注解 完成，服务降级，限流等

原文链接：https://blog.csdn.net/weixin_44520739/article/details/110403128

运行 Sentinel

端口是：8080 检查一下8080端口是否被占用 被占用起不来
从目下打开cmd窗口

注意版本号

Java -jar sentinel-dashboard-1.8.0.jar

启动成功访问Sentinel界面
账号：sentinel
密码：sentinel

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TvRwMAPs-1649897755124)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412165644116.png)]

登陆成功：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O7UIuQvd-1649897755124)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412165710414.png)]

引入相关依赖

两个依赖 一个是sentinel 做持久化的 就是数据库 一个是sentinel

  <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-nacos</artifactId>
        </dependency>
        <!--SpringCloud ailibaba sentinel -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>

yml

port: 8719 如果端口被占用 就从8719+1开始 一直找到那个端口没被占用为止

server:
  port: 8092
spring:
  application:
    name: cloudalibaba-sentinel-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #Nacos服务注册中心地址
    sentinel:
      transport:
        dashboard: localhost:8080 #配置Sentinel dashboard地址
        port: 8719

management:
  endpoints:
    web:
      exposure:
        include: '*'

启动类：

package com.tang.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class SentinelService8092 {

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

测试类写个方法就可以
Sentinel是 懒加载机制所以呢 需要访问一下接口即可
再去访问Sentinel 就有数据了

Sentinel流控监测

资源名：唯一名称请求路径

针对来源：Sentinel可以针对调用者进行限流，填写微服务的名 默认default（不区分来源）
阀值类型/单机阀值：QPS（每秒请求的数量）当前调用api的QPS达到阀值的 时候进行限流
进程数当调用该api的线程达到了阀值的时候限流

流控模式：
直接：是 api达到了限流的条件时直接限流
关联：当关联的资源达到阀值的时候就限流自己
链路：只记录指定链路的流量
流控效果：
快速失败：直接抛异常
wan Up:根据codeFactor（冷加载因子默认3）的值 从阀值/codeFactor，进过预热时长才打到设置的QPS阀值

排队等待：均速排队，让请求以均速通过，阀值类型必须是QPS否则无效

来测试一下 QPS

QPS单机阀值是1代表的是一秒一次

如果点的过快的话直接抛异常

线程的阀值是·1的话 值允许一个线程进去如果在进一个就会抛异常、
Blocked by Sentinel (flow limiting)

关联
QPS阀值是1 意思是 当/select/test1访问达到了阀值 /select/test的这个接口就会被限流

根据调用链路入口限流：链路限流
NodeSelectorSlot 中记录了资源之间的调用链路，这些资源通过调用关系，相互之间构成一棵调用树。这棵树的根节点是一个名字为 machine-root 的虚拟节点，调用链的入口都是这个虚节点的子节点。

一棵典型的调用树如下图所示：

          machine-root
            /       \
           /         \
     Entrance1     Entrance2
        /             \
       /               \

DefaultNode(nodeA) DefaultNode(nodeA)

上图中来自入口 Entrance1 和 Entrance2 的请求都调用到了资源 NodeA，Sentinel 允许只根据某个入口的统计信息对资源限流。比如我们可以设置 strategy 为 RuleConstant.STRATEGY_CHAIN，同时设置 refResource 为 Entrance1 来表示只有从入口 Entrance1 的调用才会记录到 NodeA 的限流统计当中，而不关心经 Entrance2 到来的调用。

调用链的入口（上下文）是通过 API 方法 ContextUtil.enter(contextName) 定义的，其中 contextName 即对应调用链路入口名称。详情可以参考 ContextUtil 文档。

3.3 具有关系的资源流量控制：关联流量控制
当两个资源之间具有资源争抢或者依赖关系的时候，这两个资源便具有了关联。比如对数据库同一个字段的读操作和写操作存在争抢，读的速度过高会影响写得速度，写的速度过高会影响读的速度。如果放任读写操作争抢资源，则争抢本身带来的开销会降低整体的吞吐量。可使用关联限流来避免具有关联关系的资源之间过度的争抢，举例来说，read_db 和 write_db 这两个资源分别代表数据库读写，我们可以给 read_db 设置限流规则来达到写优先的目的：设置 strategy 为 RuleConstant.STRATEGY_RELATE 同时设置 refResource 为 write_db。这样当写库操作过于频繁时，读数据的请求会被限流。

Warm Up:(RuleConstant.CONTROL_BEHAVIOR_WARM_UP)方式，即预热/冷启动方式。当系统长期处理低水平的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加

到阈值的上限，给系统一个预热的时间，避免冷系统被压垮

意思WarmUp吗，默认是3阀值预热时间超过10秒才能到达我能的我的想要的效果一秒10个请求

匀速排队（RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER）方式会严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法。详细文档可以参考 流量控制 - 匀速器模式，具体的例子可以参见 PaceFlowDemo。

————————————————
版权声明：本文为CSDN博主「　 T」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44520739/article/details/110403128

注意 ：如果有多个接口 需要配置一个公用的接口 进行降级限流

微服务消息驱动 RocketMQ

支持为微服务应用构建消息驱动能力，基于 Spring Cloud Stream 提供 Binder 的新实现: Spring Cloud Stream RocketMQ Binder，

也新增了 Spring Cloud Bus 消息总线的新实现 Spring Cloud Bus RocketMQ。

分布式事务

使用 Seata 解决微服务场景下面临的分布式事务问题。

使用 @GlobalTransactional 注解，在微服务中传递事务上下文，可以对业务零侵入地解决分布式事务问题。

阿里云提供的商业能力

通过上面提到的OSS，schedulerx等组件，开发者可以在阿里云上实现对象存储，分布式任务调度等功能。

4. 心跳机制，服务熔断等相关概念

4.1 Spring Cloud - 负载均衡和远程调用（OpenFeign）

负载均衡

使用微服务后，为了能够承担高并发的压力，同一个服务可能会启动多个实例。这时候消费者就需要要负载均衡，把请求分散到各个实例。负载均衡主要有两种设计：

• 服务端负载均衡
• 客户端负载均衡

对于 传统的分布式服务来说，大多使用服务端负载均衡。一般会使用Nginx 或者ELB 等工具作为负载均衡器，如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rNbIiZS6-1649897755125)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412155240165.png)]

而在Spring Cloud中，使用的是客户端负载均衡的方式，使用Ribbon组件来实现客户端的负载均衡。主要引入了微服务注册中心依赖，就会自动引入Ribbon依赖。客户端负载均衡原理如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T8LgI4p8-1649897755125)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412155321916.png)]

Ribbon的原理

Ribbon 利用了 RestTemplate 的拦截器 （接口是 ClientHttpRequestInterceptor）机制，在拦截器中实现的负载均衡。负载均衡的基本实现就是利用从服务注册中心获取可用的服务地址列表，然后通过一定算法负载，决定使用哪一个服务地址来进行HTTP调用。

详情可以查看LoadBalancerInterceptor 这个类，在org.springframework.cloud.client.loadbalancer包下。

负载均衡策略

查看 IRule 接口的实现类，可以看到Ribbon的所有负载均衡策略，查看各实现类顶部的注释可以看到它的具体策略

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bU5rwU8c-1649897755125)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412155828564.png)]

• RandomRule：随机选择；
• RoundRobinRule：轮询；
• WeightedResponseTimeRule：根据每个服务的响应时间设置权重，响应时间越长，所占权重越少；
• AvailabilityFilteringRule：过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的的后端server（active connections 超过配置的阈值）；
• ZoneAvoidanceRule：使用CompositePredicate根据区域和可用性过滤服务器的规则；
• BestAvailableRule：选择一个最小的并发请求的server；
• RetryRule：在现有的策略基础上，添加重试机制，因为IRule支持级联。

远程调用（OpenFeign）

Spring Cloud提供了OpenFeign组件 以前叫Feign 来进行远程的HTTP调用。他是对RestTemplate 的一个封装。Feign默认集成了Ribbon，并和Eureka结合/Nacos。默认实现了负载均衡效果

• Feign 采用的是基于接口的注解
• Feign 整合了ribbon，具有负载均衡的能力
• 整合了Hystrix，具有熔断的能力

Feign 是一个声明式 Web Service客户端。使用Feign 能让编写Web Service客户端更加简单。Spring Cloud 对Feign 进行了封装，使其支持了 Spring MVC 标准注解和 HttpMessageConverters。Feign可以与微服务注册中心和 Ribbon组合使用以支持负载均衡。

使用 OpenFeign

因为Feign默认继承了Ribbon，并和Nacos结合，默认实现了负载均衡的效果，所以以Feign为例

准备：

• 启动 Nacos server @EnableFeignClients(basePackages = “com.atguigu.gulimall.product.feign”)
• 创建一个Feign 包 下面 是相关调用
• 引入依赖 spring-cloud-starter-openfeign

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

以 Eureka的实例图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ThjdJQ1s-1649897755125)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412161030942.png)]

4.2 心跳机制

Redis的哨兵机制 或者心跳机制 模式

转载自 https://blog.csdn.net/yswKnight/article/details/78158540

一.什么是哨兵机制?

答：Redis的哨兵(sentinel) 系统用于管理多个 Redis 服务器,该系统执行以下三个任务:
监控(Monitoring): 哨兵(sentinel) 会不断地检查你的Master和Slave是否运作正常。
提醒(Notification):当被监控的某个 Redis出现问题时, 哨兵(sentinel) 可以通过 API 向管理员或者其他应用程序发送通知。

自动故障迁移(Automatic failover):当一个Master不能正常工作时，哨兵(sentinel) 会开始一次自动故障迁移操作,它会将失效Master的其中一个Slave升级为新的Master, 并让失效Master的其他Slave改为复制新的Master; 当客户端试图连接失效的Master时,集群也会向客户端返回新Master的地址,使得集群可以使用Master代替失效Master。

哨兵(sentinel) 是一个分布式系统,你可以在一个架构中运行多个哨兵(sentinel) 进程,这些进程使用流言协议(gossipprotocols)来接收关于Master是否下线的信息,并使用投票协议(agreement protocols)来决定是否执行自动故障迁移,以及选择哪个Slave作为新的Master。
每个哨兵(sentinel) 会向其它哨兵(sentinel)、master、slave定时发送消息,以确认对方是否”活”着,如果发现对方在指定时间(可配置)内未回应,则暂时认为对方已挂(所谓的”主观认为宕机” Subjective Down,简称sdown).
若“哨兵群”中的多数sentinel,都报告某一master没响应,系统才认为该master"彻底死亡"(即:客观上的真正down机,Objective Down,简称odown),通过一定的vote算法,从剩下的slave节点中,选一台提升为master,然后自动修改相关配置。
虽然哨兵(sentinel) 释出为一个单独的可执行文件 redis-sentinel ,但实际上它只是一个运行在特殊模式下的 Redis 服务器，你可以在启动一个普通 Redis 服务器时通过给定 --sentinel 选项来启动哨兵(sentinel)。
哨兵(sentinel) 的一些设计思路和zookeeper非常类似

二.哨兵模式的配置修改

实现步骤:
1.拷贝到etc目录
cp sentinel.conf /usr/local/redis/etc
2.修改sentinel.conf配置文件
sentinel monitor mymast 192.168.110.133 6379 1 #主节点 名称 IP 端口号 选举次数

#配置主服务器的密码(如没设置密码，可以省略)
sentinel auth-pass mymaster 123456
\3. 修改心跳检测 5000毫秒
sentinel down-after-milliseconds mymaster 5000
\4. 做多多少合格节点

sentinel parallel-syncs mymaster 2
\5. 启动哨兵模式
./redis-server /usr/local/redis/etc/sentinel.conf --sentinel &
\6. 停止哨兵模式

注意：

1.当启动哨兵模式之后，如果你的master服务器宕机之后，哨兵自动会在从redis服务器里面 投票选举一个master主服务器出来；这个主服务器也可以进行读写操作！

2.如果之前宕机的主服务器已经修好，可以正式运行了。那么这个服务器只能进行读的操作，会自动跟随由哨兵选举出来的新服务器！

3.大家可以进入./redis-cli，输入**info，**查看你的状态信息；

三、哨兵(**Sentinel)**总结

1、Sentinel的作用：

A、Master 状态监测

B、如果Master 异常，则会进行Master-slave 转换，将其中一个Slave作为Master，将之前的Master作为Slave

C、Master-Slave切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换

2、Sentinel的工作方式**😗*

1)：每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令。

2)：如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel 标记为主观下线。

3)：如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。

4)：当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态， 则Master会被标记为客观下线 。

5)：在一般情况下， 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令 。

6)：当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次 。

7)：若没有足够数量的 Sentinel 同意 Master 已经下线， Master 的客观下线状态就会被移除。

若 Master 重新向 Sentinel 的 PING 命令返回有效回复， Master 的主观下线状态就会被移除。

最后，如果大家看不太懂，推荐大家看两个博客，就明白了！

1.http://blog.csdn.net/zbw18297786698/article/details/52891695
2.http://blog.csdn.net/candy_rainbow/article/details/52842402

===========================================================================

心跳检测

在命令传播阶段，从服务器默认以每秒一次的频率，向主服务器发送命令：

REPLCONF ACK <replication_offset> //replication_offset是从服务器当前的复制偏移量。

心跳检测的作用：检测主服务器的网络连接状态；辅助实现min-slaves选项；检测命令丢失。

检测主从服务器的网络连接状态

通过向主服务器发送INFO replication命令，可以列出从服务器列表，可以看出从最后一次向主发送命令距离现在过了多少秒。

lag的值应该在0或1之间跳动，如果超过1则说明主从之间的连接有故障。

辅助实现min-slaves选项

Redis可以通过配置防止主服务器在不安全的情况下执行写命令；

min-slaves-to-write 3

min-slaves-max-lag 10

上面的配置表示：从服务器的数量少于3个，或者三个从服务器的延迟（lag）值都大于或等于10秒时，主服务器将拒绝执行写命令。这里的延迟值就是上面INFOreplication命令的lag值。

检测命令丢失

如果因为网络故障，主服务器传播给从服务器的写命令在半路丢失，那么当从服务器向主服务器发送REPLCONF ACK命令时，主服务器将发觉从服务器当前的复制偏移量少于自己的复制偏移量，然后主服务器就会根据从服务器提交的复制偏移量，在复制积压缓冲区里面找到从服务器缺少的数据，并将这些数据重新发送给从服务器。

主服务器向从服务器补发缺失数据这一操作的原理和部分重同步操作的原理非常相似，它们的区别在于：补发缺失数据操作在主从服务器没有断线的情况下执行，而部分重同步操作则在主从服务器断线并重连之后执行。

4.3 服务熔断

一、Hystrix是什么

在分布式环境中，许多服务依赖（微服务间的调用）中的一些不可避免地会失败。Hystrix 可以通过添加延迟容错和容错逻辑来控制分布式服务之间的交互。Hystrix 通过隔离服务之间的访问点、阻止服务之间的级联故障并提供回退选项来实现这一点，这些操作可以提高系统的整体弹性。

Hystrix 旨在执行以下操作：

① 通常通过网络提供延迟和故障的保护和控制。
② 停止复杂分布式系统中的级联故障。（服务熔断）
③ 快速失败并快速恢复。
④ 在可能的情况下回退并优雅地降级。（服务降级）
⑤ 实现近乎实时的监控、警报和操作控制。（流量监控）

复杂分布式体系结构中的应用程序有几十个微服务，每个微服务都有宕机的可能性。如果主机应用程序没有与这些微服务(宕机)隔离开来，那么应用程序就有被这些微服务(宕机)破坏的风险。

当一切正常时，请求流可以如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3nwo8ITb-1649897755125)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412172129741.png)]

当许多后端系统中的一个微服务异常，那么可能会导致用户请求失败：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J6e0im2E-1649897755126)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412172143728.png)]

倘若出现大量的请求访问该出现问题的微服务，那么极有可能导致"雪崩":

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6VQcWhNx-1649897755126)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412172156219.png)]

当使用 Hystrix 包装每个微服务时，每个依赖项彼此隔离，在一个微服务发生异常时，并不会直接返回错误，Hystrix 会回调设计人员提前定义好服务器异常响应：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q651LvmZ-1649897755126)(C:\Users\ur901168\AppData\Roaming\Typora\typora-user-images\image-20220412172214677.png)]

二、服务熔断

1、简介
在微服务架构中，微服务之间的数据交互通过远程调用完成，微服务A 调用 微服务E 和 微服务G，微服务B 调用其它的 微服务M，此时如果链路上某个微服务的调用响应时间过长或者不可用，那么对 微服务A 的调用就会占用越来越多的系统资源，进而引起系统崩溃，导致“雪崩效应”。

客户端访问 A 、B 服务时，A 调用 E，E 调用 G；B 调用 M。当所有的服务都处于正常的状态，那么访问是成功的。

当 G服务 出现问题，无法提供服务时，那么可能会导致整个服系统出现"雪崩效应"。

当系统进入了服务熔断，即使 G服务 出现问题，熔断机制会调用 G服务 的副本，返回给用户相关的响应信息，不会使得整个系统出现雪崩。

熔断这一概念来源于电子工程中的断路器（Circuit Breaker）。其作用就是当某一个服务出现问题时，会通过熔断机制使该服务不可用并返回错误信息，从而避免服务雪崩。

熔断机制是应对服务雪崩效应的一种微服务链路保护机制，当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务熔断，不再有该节点微服务的调用，快速返回错误的响应信息。当检测到该节点微服务调用响应正常后，恢复调用链路。

2、通过Hystrix实现服务熔断

服务熔断是对于服务提供者而言的，其主要是解决项目依赖的某个微服务中的某一个功能因为某种原因出现异常时，会直接在客户端显示 500 之类的错误页面。当我们通过 Hystrix 实现了服务熔断之后，上述的问题不会出现，而是将开发人员提前定义好的服务器异常时的响应内容返回给客户端。

实现服务熔断，我们是通过 Hystrix + Ribbon （RestTemplate）实现的。

第一步：创建一个服务提供者（springcloud-provider-dept-hystrix-8001）

参考：【SpringCloud】负载均衡 （Ribbon）【精讲】- 二 （3）

第二步：导入 hystrix 依赖

<!--        hystrix 依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>

第三步：设置 fallbackMethod 方法
此方法的作用就是作为一个备用服务存在，当 A 服务出现异常时，Hystrix 会调用 A 方法的 fallbackMethod 方法，不至于使得用户得到 500 的响应页面。

@HystrixCommand(fallbackMethod = “B”)：被该注解作用的方法A，当方法A出现异常，Hystrix 就会调用自定义的 B 方法，值得注意的是：A 与 B 的返回值类型，参数类型都要相同，否则无法生效。

package com.tiger.controller;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.tiger.pojo.Department;
import com.tiger.service.DepartmentService;
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.RestController;
import java.util.List;

@RestController
public class RouteController {
@Autowired
DepartmentService departmentService;

@GetMapping("/dept/select/{id}")
@HystrixCommand(fallbackMethod = "hystrixQueryOne")
public Department queryOne(@PathVariable("id") int dNum){
    //手动制造异常
    throw new RuntimeException("error");
}
public Department hystrixQueryOne(@PathVariable int dNum){
    return new Department()
            .setD_num(dNum)
            .setD_name("服务升级中，抱歉给您带来不便")
            .setD_source("服务升级中，抱歉给您带来不便");
}

@HystrixCommand 中的另一个常用的参数是 commandProperties，而commandProperties中是通过 @HystrixProperty进行设置的,如下：

@HystrixCommand(fallbackMethod = "xxxxx", commandProperties = {
        @HystrixProperty(name="execution.isolation.semaphore.maxConcurrentRequests",value="20"),
        @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value="20000"),
})

@HystrixProperty中的属性，参看：【Hystrix】@HystrixProperty中 name-value 的说明

第四步：主启动类上开启服务熔断可用

@SpringBootApplication
...
@EnableCircuitBreaker //支持熔断（CircuitBreaker：断路器）
public class SpringcloudProviderDeptHystrix8001Application {

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

}

测试
开启 springcloud-provider-dept-hystrix-8001 ，访问 http://localhost:8081/dept/select/1，因为我们在 queryOne() 中手动设置了异常，所以当访问 queryOne()时，Hystrix 会调用 queryOne() 的 fallbackMethod 方法 —— hystrixQueryOne()。

三、服务降级

1、简介
当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务或页面的某些功能做出暂时禁止使用的限制，从而释放服务器资源以保证核心业务的正常运作或高效运作。

举个例子你可能就会更加理解了。在大学期间，大学生都会进行选课，那么选课这个服务在短时间内会产生大量了流量（访问量），为了保证选课业务的正常进行，运维人员通常会将教务系统中的其他不重要的功能（评课、搜索…）设置为不可用，以缓解服务器压力，这就是一个简单的服务降级的使用场景。

使用场景
当整个微服务架构整体的负载超出了预设的上限阈值或即将到来的流量预计将会超过预设的阈值时，为了保证重要或基本的服务能正常运行，我们可以将一些 不重要 或 不紧急 的服务或任务进行服务的 延迟使用 或 暂停使用。注意，服务降级的操作是在服务消费者（springcloud-consumer）中实现的。

当一个服务的访问过大时，在没有进行降级服务的情况是这样的：

当一个服务的访问过大时，在进行降级服务的情况是这样的：

2、通过Hystrix实现服务降级

服务降级是在客户端（服务消费者）实现的，因为只有在客户端实现服务降级，当运维人员关闭不必要的服务时，即使用户再访问 已关闭 的服务也不会爆出 500 之类的页面，因为在客户端有响应的降级处理。

关于服务降级，我们通过 feign 与 hystrix 进行结合实现服务降级（feign 搭建可参照：【SpringCloud】负载均衡 （Ribbon & Feign）【精讲】- 三）。当然你也可以通过 ribbon 与 hystrix 与结合实现负载均衡。

使用 feign 的原因，一方面 feign 是面向接口编程实现的负载均衡，更加符合 java 思想；另一方面 feign 中存在 fallbackFactory ，可以一次性的对一个接口中的方法进行降级，更加简单方便。

第一步：创建一个 FallbackFactory 的实现类
该实现类的作用是对某个服务中的模块统一进行降级处理，要将该类注入到 spring 容器中去。

package com.tiger.service;

import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

@Component
public class ServiceFallbackFactory implements FallbackFactory {

    @Override
    public Object create(Throwable throwable) {
    	return null;

    }
}

第二步：自定义降级服务

将上面的 Object 换成你要进行降级操作的接口（DeptClientService ），并重写里面的方法

package com.tiger.service;

import com.tiger.pojo.Department;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;

@Component
public class ServiceFallbackFactory implements FallbackFactory {

    @Override
    public DeptClientService create(Throwable throwable) {
        return new DeptClientService() {
            @Override
            public boolean addDept(String dName) {
                return false;
            }

            @Override
            public Department queryByNum(int dNum) {
                return new Department()
                        .setD_num(dNum)
                        .setD_name("当前流量过大,该服务暂时做降级处理")
                        .setD_source("当前流量过大,该服务暂时做降级处理");
            }

            @Override
            public List<Department> queryAll() {
                List<Department> list = new ArrayList<>();
                list.add(new Department()
                        .setD_num(0)
                        .setD_name("当前流量过大,该服务暂时做降级处理")
                        .setD_source("当前流量过大,该服务暂时做降级处理"));

                return list;
            }
        };
    }
}

第三步：将 FallbackFactory 实现类绑定 DeptClientService

fallbackFactory：其值就是 FallbackFactory 实现类的 class 类型。经过fallbackFactory 的绑定，当真实的 DeptClientService 中的某一个方法的请求出问题时 [例如：服务提供者（服务端）关闭] ，hystrix 会执行 fallbackFactory 绑定的类中的对用的预备方法。

package com.tiger.service;

import com.tiger.pojo.Department;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

@Service
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT", fallbackFactory = ServiceFallbackFactory.class)

public interface DeptClientService {
    @GetMapping("/dept/insert/{name}")
    boolean addDept(@PathVariable("name") String dName);

    @GetMapping("/dept/select/{id}")
    Department queryByNum(@PathVariable("id") int dNum);

    @GetMapping("/dept/select")
    List<Department> queryAll();
}

第四步：开启服务降级 feign.hystrix （application.yaml）

# 开启服务降级 feign.hystrix
feign:
  hystrix:
    enabled: true

测试：

开启springcloud-eureka-7001 、springcloud-provider-dept-8081 和springcloud-consumer-dept-feign 进行测试。访问 http://localhost:8080/list/1。

当关闭 springcloud-consumer-dept-feign 服务，再次访问 http://localhost:8080/list/1。

四、流量监控

1、简介
我们希望将服务中的每个子服务的流量情况（如：访问量、熔断量、超时、错误、成功）可视化。

2、通过Hystrix实现流量监控
我们需要创建一个服务（springcloud-consumer-hystrix-dashboard），由于流量监控使用
导入所需要的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--        hystrix-dashboard依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>

配置配置文件：（application.yaml）

server:
  port: 9001

# 将 localhost 添加到 proxyStreamAllowList 这个数组当中去
hystrix:
  dashboard:
    proxy-stream-allow-list: "localhost"

主启动类上添加 @EnableHystrixDashboard 注解

@SpringBootApplication
@EnableHystrixDashboard //开启Hystrix监控面板
public class SpringcloudConsumerHystrixDashboardApplication {

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

启动 springcloud-consumer-hystrix-dashboard ，访问 http://localhost:9001/hystrix

到此，我们的流量监控服务就已经搭好了。

下面我们需要将 被监控的服务 与 springcloud-consumer-hystrix-dashboard 建立联系。这里我们需要注意，被监控的服务通过 Hystrix 实现熔断，这是因为 hystrix-dashboard 是通过 @HystrixCommand 注解，对相关的方法进行监控的，而 @HystrixCommand 注解刚好是 hystrix 实现熔断的重要注解。

假设我们要对 springcloud-provider-dept-hystrix-8001 服务进行监控，那么我们需要在其主启动类中添加一个 servlet，实现对该服务中相关熔断访问的监控。（在 springboot 中，如果需要自定义一个 servlet，那么需要用到 servletRegistrationBean，将其注入到 spring 容器中）

@SpringBootApplication
@EnableEurekaClient //在服务启动后，自动注册到 Eureka 的服务端
@EnableDiscoveryClient //服务发现
@EnableCircuitBreaker //支持熔断（CircuitBreaker：断路器）
public class SpringcloudProviderDeptHystrix8001Application {

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

    @Bean
    public ServletRegistrationBean hystrixMetricsStreamServlet(){
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
        //"/actuator/hystrix.stream"刚好与上图中标红的位置相对应
        servletRegistrationBean.addUrlMappings("/actuator/hystrix.stream");
        return servletRegistrationBean;
    }
}

此时，我们已经将 被监控的服务 与 springcloud-consumer-hystrix-dashboard 建立联系。

下面我们进行测试，开启 springcloud-consumer-hystrix-dashboard 和 springcloud-provider-dept-hystrix-8001。（我们只是简单的测试一下流量监控模块，所以并没有开起 注册中心 和 服务消费者/客户端）
访问http://localhost:9001/hystrix

————————————————
版权声明：本文为CSDN博主「StudiousTiger」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_45067620/article/details/119940831

注意：

ps://img-blog.csdnimg.cn/c24c4c08659a4a689e8c2da8c0145d17.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAU3R1ZGlvdXNUaWdlcg==,size_20,color_FFFFFF,t_70,g_se,x_16)

————————————————
版权声明：本文为CSDN博主「StudiousTiger」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_45067620/article/details/119940831

注意：

心跳机制 和 服务熔断还不熟悉