自学视频：SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式

文章目录

• 1.认识微服务
• • 1.1单体架构
  • 1.2分布式架构
  • 1.3微服务
  • 1.4SpringCloud
• 2.服务拆分和远程调用
• • 2.1服务拆分原则
  • 2.2服务拆分示例
  • • 2.2.1远程调用实现
    • 2.2.2注册RestTemplate
    • 2.2.3实现远程调用
  • 2.3提供者和消费者
• 3.Eureka注册中心
• • 3.1Eureka微服务角色
  • 3.2搭建注册中心
  • 3.3服务注册
  • 3.4服务拉取
  • 3.5**Ribbon负载均衡**
  • • 3.5.1调用总结
    • 3.5.2 负载均衡策略
    • 3.5.3自定义策略
    • 3.5.4饥饿加载
• 4.Nacos注册中心
• • 4.1认识和安装Nacos
  • 4.2使用Nacos进行服务注册
  • 4.3服务分级存储模型
  • 4.4配置集群
  • • 4.4.1同集群优先负载均衡
  • 4.5权重配置
  • 4.6环境隔离
  • • 4.6.1配置namespace
  • 4.7Nacos与Eureka的区别
• 5.Nacos配置中心
• • 5.1统一配置管理
  • • 5.1.1在nacos中添加配置文件
    • 5.1.2从微服务中拉取配置
  • 5.2配置热更新
  • • 5.2.1方式一使用注解@RefreshScope
    • 5.2.2方式二@ConfigurationProperties
  • 5.3配置共享
  • 5.4搭建Nacos集群
  • • 5.4.1初始化数据库
    • 5.4.2配置Nacos
    • 5.4.3Nginx反向代理
• 6.Fegin远程调用
• • 6.1Feign替代RestTemplate
  • 6.2自定义配置
  • • 6.2.1配置文件方式
    • 6.2.2.Java代码方式
  • 6.3Feign性能优化
  • 6.4最佳实践
  • • 6.4.1抽取方式的实现
• 7.Gateway网关
• • 7.1概念
  • 7.2gateway快速入门
  • 7.3断言工厂
  • 7.5过滤器工厂
  • • 7.5.1路由过滤器的种类
    • 7.5.2请求头过滤器
  • 7.6全局过滤器
  • • 7.6.1全局过滤器的作用
    • 7.6.2自定义全局过滤器
    • 7.6.3过滤器执行顺序
  • 7.7跨域问题
  • • 7.7.1什么是跨域问题
    • 7.7.2解决跨域问题
• 8.初识Docker
• • 8.1[项目部署](https://so.csdn.net/so/search?q=项目部署&spm=1001.2101.3001.7020)的问题
  • 8.2Docker与虚拟机

1.认识微服务

1.1单体架构

单体架构：将业务的所有功能集中在一个项目中开发，打成一个包部署

优点：

• 架构简单
• 部署成本低

缺点：

• 耦合度高（维护困难、升级困难）

1.2分布式架构

分布式架构：根据业务功能对系统做拆分，每个业务功能模块作为独立项目开发，称为一个服务

优点：

• 降低服务耦合
• 有利于服务升级和拓展

缺点：

• 服务调用关系错综复杂

1.3微服务

微服务的架构特征：

• 单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责
• 自治：团队独立、技术独立、数据独立，独立部署和交付
• 面向服务：服务提供统一标准的接口，与语言和技术无关
• 隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题

微服务的上述特性其实是在给分布式架构制定一个标准，进一步降低服务之间的耦合度，提供服务的独立性和灵活性。做到高内聚，低耦合。

1.4SpringCloud

SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。

其中常见的组件包括：

2.服务拆分和远程调用

2.1服务拆分原则

这里我总结了微服务拆分时的几个原则：

• 不同微服务，不要重复开发相同业务
• 微服务数据独立，不要访问其它微服务的数据库
• 微服务可以将自己的业务暴露为接口，供其它微服务调用

2.2服务拆分示例

要求：

• 订单微服务和用户微服务都必须有各自的数据库，相互独立
• 订单服务和用户服务都对外暴露Restful的接口
• 订单服务如果需要查询用户信息，只能调用用户服务的Restful接口，不能查询用户数据

所以订单模块实现查询订单的功能，用户模块实现查询用户信息的功能，当用户要查询订单信息时候，所返回的数据不止有订单数据，还要有用户信息，但是此时用户调用的接口是订单模块的接口，则订单模块要向用户模块发送请求获取用户信息，再整合订单信息一起返回。

2.2.1远程调用实现

订单模块发送请求给用户模块获取用户信息就是远程调用，流程如下：

1. 注册一个RestTemplate的实例到Spring容器

2. 修改order-service服务中的OrderService类中的queryOrderById方法，根据Order对象中的userId查询User

3. 将查询的User填充到Order对象，一起返回

2.2.2注册RestTemplate

首先，我们在order-service服务中的OrderApplication启动类中，注册RestTemplate实例

package cn.itcast.order;import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {public static void main(String[] args) {SpringApplication.run(OrderApplication.class, args);}@Beanpublic RestTemplate restTemplate() {return new RestTemplate();}
}

2.2.3实现远程调用

修改order-service服务中的cn.itcast.order.service包下的OrderService类中的queryOrderById方法：

启动之后访问http://localhost:8080/order/101，则会返回结果

2.3提供者和消费者

在服务关系中，有两种角色：

• 服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）

• 服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）

• 服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。

3.Eureka注册中心

假如我们的服务提供者user-service部署了多个实例，如图：

• order-service在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？

  • 答：order-service和user-service可以在Eureka中注册自己的信息，然后当order-service需要拉取user-service服务的时候，就可以通过Eureka获取到是否有这个user服务。

• 有多个user-service实例地址（多个端口号），order-service调用时该如何选择？

  • 答：order-service从实例列表中利用负载均衡算法选中一个实例地址，向该实例地址发起远程调用

• order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

  • user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳
  • 当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除
  • order-service拉取服务时，就能将故障实例排除了

3.1Eureka微服务角色

3.2搭建注册中心

• 搭建eureka-server

  引入 SpringCloud 为 eureka 提供的 starter 依赖，注意这里是用 server

org.springframework.cloudspring-cloud-starter-netflix-eureka-server

• 编写启动类

  注意要添加一个 @EnableEurekaServer 注解，开启 eureka 的注册中心功能

  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;@SpringBootApplication
  @EnableEurekaServer
  public class EurekaApplication {public static void main(String[] args) {SpringApplication.run(EurekaApplication.class, args);}
  }
  

• 编写配置文件

  编写一个 application.yml 文件，内容如下：

  server:port: 10086 #服务端口
  spring:application:name: eureka-server #eureka服务名称
  eureka:client:service-url: defaultZone: http://127.0.0.1:10086/eureka #eureka地址信息
  

  

3.3服务注册

• 将user-service、order-service 都注册到 eureka

1.引入 SpringCloud 为 eureka 提供的 starter 依赖，注意这里是用 client

org.springframework.cloudspring-cloud-starter-netflix-eureka-client

2.在启动类上添加注解**@EnableEurekaClient**

3.在配置类中添加：

spring:application:#name：orderservicename: userservice #注册服务名称
eureka:client:service-url: #eureka的地址信息defaultZone: http:127.0.0.1:10086/eureka

4.如果要使一个服务有多个实例，可以：

重新启动项目之后就可以发现user服务中有两个端口实例：

3.4服务拉取

在 order-service 中完成服务拉取，然后通过负载均衡挑选一个服务，实现远程调用

1.修改 OrderService 访问的url路径，用服务名代替ip、端口：

2.给 RestTemplate 这个 Bean 添加一个 @LoadBalanced 注解，用于开启负载均衡。

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

• spring 会自动帮助我们从 eureka-server 中，根据 userservice 这个服务名称，获取实例列表后去完成负载均衡。

3.5Ribbon负载均衡

我们添加了 @LoadBalanced 注解，即可实现负载均衡功能,SpringCloud 底层提供了一个名为 Ribbon 的组件，来实现负载均衡功能。

• 源码分析：

LoadBalancerInterceptor，这个类会在对 RestTemplate 的请求进行拦截，然后从 Eureka 根据服务 id 获取服务列表，随后利用负载均衡算法得到真实的服务地址信息，替换服务 id。

• 在这个拦截器中intercept() 方法，拦截了用户的 HttpRequest 请求，然后进行：

  • request.getURI()：获取请求uri，即 http://user-service/user/8
  • originalUri.getHost()：获取uri路径的主机名，其实就是服务id user-service
  • this.loadBalancer.execute()：处理服务id，和用户请求
  • this.loadBalancer 是 LoadBalancerClient 类型
  • 然后进入execute() 方法：

  

• 在execute() 方法中：

  • getLoadBalancer(serviceId)：根据服务id获取 ILoadBalancer，而 ILoadBalancer 会拿着服务 id 去 eureka 中获取服务列表。
  • getServer(loadBalancer)：利用内置的负载均衡算法，从服务列表中选择一个。在图中可以看到获取了8082端口的服务

• 在getServer()方法中

• 在chooseServer() 方法中

• 在rule里面

• rule 默认值是一个 RoundRobinRule

• 负载均衡默认使用了轮训算法

3.5.1调用总结

SpringCloud Ribbon 底层采用了一个拦截器，拦截了 RestTemplate 发出的请求，对地址做了修改。

基本流程如下：

• 拦截我们的 RestTemplate 请求 http://userservice/user/1
• RibbonLoadBalancerClient 会从请求url中获取服务名称，也就是 user-service
• DynamicServerListLoadBalancer 根据 user-service 到 eureka 拉取服务列表
• eureka 返回列表，localhost:8081、localhost:8082
• IRule 利用内置负载均衡规则，从列表中选择一个，例如 localhost:8081
• RibbonLoadBalancerClient 修改请求地址，用 localhost:8081 替代 userservice，得到 http://localhost:8081/user/1，发起真实请求

3.5.2 负载均衡策略

负载均衡的规则都定义在 IRule 接口中，而 IRule 有很多不同的实现类：

• 不同规则含义如下：

内置负载均衡规则类	规则描述
RoundRobinRule	简单轮询服务列表来选择服务器。它是Ribbon默认的负载均衡规则。
AvailabilityFilteringRule	对以下两种服务器进行忽略：（1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。短路状态将持续30秒，如果再次连接失败，短路的持续时间就会几何级地增加。 （2）并发数过高的服务器。如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule 规则的客户端也会将其忽略。并发连接数的上限，可以由客户端设置。
WeightedResponseTimeRule	为每一个服务器赋予一个权重值。服务器响应时间越长，这个服务器的权重就越小。这个规则会随机选择服务器，这个权重值会影响服务器的选择。
ZoneAvoidanceRule	以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。
BestAvailableRule	忽略那些短路的服务器，并选择并发数较低的服务器。
RandomRule	随机选择一个可用的服务器。
RetryRule	重试机制的选择逻辑

默认的实现就是 ZoneAvoidanceRule，是一种轮询方案。

3.5.3自定义策略

通过定义 IRule 实现可以修改负载均衡规则，有两种方式：

1.代码方式在 order-service 中的 OrderApplication 启动类中，定义一个新的 IRule：

@Bean
public IRule randomRule(){return new RandomRule();//开启随机负载均衡策略
}

2.配置文件方式：在order-service的application.yml文件中，添加新的配置也可以修改规则

userservice: # 给某个微服务配置负载均衡规则，这里是userservice服务ribbon:NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则

3.5.4饥饿加载

当我们启动 orderservice，第一次访问时，时间消耗会大很多，这是因为 Ribbon 懒加载的机制。

• Ribbon 默认是采用懒加载，即第一次访问时才会去创建 LoadBalanceClient（Ribbon 的客户端），拉取集群地址，所以请求时间会很长

• 饥饿加载则会在项目启动时创建 LoadBalanceClient，降低第一次访问的耗时，通过下面配置开启饥饿加载：

ribbon:eager-load:enabled: true # 开启饥饿加载clients: userservice # 项目启动时直接去拉取userservice的集群，多个用","隔开

4.Nacos注册中心

4.1认识和安装Nacos

在Nacos的GitHub页面，提供有下载链接，可以下载编译好的Nacos服务端或者源代码：

GitHub主页：https://github.com/alibaba/nacos

GitHub的Release下载页：https://github.com/alibaba/nacos/releases

将这个包解压到任意非中文目录下:目录说明：

• bin：启动脚本
• conf：配置文件

Nacos的默认端口是8848，如果你电脑上的其它进程占用了8848端口，请先尝试关闭该进程。

如果无法关闭占用8848端口的进程，也可以进入nacos的conf目录，修改配置文件(application.properties)中的端口：

• 下载好之后对安装包进行解压，解压之后的目录是：

  • 进入bin目录：
    

• 可以打开cmd窗口，输入：

  • startup.cmd -m standalone
    

    执行之后在浏览器中输入http://127.0.0.1:8848/nacos即可。

    默认的账号和密码都是nacos。

4.2使用Nacos进行服务注册

Nacos是SpringCloudAlibaba的组件，而SpringCloudAlibaba也遵循SpringCloud中定义的服务注册、服务发现规范。因此使用Nacos和使用Eureka对于微服务来说，并没有太大区别。

主要区别在于：

• 依赖不同
• 服务地址不同

1.引入依赖

在cloud-demo父工程的pom文件中的中引入SpringCloudAlibaba的依赖：

com.alibaba.cloudspring-cloud-alibaba-dependencies2.2.6.RELEASEpomimport

然后在user-service和order-service中的pom文件中注释掉eureka依赖，引入nacos-discovery依赖：

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

2.配置nacos地址

• 在user-service和order-service的application.yml中注释erueka配置，添加nacos地址：

spring:cloud:nacos:server-addr: localhost:8848

4.3服务分级存储模型

一个服务可以有多个实例，这些实例分布于全国各地的不同机房，Nacos就将同一机房内的实例，划分为一个集群。

微服务互相访问时，应该尽可能访问同集群实例，因为本地访问速度更快。当本集群内不可用时，才访问其它集群。

4.4配置集群

修改 user-service 的 application.yml 文件，添加集群配置：

spring:cloud:nacos:server-addr: localhost:8848discovery:cluster-name: HZ # 集群名称 HZ杭州

重启两个 user-service 实例后，我们再去启动一个上海集群的实例

-Dserver.port=8083 -Dspring.cloud.nacos.discovery.cluster-name=SH

即可在Nacos控制台中查看到两个集群中的实例了。

4.4.1同集群优先负载均衡

默认情况下不能实现根据同集群优先来实现负载均衡。

因此Nacos中提供了一个NacosRule的实现，可以优先从同集群中挑选实例。

• 修改负载均衡规则

修改order-service的application.yml文件，修改负载均衡规则：

userservice:ribbon:NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则 

4.5权重配置

默认情况下NacosRule是同集群内随机挑选，不会考虑机器的性能问题。因此，Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高。在nacos控制台，找到user-service的实例列表，点击编辑，即可修改权重：

编辑实例：

注意：如果权重修改为0，则该实例永远不会被访问

4.6环境隔离

Nacos提供了namespace来实现环境隔离功能（对服务进行隔离，而集群则是对服务中的实例进行隔离）。

• nacos中可以有多个namespace
• namespace下可以有group、service等
• 不同namespace之间相互隔离，例如不同namespace的服务互相不可见

4.6.1配置namespace

1.创建namespace：

​ 默认情况下，所有service、data、group都在同一个namespace，名为public

2.点击页面新增按钮，添加一个namespace：

3.填写表单

4.在页面中就可以看到

5.给微服务配置namespace

给微服务配置namespace只能通过修改配置来实现。

spring:cloud:nacos:server-addr: localhost:8848discovery:cluster-name: HZnamespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID

这时在启动微服务，该服务就会在另外一个命名空间中的了。

总结：

• 每个namespace都有唯一的id
• 不同的namespace下服务是不可见的（两个命名空间中的服务不能互相调用）

4.7Nacos与Eureka的区别

Nacos的服务实例分为两种类型：

• 临时实例：如果实例宕机超过一定时间，会从服务列表剔除，默认的类型。
• 非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例。

配置一个服务的永久实例：

spring:cloud:nacos:discovery:ephemeral: false # 设置为非临时实例

• Nacos与eureka的共同点
  • 都支持服务注册和服务拉取
  • 都支持服务提供者心跳方式做健康检测
• Nacos与Eureka的区别
  • Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
  • 临时实例心跳不正常会被剔除，非临时实例则不会被剔除
  • Nacos支持服务列表变更的消息推送模式，服务列表更新更及时；eureka之支持定时拉取服务列表所以可能不及时。
  • Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式；Eureka采用AP方式

5.Nacos配置中心

Nacos除了可以做注册中心，同样可以做配置管理来使用。

5.1统一配置管理

当微服务部署的实例越来越多，达到数十、数百时，逐个修改微服务配置就会让人抓狂，而且很容易出错。我们需要一种统一配置管理方案，可以集中管理所有实例的配置。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8RgNucjb-1678887798058)(C:\Users\86178\Desktop\博客专用\后端\springcloud\131.png)]

Nacos一方面可以将配置集中管理，另一方可以在配置变更时，及时通知微服务，实现配置的热更新。

5.1.1在nacos中添加配置文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F1qNiGcD-1678887798058)(C:\Users\86178\Desktop\博客专用\后端\springcloud\132.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L1W9B8lV-1678887798058)(C:\Users\86178\Desktop\博客专用\后端\springcloud\133.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n4Evq5rA-1678887798059)(C:\Users\86178\Desktop\博客专用\后端\springcloud\134.png)]

注意：项目的核心配置，需要热更新的配置才有放到nacos管理的必要。基本不会变更的一些配置还是保存在微服务本地比较好。

5.1.2从微服务中拉取配置

微服务要拉取nacos中管理的配置，并且与本地的application.yml配置合并，才能完成项目启动。

如果尚未读取application.yml，又如何得知nacos地址呢？因此spring引入了一种新的配置文件：bootstrap.yaml文件，会在application.yml之前被读取，流程如下：

1.引入nacos-config依赖：

首先，在user-service服务中，引入nacos-config的客户端依赖：

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

2.添加bootstrap.yaml

在user-service中添加一个bootstrap.yaml文件，内容如下：

spring:application:name: userservice # 服务名称profiles:active: dev #开发环境，这里是dev cloud:nacos:server-addr: localhost:8848 # Nacos地址config:file-extension: yaml # 文件后缀名#因为在上面的在nacos中定义的配置文件是userservice-dev.yaml

3.读取nacos配置

在user-service中的UserController中添加业务逻辑，读取pattern.dateformat配置：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I41HAEZn-1678887798059)(C:\Users\86178\Desktop\博客专用\后端\springcloud\136.png)]

测试止呕发现获取到的系统时间是指定的格式，则nacos中配置生效。

5.2配置热更新

修改nacos中的配置后，微服务中无需重启即可让配置生效，也就是配置热更新。

要实现热更新，可以使用两种方式：

5.2.1方式一使用注解@RefreshScope

通过在@Value注入的变量所在类上添加注解@RefreshScope：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xgZjg66B-1678887798059)(C:\Users\86178\Desktop\博客专用\后端\springcloud\137.png)]

5.2.2方式二@ConfigurationProperties

在user-service服务中，添加一个类，读取patterrn.dateformat属性：

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;@Component
@Data
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {private String dateformat;
}

在UserController中使用这个类代替配置中的@Value：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yeLDJtiP-1678887798060)(C:\Users\86178\Desktop\博客专用\后端\springcloud\138.png)]

5.3配置共享

微服务启动时，会去nacos读取多个配置文件，如：

• [spring.application.name]-[spring.profiles.active].yaml，例如：userservice-dev.yaml
• [spring.application.name].yaml，例如：userservice.yaml

而[spring.application.name].yaml不包含环境，因此可以被多个环境共享。

1.添加一个环境共享配置

在nacos中添加一个userservice.yaml文件：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nsKtNCCQ-1678887798060)(C:\Users\86178\Desktop\博客专用\后端\springcloud\139.png)]

2.在user-service中读取共享配置

在user-service服务中，修改PatternProperties类，读取新添加的属性(该属性为配置文件的共享配置)：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q0duiEJ3-1678887798060)(C:\Users\86178\Desktop\博客专用\后端\springcloud\140.png)]

在user-service服务中，修改UserController，添加一个方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QlB4fgA2-1678887798060)(C:\Users\86178\Desktop\博客专用\后端\springcloud\141.png)]

3.运行两个UserApplication，使用不同的profile环境

修改UserApplication2这个启动项，改变其profile值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-keDTdg37-1678887798061)(C:\Users\86178\Desktop\博客专用\后端\springcloud\142.png)]

• 修改UserApplication2这个启动项，改变其profile值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vVHJJKRo-1678887798061)(C:\Users\86178\Desktop\博客专用\后端\springcloud\143.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nJwCGVJK-1678887798061)(C:\Users\86178\Desktop\博客专用\后端\springcloud\144.png)]

• 可以看出来，不管是dev，还是test环境，都读取到了envSharedValue这个属性的值。

4.配置共享的优先级

nacos、服务本地同时出现相同属性时，优先级有高低之分：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s7oTszs8-1678887798061)(C:\Users\86178\Desktop\博客专用\后端\springcloud\145.png)]

5.4搭建Nacos集群

1.集群框架图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pa1z0npq-1678887798062)(C:\Users\86178\Desktop\博客专用\后端\springcloud\146.png)]

其中包含3个nacos节点，然后一个负载均衡器代理3个Nacos。这里负载均衡器可以使用nginx。

三个 Nacos 节点的地址

节点	ip	port
nacos1	192.168.150.1	8845
nacos2	192.168.150.1	8846
nacos3	192.168.150.1	8847

5.4.1初始化数据库

Nacos 默认数据存储在内嵌数据库 Derby 中，不属于生产可用的数据库。官方推荐的最佳实践是使用带有主从的高可用数据库集群，主从模式的高可用数据库。这里我们以单点的数据库为例。

首先新建一个数据库，命名为 nacos，而后导入下面的 SQL

CREATE TABLE `config_info` (`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',`data_id` varchar(255) NOT NULL COMMENT 'data_id',`group_id` varchar(255) DEFAULT NULL,`content` longtext NOT NULL COMMENT 'content',`md5` varchar(32) DEFAULT NULL COMMENT 'md5',`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',`src_user` text COMMENT 'source user',`src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',`app_name` varchar(128) DEFAULT NULL,`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',`c_desc` varchar(256) DEFAULT NULL,`c_use` varchar(64) DEFAULT NULL,`effect` varchar(64) DEFAULT NULL,`type` varchar(64) DEFAULT NULL,`c_schema` text,PRIMARY KEY (`id`),UNIQUE KEY `uk_configinfo_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info';/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_aggr   */
/******************************************/
CREATE TABLE `config_info_aggr` (`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',`data_id` varchar(255) NOT NULL COMMENT 'data_id',`group_id` varchar(255) NOT NULL COMMENT 'group_id',`datum_id` varchar(255) NOT NULL COMMENT 'datum_id',`content` longtext NOT NULL COMMENT '内容',`gmt_modified` datetime NOT NULL COMMENT '修改时间',`app_name` varchar(128) DEFAULT NULL,`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',PRIMARY KEY (`id`),UNIQUE KEY `uk_configinfoaggr_datagrouptenantdatum` (`data_id`,`group_id`,`tenant_id`,`datum_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='增加租户字段';/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_beta   */
/******************************************/
CREATE TABLE `config_info_beta` (`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',`data_id` varchar(255) NOT NULL COMMENT 'data_id',`group_id` varchar(128) NOT NULL COMMENT 'group_id',`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',`content` longtext NOT NULL COMMENT 'content',`beta_ips` varchar(1024) DEFAULT NULL COMMENT 'betaIps',`md5` varchar(32) DEFAULT NULL COMMENT 'md5',`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',`src_user` text COMMENT 'source user',`src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',PRIMARY KEY (`id`),UNIQUE KEY `uk_configinfobeta_datagrouptenant` (`data_id`,`group_id`,`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_beta';/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_info_tag   */
/******************************************/
CREATE TABLE `config_info_tag` (`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',`data_id` varchar(255) NOT NULL COMMENT 'data_id',`group_id` varchar(128) NOT NULL COMMENT 'group_id',`tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',`tag_id` varchar(128) NOT NULL COMMENT 'tag_id',`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',`content` longtext NOT NULL COMMENT 'content',`md5` varchar(32) DEFAULT NULL COMMENT 'md5',`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',`src_user` text COMMENT 'source user',`src_ip` varchar(50) DEFAULT NULL COMMENT 'source ip',PRIMARY KEY (`id`),UNIQUE KEY `uk_configinfotag_datagrouptenanttag` (`data_id`,`group_id`,`tenant_id`,`tag_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_info_tag';/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = config_tags_relation   */
/******************************************/
CREATE TABLE `config_tags_relation` (`id` bigint(20) NOT NULL COMMENT 'id',`tag_name` varchar(128) NOT NULL COMMENT 'tag_name',`tag_type` varchar(64) DEFAULT NULL COMMENT 'tag_type',`data_id` varchar(255) NOT NULL COMMENT 'data_id',`group_id` varchar(128) NOT NULL COMMENT 'group_id',`tenant_id` varchar(128) DEFAULT '' COMMENT 'tenant_id',`nid` bigint(20) NOT NULL AUTO_INCREMENT,PRIMARY KEY (`nid`),UNIQUE KEY `uk_configtagrelation_configidtag` (`id`,`tag_name`,`tag_type`),KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='config_tag_relation';/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = group_capacity   */
/******************************************/
CREATE TABLE `group_capacity` (`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',`group_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Group ID，空字符表示整个集群',`quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',`usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '使用量',`max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',`max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数，，0表示使用默认值',`max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',`max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',PRIMARY KEY (`id`),UNIQUE KEY `uk_group_id` (`group_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='集群、各Group容量信息表';/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = his_config_info   */
/******************************************/
CREATE TABLE `his_config_info` (`id` bigint(64) unsigned NOT NULL,`nid` bigint(20) unsigned NOT NULL AUTO_INCREMENT,`data_id` varchar(255) NOT NULL,`group_id` varchar(128) NOT NULL,`app_name` varchar(128) DEFAULT NULL COMMENT 'app_name',`content` longtext NOT NULL,`md5` varchar(32) DEFAULT NULL,`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,`src_user` text,`src_ip` varchar(50) DEFAULT NULL,`op_type` char(10) DEFAULT NULL,`tenant_id` varchar(128) DEFAULT '' COMMENT '租户字段',PRIMARY KEY (`nid`),KEY `idx_gmt_create` (`gmt_create`),KEY `idx_gmt_modified` (`gmt_modified`),KEY `idx_did` (`data_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='多租户改造';/******************************************/
/*   数据库全名 = nacos_config   */
/*   表名称 = tenant_capacity   */
/******************************************/
CREATE TABLE `tenant_capacity` (`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',`tenant_id` varchar(128) NOT NULL DEFAULT '' COMMENT 'Tenant ID',`quota` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '配额，0表示使用默认值',`usage` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '使用量',`max_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个配置大小上限，单位为字节，0表示使用默认值',`max_aggr_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '聚合子配置最大个数',`max_aggr_size` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '单个聚合数据的子配置大小上限，单位为字节，0表示使用默认值',`max_history_count` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '最大变更历史数量',`gmt_create` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',`gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',PRIMARY KEY (`id`),UNIQUE KEY `uk_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='租户容量信息表';CREATE TABLE `tenant_info` (`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',`kp` varchar(128) NOT NULL COMMENT 'kp',`tenant_id` varchar(128) default '' COMMENT 'tenant_id',`tenant_name` varchar(128) default '' COMMENT 'tenant_name',`tenant_desc` varchar(256) DEFAULT NULL COMMENT 'tenant_desc',`create_source` varchar(32) DEFAULT NULL COMMENT 'create_source',`gmt_create` bigint(20) NOT NULL COMMENT '创建时间',`gmt_modified` bigint(20) NOT NULL COMMENT '修改时间',PRIMARY KEY (`id`),UNIQUE KEY `uk_tenant_info_kptenantid` (`kp`,`tenant_id`),KEY `idx_tenant_id` (`tenant_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='tenant_info';CREATE TABLE `users` (`username` varchar(50) NOT NULL PRIMARY KEY,`password` varchar(500) NOT NULL,`enabled` boolean NOT NULL
);CREATE TABLE `roles` (`username` varchar(50) NOT NULL,`role` varchar(50) NOT NULL,UNIQUE INDEX `idx_user_role` (`username` ASC, `role` ASC) USING BTREE
);CREATE TABLE `permissions` (`role` varchar(50) NOT NULL,`resource` varchar(255) NOT NULL,`action` varchar(8) NOT NULL,UNIQUE INDEX `uk_role_permission` (`role`,`resource`,`action`) USING BTREE
);INSERT INTO users (username, password, enabled) VALUES ('nacos', '$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu', TRUE);INSERT INTO roles (username, role) VALUES ('nacos', 'ROLE_ADMIN');

5.4.2配置Nacos

进入 nacos 的 conf 目录，修改配置文件 cluster.conf.example，重命名为 cluster.conf

添加内容

127.0.0.1:8845
127.0.0.1.8846
127.0.0.1.8847

然后修改 application.properties 文件，添加数据库配置

spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=123456

将 nacos 文件夹复制三份，分别命名为：nacos1、nacos2、nacos3

然后分别修改三个文件夹中的 application.properties，

nacos1

server.port=8845

nacos2

server.port=8846

nacos3

server.port=8847

然后分别启动三个 nacos

startup.cmd

5.4.3Nginx反向代理

修改 nginx 文件夹下的 conf/nginx.conf 文件，配置如下

upstream nacos-cluster {server 127.0.0.1:8845;server 127.0.0.1:8846;server 127.0.0.1:8847;
}server {listen       80;server_name  localhost;location /nacos {proxy_pass http://nacos-cluster;}
}

启动 nginx，在浏览器访问：http://localhost/nacos

在代码中的 application.yml 文件配置改为如下：

spring:cloud:nacos:server-addr: localhost:80 # Nacos地址

实际部署时，需要给做反向代理的 Nginx 服务器设置一个域名，这样后续如果有服务器迁移 Nacos 的客户端也无需更改配置。Nacos 的各个节点应该部署到多个不同服务器，做好容灾和隔离工作。

6.Fegin远程调用

以前利用RestTemplate发起远程调用的代码：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9M0TyGQE-1678887798063)(C:\Users\86178\Desktop\博客专用\后端\springcloud\147.png)]

存在下面的问题：

• 代码可读性差，编程体验不统一
• 参数复杂URL难以维护

Feign是一个声明式的http客户端，官方地址：https://github.com/OpenFeign/feign

其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题

6.1Feign替代RestTemplate

1.引入依赖

在order-service服务的pom文件中引入feign的依赖：

org.springframework.cloudspring-cloud-starter-openfeign

2.添加注解

在order-service的启动类添加注解开启Feign的功能：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jdbteICB-1678887798063)(C:\Users\86178\Desktop\博客专用\后端\springcloud\148.png)]

3.编写Feign的客户端

在order-service中新建一个接口，内容如下：

import cn.itcast.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;@FeignClient("userservice")
public interface UserClient {@GetMapping("/user/{id}")User findById(@PathVariable("id") Long id);
}

客户端主要是基于SpringMVC的注解来声明远程调用的信息：

• 服务名称：userservice
• 请求方式：GET
• 请求路径：/user/{id}
• 请求参数：Long id
• 返回值类型：User

Feign就可以帮助我们发送http请求，无需自己使用RestTemplate来发送了

4.测试

修改order-service中的OrderService类中的queryOrderById方法，使用Feign客户端代替RestTemplate：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5FjX6cu7-1678887798063)(C:\Users\86178\Desktop\博客专用\后端\springcloud\149.png)]

而且也已经自动引入了ribbon负载均衡。

5.总结

使用Feign的步骤：

① 引入依赖

② 添加@EnableFeignClients注解

③ 编写FeignClient接口

④ 使用FeignClient中定义的方法代替RestTemplate

6.2自定义配置

Feign可以支持很多的自定义配置，如下表所示：

类型	作用	说明
feign.Logger.Level	修改日志级别	包含四种不同的级别：NONE、BASIC、HEADERS、FULL
feign.codec.Decoder	响应结果的解析器	http远程调用的结果做解析，例如解析json字符串为java对象
feign.codec.Encoder	请求参数编码	将请求参数编码，便于通过http请求发送
feign.Contract	支持的注解格式	默认是SpringMVC的注解
feign.Retryer	失败重试机制	请求失败的重试机制，默认是没有，不过会使用Ribbon的重试

配置日志的两种方式：

6.2.1配置文件方式

基于配置文件修改feign的日志级别：

可以针对单个服务：

feign:  client:config: userservice: # 针对某个微服务的配置loggerLevel: FULL #  日志级别 

也可以针对所有服务：

feign:  client:config: default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置loggerLevel: FULL #  日志级别 

而日志的级别分为四种：

• NONE：不记录任何日志信息，这是默认值。
• BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
• HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
• FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据。

6.2.2.Java代码方式

也可以基于Java代码来修改日志级别，先声明一个类，然后声明一个Logger.Level的对象：

public class DefaultFeignConfiguration  {@Beanpublic Logger.Level feignLogLevel(){return Logger.Level.BASIC; // 日志级别为BASIC}
}

如果要全局生效，将其放到启动类的**@EnableFeignClients**这个注解中：

@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class) 

如果是局部生效，则把它放到具体接口clients对应的**@FeignClient**这个注解中：

//在orderservice中的userclients接口中添加
@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration .class) 

6.3Feign性能优化

Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括：

• URLConnection：默认实现，不支持连接池
• Apache HttpClient ：支持连接池
• OKHttp：支持连接池

因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。

这里我们使用Apache的HttpClient来演示。

1.引入依赖

io.github.openfeignfeign-httpclient

2.配置连接池

feign:client:config:default: # default全局的配置loggerLevel: BASIC # 日志级别，BASIC就是基本的请求和响应信息httpclient:enabled: true # 开启feign对HttpClient的支持max-connections: 200 # 最大的连接数max-connections-per-route: 50 # 每个路径的最大连接数

Feign优化方向：

• 日志级别尽量用basic级别
• 使用HttpClient或OKHttp代替URLConnection

6.4最佳实践

1. 继承方式：

一样的代码可以通过继承来共享：

• 定义一个 API 接口，利用定义方法，并基于 SpringMVC 注解做声明
• Feign 客户端、Controller 都实现该接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gAsMpuRT-1678887798063)(C:\Users\86178\Desktop\博客专用\后端\springcloud\150.png)]

优点：

• 简单
• 实现代码的共享

缺点：

• 服务提供方、服务消费方紧耦合
• 参数列表中的注解映射不会继承，因此Controller 中必须再次声明方法、参数列表、注解

2.抽取方式：

将 FeignClient 抽取为独立模块，并且把接口有关的 pojo、默认的 Feign 配置都放到这个模块中，提供给所有消费者使用。

例如：将 UserClient、User、Feign 的默认配置都抽取到一个 feign-api 包中，所有微服务引用该依赖包，即可直接使用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PN0poV9E-1678887798064)(C:\Users\86178\Desktop\博客专用\后端\springcloud\151.png)]

6.4.1抽取方式的实现

1.首先创建一个 module，命名为 feign-api

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HeuoxyFl-1678887798064)(C:\Users\86178\Desktop\博客专用\后端\springcloud\152.png)]

2.在 feign-api 中然后引入依赖

org.springframework.cloudspring-cloud-starter-openfeign

3.order-service中 的 UserClient、User 都复制到 feign-api 项目中

4.在 order-service 中使用 feign-api

由于我们已经将 UserClient、User 放在 fegin-api 中共享了 ，所以可以删除 order-service 中的 UserClient、User，然后在 order-service 中引入 feign-api

com.xn2001.feignfeign-api1.0

修改order-service中的所有与上述三个组件有关的导包部分，改成导入feign-api中的包

5.重启测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rf4DDkJ3-1678887798064)(C:\Users\86178\Desktop\博客专用\后端\springcloud\153.png)]

发信存在报错，因为UserClient现在在cn.itcast.feign.clients包下，@Autowired扫描的是当前包下的类来创建对象，所以扫描不到，无法实现自动注入，解决方案如下：

• 方式一：

  在实现启动类中指定Feign应该扫描的包：

@EnableFeignClients(basePackages = "cn.itcast.feign.clients")

• 方式二：

  在实现启动类中指定需要加载的Client接口：

@EnableFeignClients(clients = {UserClient.class})

7.Gateway网关

Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。

7.1概念

网关的核心功能特性：

• 请求路由
• 权限控制
• 限流

网关的作用：

• 网关作为微服务入口，需要校验用户是是否有请求资格，如果没有则进行拦截
• 一切请求都必须先经过gateway，但网关不处理业务，而是根据某种规则，把请求转发到某个微服务，这个过程叫做路由。当然路由的目标服务有多个时，还需要做负载均衡。
• 当请求流量过高时，在网关中按照下流的微服务能够接受的速度来放行请求，避免服务压力过大。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3qMCcUuN-1678887798064)(C:\Users\86178\Desktop\博客专用\后端\springcloud\154.png)]

在SpringCloud中网关的实现包括两种：gateway和zuul；

Zuul是基于Servlet的实现，属于阻塞式编程。而SpringCloudGateway则是基于Spring5中提供的WebFlux，属于响应式编程的实现，具备更好的性能。

7.2gateway快速入门

1. 创建SpringBoot工程gateway服务，引入网关依赖

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0cp7zHTq-1678887798065)(C:\Users\86178\Desktop\博客专用\后端\springcloud\155.png)]

引入依赖：

org.springframework.cloudspring-cloud-starter-gateway


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

2.编写启动类

package cn.itcast.gateway;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class GatewayApplication {public static void main(String[] args) {SpringApplication.run(GatewayApplication.class, args);}
}

3.编写基础配置和路由规则

创建application.yml文件，内容如下：

server:port: 10010 # 网关端口
spring:application:name: gateway # 服务名称cloud:nacos:server-addr: localhost:8848 # nacos地址gateway:routes: # 网关路由配置- id: user-service                 # 路由id，自定义，只要唯一即可# uri: http://127.0.0.1:8081     # 路由的目标地址 http就是固定地址uri: lb://userservice            # 路由的目标地址 lb就是负载均衡，后面跟服务名称predicates:                      # 路由断言，也就是判断请求是否符合路由规则的条件- Path=/user/**                # 这个是按照路径匹配，只要以/user/开头就符合要求，所以当路路径是/user/1的时候，就会通过负载均衡发送请求。- id: order-serviceuri: lb://orderservicepredicates:- Path=/user/**

4.启动网关服务进行测试

重启网关，访问http://localhost:10010/user/1时，符合/user/**规则，请求转发到uri：http://userservice/user/1，就能得到结果

5.网关路由流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-voyY8Xcq-1678887798065)(C:\Users\86178\Desktop\博客专用\后端\springcloud\156.png)]

6.总结

网关搭建步骤：

• 创建项目，引入nacos服务发现和gateway依赖

• 配置application.yml，包括服务基本信息、nacos地址、路由

路由配置包括：

• 路由id：路由的唯一标示

• 路由目标（uri）：路由的目标地址，http代表固定地址，lb代表根据服务名负载均衡

• 路由断言（predicates）：判断路由的规则，

• 路由过滤器（filters）：对请求或响应做处理

7.3断言工厂

• 在配置文件中写的断言规则只是字符串，这些字符串会被Predicate Factory读取并处理，转变为路由判断的条件

• 如Path=/user/**是按照路径匹配，这个规则是由

  org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory类来

  处理的，像这样的断言工厂在SpringCloudGateway还有十几个:

名称	说明	示例
After	是某个时间点后的请求	- After=2037-01-20T17:42:47.789-07:00[America/Denver]
Before	是某个时间点之前的请求	- Before=2031-04-13T15:14:47.433+08:00[Asia/Shanghai]
Between	是某两个时间点之前的请求	- Between=2037-01-20T17:42:47.789-07:00[America/Denver], 2037-01-21T17:42:47.789-07:00[America/Denver]
Cookie	请求必须包含某些cookie	- Cookie=chocolate, ch.p
Header	请求必须包含某些header	- Header=X-Request-Id, \d+
Host	请求必须是访问某个host（域名）	- Host=**.somehost.org, **.anotherhost.org
Method	请求方式必须是指定方式	- Method=GET,POST
Path	请求路径必须符合指定规则	- Path=/red/{segment},/blue/**
Query	请求参数必须包含指定参数	- Query=name, Jack或者- Query=name
RemoteAddr	请求者的ip必须是指定范围	- RemoteAddr=192.168.1.1/24
Weight	权重处理

官方文档：https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gateway-request-predicates-factories

7.5过滤器工厂

GatewayFilter是网关中提供的一种过滤器，可以对进入网关的请求和微服务返回的响应做处理：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1uPEM8IX-1678887798065)(C:\Users\86178\Desktop\博客专用\后端\springcloud\157.png)]

7.5.1路由过滤器的种类

Spring提供了31种不同的路由过滤器工厂。例如：

名称	说明
AddRequestHeader	给当前请求添加一个请求头
RemoveRequestHeader	移除请求中的一个请求头
AddResponseHeader	给响应结果中添加一个响应头
RemoveResponseHeader	从响应结果中移除有一个响应头
RequestRateLimiter	限制请求的流量

7.5.2请求头过滤器

以AddRequestHeader 为例

需求：给所有进入userservice的请求添加一个请求头：Truth=itcast is freaking awesome!

只需要修改gateway服务的application.yml文件，添加路由过滤即可：

spring:cloud:gateway:routes:- id: user-service uri: lb://userservice predicates: - Path=/user/** filters: # 过滤器- AddRequestHeader=Truth, Itcast is freaking awesome! # 添加请求头，只针对user-service这个路由生效

修改 userservice 中的一个接口验证请求头是否实现：

@GetMapping("/{id}")
public User queryById(@PathVariable("id") Long id, @RequestHeader(value = "Truth", required = false) String sign) {System.out.println("Truth = " + Truth);return userService.queryById(id);
}

运行即可看到控制台打印出的信息Truth = Itcast is freaking awesome!

• Gateway 也是有全局过滤器的，如果要对所有的路由都生效，则可以将过滤器工厂写到 default-filters 下：

spring:cloud:gateway:default-filters:- AddRequestHeader=Truth,  Itcast is freaking awesome! # 添加请求头，这是对所有的路由都生效

7.6全局过滤器

由于上面的过滤器都是Spring写死的，一些规则无法自定义，所以要想自定义一些复杂的规则，则要通过全局过滤器。

7.6.1全局过滤器的作用

全局过滤器的作用也是处理一切进入网关的请求和微服务响应，与GatewayFilter的作用一样。区别在于GatewayFilter通过配置定义，处理逻辑是固定的；而GlobalFilter的逻辑需要自己写代码实现。

定义方式是实现GlobalFilter接口。

public interface GlobalFilter {/***  处理当前请求，有必要的话通过{@link GatewayFilterChain}将请求交给下一个过滤器处理** @param exchange 请求上下文，里面可以获取Request、Response等信息* @param chain 用来把请求委托给下一个过滤器 * @return {@code Mono} 返回标示当前过滤器业务结束*/Mono filter(ServerWebExchange exchange, GatewayFilterChain chain);
}

在filter中编写自定义逻辑，可以实现下列功能：

• 登录状态判断
• 权限校验
• 请求限流等

7.6.2自定义全局过滤器

• 需求：定义全局过滤器，拦截请求，判断请求的参数是否满足下面条件：
  • 参数中是否有authorization，
  • authorization参数值是否为admin
• 如果同时满足则放行，否则拦截

代码实现：

在gateway中定义一个过滤器：

package cn.itcast.gateway.filters;import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;@Order(-1)//定义过滤器的优先级，也可以通过实现Ordered接口重写方法来代替注解
@Component
public class AuthorizeFilter implements GlobalFilter {@Overridepublic Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {// 1.获取请求参数MultiValueMap params = exchange.getRequest().getQueryParams();// 2.获取authorization参数String auth = params.getFirst("authorization");// 3.校验if ("admin".equals(auth)) {// 放行return chain.filter(exchange);}// 4.拦截// 4.1.禁止访问，设置状态码为禁止exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);// 4.2.结束处理return exchange.getResponse().setComplete();}
}

7.6.3过滤器执行顺序

请求进入网关会碰到三类过滤器：当前路由的过滤器、DefaultFilter、GlobalFilter

请求路由后，会将当前路由过滤器和DefaultFilter、GlobalFilter，合并到一个过滤器链（集合）中，排序后依次执行每个过滤器：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2NKlJt9s-1678887798066)(C:\Users\86178\Desktop\博客专用\后端\springcloud\158.png)]

• 排序规则
  • 每一个过滤器都必须指定一个 int 类型的 order 值，order 值越小，优先级越高，执行顺序越靠前。
  • GlobalFilter 通过实现 Ordered 接口，或者使用 @Order 注解来指定 order 值，由我们自己指定。
  • 路由过滤器和 defaultFilter 的 order 由 Spring 指定，默认是按照声明顺序从1递增。
  • 当过滤器的 order 值一样时，会按照 defaultFilter > 路由过滤器 > GlobalFilter 的顺序执行。

7.7跨域问题

7.7.1什么是跨域问题

跨域：域名不一致就是跨域，主要包括：

域名不同： www.taobao.com 和 www.taobao.org 和 www.jd.com 和 miaosha.jd.com

域名相同，端口不同：localhost:8080和localhost8081

跨域问题：浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题
解决方案：CORS，这个以前应该学习过，这里不再赘述了。

不知道的小伙伴可以查看https://www.ruanyifeng.com/blog/2016/04/cors.html

7.7.2解决跨域问题

在gateway服务的application.yml文件中，添加下面的配置：

spring:cloud:gateway:globalcors: # 全局的跨域处理add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题corsConfigurations:'[/**]':allowedOrigins: # 允许哪些网站的跨域请求 - "http://localhost:8090"allowedMethods: # 允许的跨域ajax的请求方式- "GET"- "POST"- "DELETE"- "PUT"- "OPTIONS"allowedHeaders: "*" # 允许在请求中携带的头信息allowCredentials: true # 是否允许携带cookiemaxAge: 360000 # 这次跨域检测的有效期

8.初识Docker

8.1项目部署的问题

大型项目组件较多，运行环境也较为复杂，部署时会碰到一些问题：

• 依赖关系复杂，容易出现兼容性问题
• 开发、测试、生产环境有差异

Docker如何解决依赖的兼容问题

• 将应用的Libs（函数库）、Deps（依赖）、配置与应用一起打包
• 将每个应用放到一个隔离容器去运行，避免互相干扰

Docker如何解决不同系统环境的问题

不同环境的操作系统不同，Docker如何解决？我们先来了解下操作系统结构

• 用户程序【MySQL】：基于系统函数库实现功能
• 系统应用【ubuntu】：封装内核指令为函数，便于程序员调用
• Linux内核：与硬件交互，提供操作硬件的指令

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5xRR5TD4-1678887798066)(C:\Users\86178\Desktop\博客专用\后端\springcloud\159.png)]

Ubuntu和CentOS都是基于Linux内核，只是系统应用不同，提供的函数库有差异。此时，如果将一个Ubuntu版本的MySQL应用安装到CentOS系统，MySQL在调用Ubuntu函数库时，会发现找不到或者不匹配，就会报错了：

Docker如何解决不同系统环境的问题？

• Docker将用户程序与所需要调用的系统(比如Ubuntu的)函数库一起打包
• Docker运行到不同操作系统时，借助于已经打包好的库函数，直接调用Linux内核来运行
• 也就是说，Docker打包好的程序包可以运行在任何一个基于Linux内核的操作系统上

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t6EgsCkd-1678887798066)(C:\Users\86178\Desktop\博客专用\后端\springcloud\160.png)]

总结：

Docker如何解决大型项目依赖关系复杂，不同组件依赖的兼容性问题？

• Docker允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像
• Docker应用运行在容器中，使用沙箱机制，相互隔离

Docker如何解决开发、测试、生产环境有差异的问题

• Docker镜像中包含完整运行环境，包括系统函数库，仅依赖系统的Linux内核，因此可以在任意Linux操作系统上运行

8.2Docker与虚拟机

• 虚拟机（virtual machine）是在操作系统中模拟硬件设备，然后运行另一个操作系统，比如在 Windows 系统里面运行Ubuntu 系统，这样就可以运行任意的Ubuntu应用了。
• Docker仅仅是封装函数库，并没有模拟完整的操作系统。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MyDWLRXN-1678887798066)(C:\Users\86178\Desktop\博客专用\后端\springcloud\161.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Tgomsrf-1678887798067)(C:\Users\86178\Desktop\博客专用\后端\springcloud\162.png)]

总结：

• docker是一个系统进程；虚拟机是在操作系统中的操作系统
• docker体积小、启动速度快、性能好；虚拟机体积大、启动速度慢、性能一般

持续更新中。。。。。