Spring Cloud全家桶（上）【Nacos、OpenFeign、LoadBalancer、GateWay、金丝雀灰色发布】

码农世界 2024-06-17 后端 86 次浏览 0个评论

0.零基础入门微服务实战课

1.微服务和 Spring Cloud

1.1 什么是微服务？
1.2 什么是 Spring Cloud？
1.3 微服务 VS Spring Cloud
2.为什么要学微服务？
3.Spring Cloud 组件介绍
1.什么是 Nacos?

1.1 Nacos 功能

1.1.1 配置中心
1.1.2 注册中心
1.2 Nacos 优点
2.Nacos 基本使用

2.1 Nacos 部署安装

2.1.1 部署方式
2.1.2 安装并启动
2.2.3 配置数据源
2.2.4 开启控制台授权登录（可选）
2.2 配置中心使用

2.2.1 创建配置信息
2.2.2 Spring Boot 使用配置中心 ★

1. 项目中添加 nacos-config 依赖。
2. 在项目配置文件(application.properties)中设置 Nacos 相关信息。
3. 使用 @Value 注解和 @RefreshScope 实现配置的读取和自动更新。
2.3 注册中心使用

2.3.1 生产者实现 ★

1. 添加 nacos-discovery 框架支持
2. 配置 nacos 服务器端信息
3. 编写调用接口
2.3.2 消费者实现

1.添加依赖(注册中心、Openfeign、Spring Cloud LoadBalancer)
2.配置 Nacos 服务端信息
3.在项目中开启 Openfeign
4.编写 Openfeign 调用代码
5.编写代码通过 Openfeiqn 调用生产者
2.3.3 注册中心参数说明

临时实例 VS 永久实例
2.3.4 健康检测机制
3.1 配置自动刷新原理
3.2 注册中心底层实现
1.什么是 OpenFeign?
2.OpenFeign 基础使用

2.1 添加依赖
2.2 配置 Nacos 服务端信息
2.3 项目中开启 OpenFeign
2.4 编写 OpenFeign 调用代码
2.5 调用 OpenFeign 接口代码
3.超时重试机制

3.1 配置超时重试
3.2 覆盖 Retryer
4.自定义超时重试机制

4.1 自定义超时重试类
4.2 设置配置文件
5.超时重试底层实现

5.1 超时底层实现
5.2 重试底层实现
1.什么是 LoadBalancer?

1.1负载均衡分类
1.2 常见负载均衡策略
2.为什么要学 LoadBalancer?
3.如何使用?
4.默认负载均衡策略
5.随机负载均策略

5.1 创建随机负载均衡器
5.2 设置随机负载均衡器 (局部设置)
5.3 设置全局负载均衡器
6.Nacos 权重负载均器

6.1 创建 Nacos 负载均衡器
6.2 设置负载均衡器
7.自定义负载均衡器

7.1 创建自定义负载均衡器
7.2 封装自定义负载均衡器
7.3 设置自定义负载均器
8.缓存

关闭缓存
9.执行原理

底层执行原理

1. `ServiceInstanceListSupplier`
2. `LoadBalancerClient`
3. `LoadBalancer`
执行流程
源码示例
总结
1.什么是网关?
2.网关有什么用?
3.Spring Cloud Gateway 组成
4.Spring Cloud Gateway 基础使用

添加依赖
设置路由规则
5.匹配多个 Path
6.更多断言 (Predicate) 类型

6.1 根据时间匹配
7.Gateway+Nacos+LoadBalancer

7.1 添加依赖
7.2 设置路由规则
8.过滤器

8.1 什么是过滤器?

8.2为什么需要用过滤器?
8.3 Spring Cloud Gateway 过滤器

1. 内置过滤器
2. 全局过滤器
3. 自定义过滤器
总结
限流
重试过滤器
9.工作原理
代码地址
全链路灰色发布

概念和实现思路:
流程思路（先到网关、再调用nacos服务，nacos服务根据负载均衡器调用）
1.负载均衡模块

1.1 自定义负载均衡器
1.2 封装负载均衡器
2.网关模块

配置网关
自定义过滤器

判断是否有灰度标签如果有则传递
3.服务模块

3.1 注册为灰色服务实例
3.2 设置负载均衡器
3.3 传递灰度标签
思路

1. 用户访问网关：网关过滤找到灰度标签传递灰度标签
2. 自定义loadbalance：loadbalance根据标签进行分发

3. service被调用后：再调用其他服务利用feign传递标签

1.微服务和 Spring Cloud

1.1 什么是微服务？

==微服务是将一个大型的、单一的应用程序拆分成多个小型服务，每个服务负责实现特定的业务功能，==并且可以通过网络通信与其他服务通讯。

微服务的优点是开发更灵活(不同微服务可以使用不同开发语言)、更容易维护、更好的可伸缩性和可用性更高，以及更好的团队协作。

1.2 什么是 Spring Cloud？

Spring Cloud 是一个用于构建分布式系统和微服务架构的开发工具集合。它基于 Spring Framework，为开发人员提供了一套简化分布式系统开发的解决方案。

Spring Cloud 提供了一系列的组件和库，用于实现分布式系统的常见功能和模式，包括服务注册与发现、负载均衡、断路器、配置管理、消息总线、分布式追踪、网关等等。它简化了在构建分布式系统时所需的开发工作，并提供了一致而可靠的开发模式。

通过使用 Spring Cloud，开发人员可以快速构建基于微服务架构的应用程序，并将各个微服务协调管理起来。这样，每个微服务可以根据自身的需求独立开发、部署和扩展，通过服务间的调用和协作来实现整体功能。

1.3 微服务 VS Spring Cloud

微服务是一种架构思想，而 Spring Coud 是对于微服务实现的一种规范。当然很多地方也把 Spring Cloud 用来代指微服务，但二者还是不同的，前者是思想，或者是规范。

思想 VS 规范

思想是指解决问题或完成任务的方法、策略或思考方式
规范是一组详细的规则、指南或标准，用于确保系统、组件或功能在实际开发中按照某个特定的方法或标准进行实现。

2.为什么要学微服务？

Java从业者学习微服务有几个重要原因：

可扩展性和灵活性：微服务架构允许将应用程序拆分成小型、独立的服务，每个服务专注于单一功能。这种分解提高了系统的灵活性和可扩展性，有利于应对不断变化的需求和规模。
技术多样性：微服务架构通常采用多语言和多技术栈的方式，使得开发团队可以选择最适合其需求的技术来构建特定的服务。对于Java从业者来说，学习微服务意味着他们有机会接触和掌握其他语言和技术，拓宽自己的技术栈。
团队协作和快速交付：微服务架构将大型应用程序拆分成小的团队可以独立开发和部署的服务，这种方式促进了团队之间的协作，同时也能够实现快速交付和持续集成/部署。
容错性和可维护性：微服务的独立部署和运行使得系统更加容错，即使一个服务发生故障，也不会影响到整个系统的运行。此外，每个微服务都可以独立进行开发、测试和部署，有利于系统的维护和演进。
云原生和容器化：微服务与云原生应用开发和容器化技术紧密相关，如Docker和Kubernetes等。Java从业者学习微服务也就意味着他们有机会学习和应用这些先进的技术，为将来的职业发展打下基础。

3.Spring Cloud 组件介绍

Spring Cloud Alibaba 是一套基于 Spring Cloud 的开源框架，它提供了一系列与阿里巴巴生态相关的组件和工具，帮助开发者快速构建和部署分布式应用和微服务架构。以下是 Spring Cloud Alibaba 的一些核心组件介绍：

Nacos（注册中心和配置中心）：Nacos 是一个功能强大的注册中心和配置中心，支持动态服务发现、服务健康检查、动态配置管理等功能。
Sentinel（流量控制和熔断降级）：Sentinel 提供了流量控制、熔断降级、系统负载保护等功能，帮助保障微服务架构的稳定性和可靠性。
RocketMQ（消息队列）：RocketMQ 是一款高可靠、高吞吐量的分布式消息队列，适用于大规模分布式系统中的消息通信和异步处理。
Dubbo（RPC 框架）：Dubbo 是一款高性能的远程服务调用框架，支持多种协议和序列化方式，能够实现微服务之间的远程调用。
Seata（分布式事务）：Seata 是一个开源的分布式事务解决方案，支持分布式事务的一致性和高性能。
Alibaba Cloud SDK（阿里云 SDK）：提供了与阿里云产品集成的各种 SDK，方便开发者在 Spring Cloud 应用中使用阿里云的各种服务，如对象存储、数据库、消息队列等。

这些组件和工具共同构成了 Spring Cloud Alibaba 生态系统，为开发者提供了一站式的解决方案，帮助他们构建可靠、高效的分布式应用和微服务架构。

1.Nacos 入门与实战

1.微服务和 Spring Cloud

1.1 什么是微服务？
1.2 什么是 Spring Cloud？
1.3 微服务 VS Spring Cloud
2.为什么要学微服务？
3.Spring Cloud 组件介绍
1.什么是 Nacos?

1.1 Nacos 功能

1.1.1 配置中心
1.1.2 注册中心
1.2 Nacos 优点
2.Nacos 基本使用

2.1 Nacos 部署安装

2.1.1 部署方式
2.1.2 安装并启动
2.2.3 配置数据源
2.2.4 开启控制台授权登录（可选）
2.2 配置中心使用

2.2.1 创建配置信息
2.2.2 Spring Boot 使用配置中心 ★

1. 项目中添加 nacos-config 依赖。
2. 在项目配置文件(application.properties)中设置 Nacos 相关信息。
3. 使用 @Value 注解和 @RefreshScope 实现配置的读取和自动更新。
2.3 注册中心使用

2.3.1 生产者实现 ★

1. 添加 nacos-discovery 框架支持
2. 配置 nacos 服务器端信息
3. 编写调用接口
2.3.2 消费者实现

1.添加依赖(注册中心、Openfeign、Spring Cloud LoadBalancer)
2.配置 Nacos 服务端信息
3.在项目中开启 Openfeign
4.编写 Openfeign 调用代码
5.编写代码通过 Openfeiqn 调用生产者
2.3.3 注册中心参数说明

临时实例 VS 永久实例
2.3.4 健康检测机制
3.1 配置自动刷新原理
3.2 注册中心底层实现
1.什么是 OpenFeign?
2.OpenFeign 基础使用

2.1 添加依赖
2.2 配置 Nacos 服务端信息
2.3 项目中开启 OpenFeign
2.4 编写 OpenFeign 调用代码
2.5 调用 OpenFeign 接口代码
3.超时重试机制

3.1 配置超时重试
3.2 覆盖 Retryer
4.自定义超时重试机制

4.1 自定义超时重试类
4.2 设置配置文件
5.超时重试底层实现

5.1 超时底层实现
5.2 重试底层实现
1.什么是 LoadBalancer?

1.1负载均衡分类
1.2 常见负载均衡策略
2.为什么要学 LoadBalancer?
3.如何使用?
4.默认负载均衡策略
5.随机负载均策略

5.1 创建随机负载均衡器
5.2 设置随机负载均衡器 (局部设置)
5.3 设置全局负载均衡器
6.Nacos 权重负载均器

6.1 创建 Nacos 负载均衡器
6.2 设置负载均衡器
7.自定义负载均衡器

7.1 创建自定义负载均衡器
7.2 封装自定义负载均衡器
7.3 设置自定义负载均器
8.缓存

关闭缓存
9.执行原理

底层执行原理

1. `ServiceInstanceListSupplier`
2. `LoadBalancerClient`
3. `LoadBalancer`
执行流程
源码示例
总结
1.什么是网关?
2.网关有什么用?
3.Spring Cloud Gateway 组成
4.Spring Cloud Gateway 基础使用

添加依赖
设置路由规则
5.匹配多个 Path
6.更多断言 (Predicate) 类型

6.1 根据时间匹配
7.Gateway+Nacos+LoadBalancer

7.1 添加依赖
7.2 设置路由规则
8.过滤器

8.1 什么是过滤器?

8.2为什么需要用过滤器?
8.3 Spring Cloud Gateway 过滤器

1. 内置过滤器
2. 全局过滤器
3. 自定义过滤器
总结
限流
重试过滤器
9.工作原理
代码地址
全链路灰色发布

概念和实现思路:
流程思路（先到网关、再调用nacos服务，nacos服务根据负载均衡器调用）
1.负载均衡模块

1.1 自定义负载均衡器
1.2 封装负载均衡器
2.网关模块

配置网关
自定义过滤器

判断是否有灰度标签如果有则传递
3.服务模块

3.1 注册为灰色服务实例
3.2 设置负载均衡器
3.3 传递灰度标签
思路

1. 用户访问网关：网关过滤找到灰度标签传递灰度标签
2. 自定义loadbalance：loadbalance根据标签进行分发

3. service被调用后：再调用其他服务利用feign传递标签

1.什么是 Nacos?

Nacos /na:kats/是 Dynamic Naming and Confiquration Service 的首字母简称，一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。

Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构(例如微服务范式、云原生范式)的服务基础设施。

1.1 Nacos 功能

配置中心
注册中心

1.1.1 配置中心

配置中心是一种集中化管理配置的服务。

它的主要作用有以下几个:

集中管理配置信息: 配置中心将不同服务的配置信息集中放在一起进行管理，实现了配置信息的集中存储。
动态更新配置: 配置中心中的配置信息可以通过操作界面或 API进行动态更新，无需重启服务就可以应用最新的配置信息。
配置信息共享: 将配置集中在配置中心中，不同的服务实例可以共享同一套配置信息。
配置信息安全: 配置中心可以对配置信息提供安全管理、权限控制等管理功能.
信息追溯: 支持配置版本管理、历史记录等管理功能。

1.1.2 注册中心

注册中心是微服务架构中的一个重要组件，用于实现服务的注册与发现。

注册中心的主要作用包括以下几个:

服务注册: 服务实例启动时，将自身信息注册到注册中心，包括服务名称、地址、端口等。
服务发现: 消费者向注册中心查询服务，并获取服务实例信息来访问服务。
服务健康检查: 注册中心定期检查服务实例健康状况，过滤不健康实例。
服务路由: 提供服务的路由与负载均衡功能。
服务监控: 统计服务调用次数，时长等，用于监控服务状态。
服务更新: 当服务实例信息变更时，向注册中心发送更新信息通知。
通过注册中心，服务提供者和消费者只需与注册中心交互即可，从而实现服务的注册与发现，降低了服务间的耦合度。

1.2 Nacos 优点

简单易用:经过几万人使用反馈优化，简单易用。
特性丰富:阿里十年软负载在这个领域积累丰富特性，提供了丰富的特性。
超高性能:苛刻场景要求极致性能。
超大容量:经受了阿里规模经济的强大容量测试，可用于生产级别的超大型系统。
高可用:双十一不能失败，造就了高可用能力。

2.Nacos 基本使用

2.1 Nacos 部署安装

2.1.1 部署方式

Nacos 有以下三种部署方式:

单机模式:将注册中心、配置中心等功能集成在一个进程内，全部部署在一台机器上，适用于测试和单机试用。
集群模式:多个 Nacos 服务器实例组成一个集群。这些实例通过相互通信和协调工作，共同提供服务注册、配置管理和服务发现等功能。在集群模式下，所有的实例共享相同的数据，数据变更会自动同步到所有的实例中，客户端可以随机选择任意一个实例进行注册和发现服务。
多集群模式:多集群模式是为了满足在不同区域或网络中进行部署和扩展的需求。在多集群模式中，可以选择将不同的 Nacos 实例组成多个相互独立的集群，每个集群可以拥有自己独立的配置和注册中心，并可以跨集群进行服务注册和发现。多集群模式适用于分布式系统的多区域部署，并可以使用不同的网络和存储设施。每个集群具有独立的数据和配置，但可以通过自定义的同步机制在集群之间共享数据。

多集群的作用:

不同机房部署:将 Nacos 集群分布在不同的机房，实现异地多活，提高服务的可用性。当单个机房不可用时，通过域名解析可快速切换到另一个机房的服务。

不同运营商部署:跨运营商部署 Nacos 集群，避免单一运营商网络问题导致服务中断。

2.1.2 安装并启动

① 预备环境准备

Nacos 安装和运行需要依赖 JDK 环境，因此在安装之前，需要先在服务器安装 JDK 1.8+ 的环境

② 安装并启动

Nacos 有以下两种安装方式:

源码安装
编译压缩包安装(推荐)

推荐使用编译压缩包安装，操作更简单，出现问题的概率更小。编译压缩包安装流程:

下载压缩包:从 https://github.com/alibaba/nacos/releases 下载最新编译后的压缩包;解压压缩包:使用 unzip nacos-server- v e r s i o n . z i p 或者 t a r − x v f n a c o s − s e r v e r − version.zip 或者 tar -xvf nacos-server- version.zip或者tar−xvfnacos−server−version.tar.gz;

进入 Nacos 运行目录:cd nacos/bin;
启动 Nacos 服务:
a.Linux/MacOS:sh startup.sh -m standalone 启动 Nacos 单机模式;
b.Windows:startup.cmd -m standalone 启动 Nacos 单机模式。
启动成功之后就可以使用:http://localhost:8084/nacos 访问 Nacos 的控制台了，如下图所示
集群部署

2.2.3 配置数据源

Nacos 单机模式默认使用的是内置的嵌入式数据库 Derby 作为数据存储的，但是 Derby 不适合承载生产环境大规模部署，因为它有以下限制:

数据存储容量最大只有 2GB;
不支持集群模式下数据的高可用复制;

性能和并发能力有限。

因此，在生产环境中使用单机模式时，可以使用外置数据库作为数据存储，比如 MySQL。

数据源切换为 MySQL

Nacos 0.7 版本增加了支持 MySQL 数据源能力，具体的操作步骤:

安装数据库，版本要求:5.6.5+;
初始化 MySQL 数据库，数据库初始化文件:mysql-schema.sql;
修改 Nacos 安装目录中 conf/application.properties 文件，增加支持 MySQL 数据源配置，添加 MySQL 数据源的 URL、用户名和密码，配置如下:

1 spring.datasource.platform=mysql
2 db.num=1
3 db.url.0=jdbc:mysgl://localhost:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketT
4 db.user=nacos devtest
5 db.password=youdontknow

再以单机模式启动 Nacos，Nacos 所有写嵌入式数据库的数据都写到了 MySQL。

最后重启 Nacos 服务。

2.2.4 开启控制台授权登录（可选）

首先，找到 Nacos 安装目录的中的 conf/application.properties 文件，修改以下几次内容为以下配置

nacos.core.auth.enabled=true1
nacos,core.auth,plugin,nacos,token.secret.key=SecretKey012345678901234567890123456789012345672# 访问 Nacos 敏感接囗的白名单，key 和 value 必须要有值3
nacos.core.auth.server.identity.key=nacos“
5 nacos.core.auth.server.identity.value=nacos

2.2 配置中心使用

2.2.1 创建配置信息

参数说明:

命名空间（线上、线下、测试）:Nacos 基于命名空间(Namespace)帮助用户逻辑隔离多个命名空间，这可以帮助用户更好的管理测试、预发、生产等多环境服务和配置，让每个环境的同一个配置(如数据库数据源)可以定义不同的值
Data ID（项目名称）:配置的唯一标识，用于查找配置文件。

Group:配置分组，用于设置小组信息，例如 DEV GROUP 开发小组，TEST GROUP 测试小组,

2.2.2 Spring Boot 使用配置中心 ★

Spring Boot 项日使用配置中心，实现步骤如下

1. 项目中添加 nacos-config 依赖。

2. 在项目配置文件(application.properties)中设置 Nacos 相关信息。

3. 使用 @Value 注解和 @RefreshScope 实现配置的读取和自动更新。

①添加配置中心依赖

        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-config

②设置 Nacos 服务端信息

在项目配置文件(application.properties)中添加如下信息:

# Nacos认证信息
spring.cloud.nacos.config.username=nacos
spring.cloud.nacos.config.password=nacos
spring.cloud.nacos.config.contextPath=/nacos
# 设置配置中心服务端地址
spring.cloud.nacos.config.server-addr=localhost:8848
# Nacos 配置中心的namespace。需要注意，如果使用 public 的 namcespace ，请不要填写这个值，直接留空即可
# spring.cloud.nacos.config.namespace=
#spring.cloud.nacos.config.group=
spring.config.import=nacos:nacos-config-example

③ 读取配置文件

@RestController
@RefreshScope
public class TestController {
    @Value("${myconfig}")
    private String myconfig;
    @RequestMapping("/getconfig")
    public String getMyconfig() {
        return myconfig;
    }
}

2.3 注册中心使用

注册中心通常有两个角色:

服务提供者(也叫生产者):对外提供服务的微服务应用。它会把自身的服务地址注册到注册中心，以供消费者发现和调用。

服务消费者(也叫消费者):调用其他微服务的应用程序。它会向注册中心订阅自己需要的服务，并基于服务提供者注册的信息发起远程调用。

2.3.1 生产者实现 ★

生产者实现步骤总共有以下 3 步:

1. 添加 nacos-discovery 框架支持

2. 配置 nacos 服务器端信息

3. 编写调用接口

①添加注册中心依赖

        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery

② 设置 Nacos 服务端信息

spring:
  application:
    name: nacos-discovery-demo # Nacos 服务名（很重要，命名不用使用“_”）
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        username: nacos
        password: nacos
        ephemeral: true # 设置此服务为永久实例
#        group: TEST_GROUP
server:
  port: 0 # 动态端口

③ 编写调用接口

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private ServletWebServerApplicationContext context;
    @RequestMapping("/getnamebyid")
    public String getNameById(Integer id) throws InterruptedException {
        System.out.println("-------------------- Do Provider getNameById method."
                + LocalDateTime.now());
        Thread.sleep(1500);
        return "provider-name-" + id +
                " | port:" + context.getWebServer().getPort();
    }
}

2.3.2 消费者实现

注册中心消费者的实现比生产者要复杂一些，首先是消费者要调用生产者的 HTTP 接口，需要引入 Spring CloudOpenFeign 进行 HTTP 调用，其次为了实现负载均衡，我们还需要添加客户端负载均衡器 Spring CloudLoadBalancer.Spring Cloud OpenFeign:Spring Cloud OpenFeign 是 Spring Cloud 生态系统中的一个组件，它是基于Netflix 的 Feign 库开发的，用于简化和优化微服务架构中的服务间通信。Spring Cloud OpenFeign 提供了-种声明式的方式来定义和调用 HTTP API，使得服务间的通信变得更加简单和直观。通过使用注解和接口定义，开发人员可以轻松地声明需要调用的远程服务的接口和方法，并且无需编写繁琐的 HTTP 请求代码。Spring Cloud LoadBalancer:Spring Cloud 团队提供的一种客户端负载均衡器。负载均衡(Load Balancer):一种在多个服务实例之间分配负载和流量的技术，目的是提高服务的整体性能和可靠性。

消费者的实现步骤如下:

1.添加依赖(注册中心、Openfeign、Spring Cloud LoadBalancer)

        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery
        
        
            org.springframework.cloud
            spring-cloud-starter-loadbalancer
        
        
            org.springframework.cloud
            spring-cloud-starter-openfeign

2.配置 Nacos 服务端信息

spring:
  application:
    name: nacos-consumer-demo
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        username: nacos
        password: nacos
        register-enabled: false # 消费者（不需要将此服务注册到nacos）
#    openfeign:
#      client:
#        config:
#          default:
##            connect-timeout: 1000 # 连接超时时间
##            read-timeout: 1000 # 读取超时时间
##            retryer: com.example.consumer.config.CustomRetryer
server:
  port: 8080

3.在项目中开启 Openfeign

@SpringBootApplication
@EnableFeignClients // 开启 OpenFeign
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

4.编写 Openfeign 调用代码

@Service
@FeignClient("nacos-discovery-demo") // 表示调用 nacos 中的 nacos-discovery-demo 服务
public interface UserService {
    @RequestMapping("/user/getnamebyid") // 调用生产者的"/user/getnamebyid"接口
    public String getNameById(@RequestParam("id") int id);
}

5.编写代码通过 Openfeiqn 调用生产者

@RestController
public class BusinessController {
    @Autowired
    private UserService userService;
    @RequestMapping("/getnamebyid")
    public String getNameById(Integer id){
        return userService.getNameById(id);
    }
}

2.3.3 注册中心参数说明

重要参数说明:

分组 :注册服务所在的组名，默认是 DEFAULT_GROUP，例如:研发小组，测试小组等。
保护闽值:健康节点要求的最小百分比。用于在服务出现不健康实例时，阻止流量过度向少量健康实例集中保护服务的整体可用性。保护阈值应设置为一个0到1之间的浮点数，默认值为 0。当集群中的健康实例占比小于设置的保护阈值时，就会触发阈值保护功能。触发保护阈值后，Nacos 会将全部实例(健康实例+非健康实例)返回给调用者，虽然可能会损失一部分流量，但能保证集群中剩余的健康实例能正常工作。
服务路由类型:用于实现不同的路由需求，常见的路由类型有以下两种:
none:默认路由，基于权重的轮询负载均衡路由策略。
label:标签路由，相同标签的实例会被聚合为一个集群，不同标签则实现流量隔离
临时实例:Nacos 中的实例分为临时实例和永久实例(也叫持久实例)，临时实例的生命周期和服务的运行周期相同，服务停止运行 Nacos 中就会将临时实例删除;而永久示例即时程序终止，也会保留在 Nacos 中。在配置文件中通过:spring.cloud.nacos.discovery.ephemeral=true 设置。

权重:用于实现负载均衡，取值范围1到 100，数值越大，权重越大，负载均衡被分配的概率也就越高。

临时实例 VS 永久实例

永久实例(persistent instance)和临时实例(ephemeral instance)是注册中心的两种不同的服务类型,永久实例(Persistent Instance):是指注册到 Nacos 的服务实例，其注册信息会一直保留在 Nacos 服务器。上，直到主动注销或被删除。这意味着即使服务实例下线或不可用，它的注册信息仍然会保留在 Nacos 上，直到显式取消注册。永久实例适用于需要长期存在的服务，比如稳定部署的服务或长时间运行的后端服务。

临时实例(Ephemeral Instance):是指注册到 Nacos 的服务实例，其注册信息在实例下线或不可用时会自动被删除。如果服务实例下线、断开连接或主动注销，Nacos 会自动从注册表中删除这些实例的信息。临时实例适用于临时性的服务实例，比如临时加入集群的短期任务或特定场景下的临时服务。

2.3.4 健康检测机制

Nacos 中的健康检测机制是用来检查服务健康状态的，只有健康的节点才会被服务消费端调用，这样才能保证程序稳定、正常的运行。

Nacos 中提供了两种健康检测的机制:

客户端主动上报(健康状态的)机制。
服务器端反向探测(健康状态的)机制,
如何理解这两种机制呢?
想象一下这么一个场景，你所在的地区突然发生地质灾書，你被掩盖在废墟下面，搜救队必须要知道你在废墟里面，那么才能对你进行施救。那有什么方法可以让救援队知道你在废墟下面?

第一种，你在废墟里面大喊 help! help!Iam here!，让搜救队知道你的位置和健康状态。

第二种，搜救队使用了他们的专业检查设备，探测到你正埋在废墟下面。

以上这两种方法和 Nacos 的两种健康检测机制类似，也就是客户端主动上报机制，是客户端每隔一段时间，主动向 Nacos 服务器端上报自己的健康状况，而服务器端反向探测机制是 Nacos 服务器端来检测客户端是否健康。

临时实例：主动上报

永久实例：反向探测

临时实例(也可以叫做非持久化实例):对应的是客户端主动上报机制。
永久实例(也可以叫做持久化实例):服务端反向探测机制。健康检查机制执行流程

在 Nacos 中，用户可以通过两种方式进行临时实例的注册，通过 Nacos 的 OpenAPI 进行服务注册或通过 Nacos提供的 SDK 进行服务注册。而 OpenAPI 和 SDK 的健康检测机制是不同的，它们的区别如下。

OpenAPI 的注册方式实际是用户根据自身需求调用 Http 接口对服务进行注册，然后通过 Http 接口发送心跳到注册中心。在注册服务的同时会注册一个全局的客户端心跳检测的任务。在服务一段时间没有收到来白客户端的心跳后，该任务会将其标记为不健康，如果在间隔的时间内还未收到心跳，那么该任务会将其剔除。

SDK 的注册方式实际是通过 RPC 与注册中心保持连接(Nacos 2.x 版本中，旧版的还是仍然通过 OpenAPI 的方式)，客户端会定时的通过 RPC 连接向 Nacos 注册中心发送心跳，保持连接的存活。如果客户端和注册中心的连接断开，那么注册中心会主动剔除该 client 所注册的服务，达到下线的效果。同时 Nacos 注册中心还会在注册中心启动时，注册一个过期客户端清除的定时任务，用于删除那些健康状态超过一段时间的客户端。从上面的特点我们可以发现，对于不同类型的使用方式，Nacos 对于健康检查的特点实际都是相同的，都是由客户端向注册中心发送心跳，注册中心会在连接断开或是心跳过期后将不健康的实例移除。

这两种方式相同的是:临时实例每隔5秒会主动上报一次自己的健康状况，发送的数据包叫做心跳包，发送心跳包的机制叫做心跳机制。如果心跳包的间隔时间超过了 15 秒，那么 Nacos 服务器端就会将此服务实例标记为非健康实例，如果心跳包超过了 30s秒，那么 Nacos 服务器端将会把此服务实例从服务列表中删除掉。

3.1 配置自动刷新原理

Nacos 配置中心是支持配置项自动刷新的，而其实现的原理是通过长轮询+事件驱动的方式来实现的，具体来说:

客户端向 Nacos 服务器发送一个带有监听器(Listener)的请求，以获取某个特定配置的值。
Nacos 服务器接收到请求后，会检查该配置是否发生了变化。如果没有变化，则该请求将被阻塞，直到超时或配置发生变化。
当配置发生变化时，Nacos 服务器会立即响应，并将新的配置值返回给客户端
4.客户端接收到新的配置值后，可以根据需要更新自身的配置。

长轮询 VS 长连接

长轮询和长连接是不同的，长轮询是一种通过挂起请求等待服务器响应的方式来实现实时通信，而长连接则是-种客户端与服务器之间保持持久性连接，来实现实时数据传输和通信的方式。但长轮询更节省资源，降低了服务器的负载和网络带宽，长轮询只是有数据时才响应请求，避免了空闲请求，降低了负载和网络带宽。

3.2 注册中心底层实现

Nacos 注册中心的底层实现主要依赖于两个关键组件:服务注册(Service Register)和服务发现(ServiceDiscovery

服务注册:是指将服务实例的元数据(包括 IP 地址、端口号、服务名称等)注册到 Nacos 服务器上，以便其他服务能够发现和访问该服务。在服务启动时，它会向 Nacos 服务器发送一个注册请求，将自身的信息注册到持定的命名空间和分组中，

服务发现:是指根据服务名称从 Nacos 服务器获取已注册的服务实例列表，并将其提供给需要调用该服务的服务消费者。消费者可以通过调用 Nacos 提供的 API 或集成 Nacos 客户端库来获取服务实例列表。具体来说，Nacos 注册中心的实现包括以下几个步骤:

服务注册:当服务启动时，它会向 Nacos 服务器发送一个注册请求，包含自己的元数据信息。Nacos 服务器接收到注册请求后，在内存中维护一个注册表，将服务实例的元数据保存起来，用于后续的服务发现。

心跳机制:注册成功后，服务实例会定期向 Nacos 服务器发送心跳请求，以表明自己的健康状态和可用性。这样 Nacos 服务器可以监控各个服务实例的状态，并及时剔除不可用或下线的实例。

它会向 Nacos 服务器发送一个服务发现请求，包含所需服务的服务发现:当服务消费者需要访问某个服务时名称。Nacos 服务器根据服务名称查找注册表，并返回该服务的实例列表给消费者

负载均衡:在服务发现的过程中，Nacos 还提供了负载均衡的支持。消费者可以选择合适的负载均衡策略来选择其中一个或多个服务实例进行调用。

2.OpenFeign 入门与使用

1.微服务和 Spring Cloud

1.1 什么是微服务？
1.2 什么是 Spring Cloud？
1.3 微服务 VS Spring Cloud
2.为什么要学微服务？
3.Spring Cloud 组件介绍
1.什么是 Nacos?

1.1 Nacos 功能

1.1.1 配置中心
1.1.2 注册中心
1.2 Nacos 优点
2.Nacos 基本使用

2.1 Nacos 部署安装

2.1.1 部署方式
2.1.2 安装并启动
2.2.3 配置数据源
2.2.4 开启控制台授权登录（可选）
2.2 配置中心使用

2.2.1 创建配置信息
2.2.2 Spring Boot 使用配置中心 ★

1. 项目中添加 nacos-config 依赖。
2. 在项目配置文件(application.properties)中设置 Nacos 相关信息。
3. 使用 @Value 注解和 @RefreshScope 实现配置的读取和自动更新。
2.3 注册中心使用

2.3.1 生产者实现 ★

1. 添加 nacos-discovery 框架支持
2. 配置 nacos 服务器端信息
3. 编写调用接口
2.3.2 消费者实现

1.添加依赖(注册中心、Openfeign、Spring Cloud LoadBalancer)
2.配置 Nacos 服务端信息
3.在项目中开启 Openfeign
4.编写 Openfeign 调用代码
5.编写代码通过 Openfeiqn 调用生产者
2.3.3 注册中心参数说明

临时实例 VS 永久实例
2.3.4 健康检测机制
3.1 配置自动刷新原理
3.2 注册中心底层实现
1.什么是 OpenFeign?
2.OpenFeign 基础使用

2.1 添加依赖
2.2 配置 Nacos 服务端信息
2.3 项目中开启 OpenFeign
2.4 编写 OpenFeign 调用代码
2.5 调用 OpenFeign 接口代码
3.超时重试机制

3.1 配置超时重试
3.2 覆盖 Retryer
4.自定义超时重试机制

4.1 自定义超时重试类
4.2 设置配置文件
5.超时重试底层实现

5.1 超时底层实现
5.2 重试底层实现
1.什么是 LoadBalancer?

1.1负载均衡分类
1.2 常见负载均衡策略
2.为什么要学 LoadBalancer?
3.如何使用?
4.默认负载均衡策略
5.随机负载均策略

5.1 创建随机负载均衡器
5.2 设置随机负载均衡器 (局部设置)
5.3 设置全局负载均衡器
6.Nacos 权重负载均器

6.1 创建 Nacos 负载均衡器
6.2 设置负载均衡器
7.自定义负载均衡器

7.1 创建自定义负载均衡器
7.2 封装自定义负载均衡器
7.3 设置自定义负载均器
8.缓存

关闭缓存
9.执行原理

底层执行原理

1. `ServiceInstanceListSupplier`
2. `LoadBalancerClient`
3. `LoadBalancer`
执行流程
源码示例
总结
1.什么是网关?
2.网关有什么用?
3.Spring Cloud Gateway 组成
4.Spring Cloud Gateway 基础使用

添加依赖
设置路由规则
5.匹配多个 Path
6.更多断言 (Predicate) 类型

6.1 根据时间匹配
7.Gateway+Nacos+LoadBalancer

7.1 添加依赖
7.2 设置路由规则
8.过滤器

8.1 什么是过滤器?

8.2为什么需要用过滤器?
8.3 Spring Cloud Gateway 过滤器

1. 内置过滤器
2. 全局过滤器
3. 自定义过滤器
总结
限流
重试过滤器
9.工作原理
代码地址
全链路灰色发布

概念和实现思路:
流程思路（先到网关、再调用nacos服务，nacos服务根据负载均衡器调用）
1.负载均衡模块

1.1 自定义负载均衡器
1.2 封装负载均衡器
2.网关模块

配置网关
自定义过滤器

判断是否有灰度标签如果有则传递
3.服务模块

3.1 注册为灰色服务实例
3.2 设置负载均衡器
3.3 传递灰度标签
思路

1. 用户访问网关：网关过滤找到灰度标签传递灰度标签
2. 自定义loadbalance：loadbalance根据标签进行分发

3. service被调用后：再调用其他服务利用feign传递标签

1.什么是 OpenFeign?

OpenFeign 的全称为 Spring Cloud OpenFeign(下文简称 OpenFeign)，是 Spring Cloud 团队开发的一款基于Feign 的框架，声明式 Web 服务客户端。

Feign 是 Netfix 开源的一个声明式的 Web 服务客户端，它简化了基于 HTTP 的服务调用，使得服务间的通信变得更加简单和灵活。Feiqn 通过定义接口、注解和动态代理等方式，将服务调用的过程封装起来，开发者只需要定义服务接口，而无需关心底层的 HTTP 请求和序列化等细节。

OpenFeign 功能升级

OpenFeign 在 Feign 的基础上提供了以下增强和扩展功能:

更好的集成 Spring Cloud 组件:OpenFeign 与 Spring Cloud 其他组件(如服务发现、负载均衡等)紧密集成，可以无缝地与其他 Spring Cloud 组件一起使用。
支持 @Feignclient 注解:0penFeign 引入了 @FeignClient 注解作为 Feign 客户端的标识，可以方便地定义和使用远程服务的声明式接口。
错误处理改进:OpenFeiqn 对异常的处理做了增强，提供了更好的错误信息和异常处理机制，使得开发者可以3更方便地进行错误处理。例如 OpenFeiqn 提供的错误解码器(DefaultErrorDecoder)和回退策略(当服务端返回错误响应或请求失败时，OpenFeiqn 会调用回退策略中的逻辑，提供一个默认的处理结果)。
更丰富的配置项:OpenFeiqn 提供了丰富的配置选项，可以对 Feiqn 客户端的行为进行灵活的配置，例如超时设置、重试策略等。

2.OpenFeign 基础使用

2.1 添加依赖

        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery
        
        
            org.springframework.cloud
            spring-cloud-starter-loadbalancer
        
        
            org.springframework.cloud
            spring-cloud-starter-openfeign

2.2 配置 Nacos 服务端信息

spring:
  application:
    name: nacos-consumer-demo
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        username: nacos
        password: nacos
        register-enabled: false # 消费者（不需要将此服务注册到nacos）
    openfeign:
      client:
        config:
          default:
            connect-timeout: 1000 # 连接超时时间
            read-timeout: 1000 # 读取超时时间
            retryer: com.example.consumer.config.CustomRetryer
server:
  port: 8080

2.3 项目中开启 OpenFeign

@SpringBootApplication
@EnableFeignClients // 开启 OpenFeign
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

2.4 编写 OpenFeign 调用代码

@Service
@FeignClient("nacos-discovery-demo") // 表示调用 nacos 中的 nacos-discovery-demo 服务
public interface UserService {
    @RequestMapping("/user/getnamebyid") // 调用生产者的"/user/getnamebyid"接口
    public String getNameById(@RequestParam("id") int id);
}

2.5 调用 OpenFeign 接口代码

@RestController
public class BusinessController {
    @Autowired
    private UserService userService;
    @RequestMapping("/getnamebyid")
    public String getNameById(Integer id){
        return userService.getNameById(id);
    }
}

3.超时重试机制

在微服务架构中，服务之间是通过网络进行通信的，而网络是非常复杂性和不稳定的，所以在调用服务时可能会失败或超时，那么在这种情况下，我们就需要给 OpenFeign 配置超时重试机制了。

什么是超时重试?

答:超时重试是一种在网络通信中常用的策略，用于处理请求在一定时间内未能得到响应或得到超时响应的情况。当发起请求后，如果在规定的时间内没有得到预期的响应，就会触发超时重试机制，重新发送请求。超时重试的主要目的是提高请求的可靠性和稳定性，以应对网络不稳定、服务不可用、响应延迟等不确定因素OpenFeign 默认情况下是不会自动开启超时重试的，所以想要开启超时重试，需要通过以下2 步来实现:

配置超时重试,
覆盖 Retryer 对象

3.1 配置超时重试

spring:
  application:
    name: nacos-consumer-demo
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        username: nacos
        password: nacos
        register-enabled: false # 消费者（不需要将此服务注册到nacos）
    openfeign:
      client:
        config:
          default:
            connect-timeout: 1000 # 连接超时时间
            read-timeout: 1000 # 读取超时时间
            retryer: com.example.consumer.config.CustomRetryer
server:
  port: 8080

3.2 覆盖 Retryer

@Configuration // 将当前对象存储在 IoC 容器
public class RetryerConfig {
    @Bean
    public Retryer retryer(){
        return new Retryer.Default(1000,1000,3);
    }
}

4.自定义超时重试机制

自定义超时重试机制的实现分为以下两步:

自定义超时重试类(实现 Retryer 接口，并重写 continueOrPropagate 方法)
设置配置文件。

4.1 自定义超时重试类

常见的超时重试策略有以下三种:

固定间隔重试:每次重试之间的时间间隔固定不变，例如每次重试之间相隔1秒。
指数重试:每次重试之间的时间间隔按指数递增。例如，初始间隔为1秒，每次重试后加倍，即第一次1 秒,第二次 2 秒，第三次 4秒，以此类推。
随机间隔重试:每次重试之间的时间间隔是随机的，通过引入随机性来防止多个失败请求同时发生。例如，每3.次重试的时间间隔在一定范围内随机选择。

package com.example.consumer.config;
import feign.RetryableException;
import feign.Retryer;
import java.time.LocalDateTime;
/**
 * 自定义超时重传类
 */
public class CustomRetryer implements Retryer {
    private final int maxAttempts;  // 最大尝试次数
    private final long backoff;     // 超时间隔时间
    int attempt; // 当前尝试次数
    public CustomRetryer() {
        this.maxAttempts = 3;
        this.backoff = 1000L;
        this.attempt = 0;
    }
    @Override
    public void continueOrPropagate(RetryableException e) {
        if (attempt++ >= maxAttempts) {
            throw e;
        }
        long interval = this.backoff; // 重试间隔时间
        System.out.println(LocalDateTime.now() + " | 执行一次重试：" + interval);
        try {
            Thread.sleep(interval * attempt);
        } catch (InterruptedException ex) {
            throw new RuntimeException(ex);
        }
    }
    @Override
    public Retryer clone() {
        return new CustomRetryer();
    }
}

4.2 设置配置文件

spring:
  application:
    name: nacos-consumer-demo
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        username: nacos
        password: nacos
        register-enabled: false # 消费者（不需要将此服务注册到nacos）
    openfeign:
      client:
        config:
          default:
            connect-timeout: 1000 # 连接超时时间
            read-timeout: 1000 # 读取超时时间
            retryer: com.example.consumer.config.CustomRetryer
server:
  port: 8080

5.超时重试底层实现

5.1 超时底层实现

OpenFeign 超时的底层实现是通过配置底层的 HTTP 客户端来实现的。Openfeign 允许你在请求连接和读取数据阶段设置超时时间，具体的超时配置可以通过设置 HTP 客户端的连接超时(connectTimeout)和读取超时(readTimeout)来实现，你可以在配置文件中设置超时参数。OpenFeiqn 底层的 HTTP 客户端，可以使用 Apache HttpClient 或 OkHtpClient 来实现，默认使用的是 ApacheHttpClient 实现的。

5.2 重试底层实现

  @Override
  public Object invoke(Object[] argv) throws Throwable {
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Options options = findOptions(argv);
    Retryer retryer = this.retryer.clone();
    try {
      if (methodInfo.isAsyncReturnType()) {
        return executeAndDecode(template, options, retryer);
      } else {
        return executeAndDecode(template, options, retryer).join();
      }
    } catch (CompletionException e) {
      throw e.getCause();
    }
  }
  private CompletableFuture