SpringCloud全面学习笔记之初尝美妙篇

￡神魔★判官ぃ 2023-09-29 21:09 13阅读 0赞

#### 目录 ####

*  前言
 *  初识微服务
 *   *  单体架构
     *  分布式架构
     *  微服务架构
     *  初见SpringCloud
     *  微服务治理
     *  分布式服务架构案例
 *  微服务组件及使用
 *   *  Eureka注册中心
     *   *  提供者和消费者
         *  Eureka的结构和作用
         *  搭建Eureka服务
         *  注册服务
         *  服务发现
         *  Eureka注册服务总结
     *  Ribbon负载均衡原理
     *   *  负载均衡原理
         *  负载均衡策略
         *  懒加载
     *  Nacos注册中心
     *   *  认识安装nacos
         *  Nacos快速入门
         *  Nacos服务分级存储模型
         *  Nacos环境隔离
         *  Nacos和Eureka的区别
     *  Nacos管理配置
     *   *  统一配置管理
         *  配置热更新
         *  配置共享
         *  搭建Nacos集群
     *  Feign远程调用
     *   *  Feign替代RestTemplate
         *  自定义配置
         *  Feign的性能优化
         *  Feign的最佳实践
     *  Gateway服务网关
     *   *  初识Gateway网关
         *  Gateway快速入门
         *  断言工厂
         *  过滤器工厂
         *  全局过滤器
         *  跨域问题
 *  未完待续

## 前言 ##

*本篇是记录黑马的SpringCloud学习过程中的笔记，该篇为实用篇的上篇，详尽记录了微服务架构，Eurake注册中心，Nacos注册及配置管理中心，Ribbon，Feign和Gateway网关；而Docker，MQ，ES等服务组件在实用篇下篇继续记录，最后感谢您的阅览，愿您终有所获*

--------------------

## 初识微服务 ##

单体项目随身业务的增加，不可避免的就是项目越来越庞大，很不利于后期项目的维护，导致项目结构变的很臃肿，耦合度高，所以，现在的服务架构也从单体项目，演变为**分布式**和**微服务**架构

--------------------

### 单体架构 ###

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

![在这里插入图片描述][a0fcda09fbf74a6aa3760548a4e4de85.png]

**优点是**

*  简单便捷
 *  易上手
 *  操作难度低

**缺点是**

*  随着业务的增加结构逐渐臃肿
 *  耦合度较高，不易于维护

--------------------

### 分布式架构 ###

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

这里引用颜老师的一句话

> 分布式的核心就一个字：**拆**。只要是将一个项目拆分成了多个模块，并将这些模块分开部署，那就算是分布式。

--------------------

*`分布式的拆分可以分为水平拆分和垂直拆分`*

> **水平拆分**

字面上理解，水平拆分就是按照三层模型来拆，“三层架构”拆分成 表示层（jsp+servlet）、业务逻辑层（service）和数据访问层（dao），然后再**分开部署各个服务器上，之间通过dubbo或RPC进行进行整合**

> **垂直拆分**

根据**业务**进行拆分。例如，可以根据**业务逻辑**，比如常见的电商系统，可以把用户模块当作一个独立的项目，同理，订单，聊天也是可以拆分为一个独立项目的。==显然这三个拆分后的项目，仍然可以作为独立的项目使用。==像这种拆分的方法，就成为**垂直拆分**。

> **分布式架构的优缺点：**

**优点：**

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

**缺点：**

*  服务调用关系错综复杂

--------------------

### 微服务架构 ###

微服务可以理解为**一种非常细粒度的垂直拆分**。例如，以上“订单项目”本来就是垂直拆分后的子项目，但实际上“订单项目”还能进一步拆分为“购物项目”、“结算项目”和“售后项目”。

> *微服务是不能再拆的“微小”服务，类似于“原子性”*

微服务的架构**四大特征**：

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

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

因此，可以认为**微服务**是一种经过良好架构设计的**分布式架构方案**

①优点：拆分粒度更小、服务更独立、耦合度更低

②缺点：架构非常复杂，运维、监控、部署难度提高

--------------------

下图就是标准的微服务架构的图解

> ***每个模块的作用与组合结构如下图关系所示***

![在这里插入图片描述][1a0069336b264d668b442aa737660043.png]

--------------------

> **注意微服务不仅仅是SpringCloud**

![在这里插入图片描述][68d0dcf41ae54b059205231bc2dce399.png]

--------------------

### 初见SpringCloud ###

SpringCloud作为Spring大家族之一，也是目前国内使用最广泛的微服务框架，SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。

> ***下面是一些常见的组件***

![在这里插入图片描述][d002bdf6901646c4a65eb6dd18ae353e.png]  
**SpringCloud底层是依赖于SpringBoot的，并且有版本的兼容关系**

--------------------

### 微服务治理 ###

在国内最知名的就是SpringCloud和阿里巴巴的Dubbo。后来阿里出的最火热的SpringCloudAlibaba框架，兼容了前两种服务协议（Dubbo，Feign）

![在这里插入图片描述][e524914f193b474b9bbf8f74ba37fd14.png]

> **微服务架构落地的四种方案**

![在这里插入图片描述][67e67fc5ffd04336aa4ebbca99e5a28f.png]

--------------------

### 分布式服务架构案例 ###

现在来演示一个小小的服务拆分的demo示例  
例如，现在我们把user模块给拆分出来，把order模块给拆分出来；步骤如下

`①首先为两个项目建立各自的数据库，导入对应的数据（sql文件）创建表`

![在这里插入图片描述][bbc08ff09cea4fd79e64362017a221f6.png]

--------------------

`②先创建boot主项目（如果是b站黑马过来的，直接导入资料文件夹下的demo项目），然后创建其他模块的项目`

注意一点，cloud底层是依赖boot的，所以cloud和boot版本需要一一对应，这重要，具体对应关系如下表

![在这里插入图片描述][af28a984fb304ef3962c15afad80b000.png]  
例如下面是主项目工程的pom文件

![在这里插入图片描述][a1e66d7553c7400583bb4d8a6963fa50.png]  
主项目工程中的依赖

<dependencyManagement>
            <dependencies>
                
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${
        spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>${
        mysql.version}</version>
                </dependency>
                
                <dependency>
                    <groupId>org.mybatis.spring.boot</groupId>
                    <artifactId>mybatis-spring-boot-starter</artifactId>
                    <version>${
        mybatis.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>

然后创建子模块项目，boot版本高了，创建好后手动降低版本，就是在parent那块，把version手动调整刷新就好了

具体项目结构如下图

![在这里插入图片描述][03d29c4e55eb41ee8f81a71340d749bd.png]  
然后完善子模块，先写一个基本查询业务，mapper层，service层，controller层，没什么好说的，如果用上mp的api，甚至可以更快。

接下来把user-service 和 cloud-service项目都启动起来，然后浏览器访问http://localhost:8080/order/101，可以看到订单信息的数据已经查询出来了

![在这里插入图片描述][909ed3f790474206b1b1b01c380df350.png]

--------------------

`③实现远程调用`

但是如上图其中的user属性是null，这是因为order表中没有user字段，如果是以前的单体项目就是直接来个两表联查，但是对于微服务项目，每个模块负责各自的业务，不允许业务重复，这是就需要远程调用出手了

我们需要在order-service中 向user-service发起一个http的请求，调用http://localhost:8081/user/\{userId\}这个接口。

![在这里插入图片描述][fc0b76e91741417da3359b1775543042.png]

> **大概的步骤是这样的：**

*  注册一个RestTemplate的实例到Spring容器
 *  修改order-service服务中的OrderService类中的queryOrderById方法，根据Order对象中的userId查询User
 *  将查询的User填充到Order对象，一起返回

--------------------

**实现如下**  
在order-service项目中的启动类里，注册RestTemplate实例

@MapperScan("cn.order.mapper")
    @SpringBootApplication
    public class OrderApplication {
        
    
        public static void main(String[] args) {
        
            SpringApplication.run(OrderApplication.class, args);
        }
        
        @Bean
        public RestTemplate restTemplate(){
        
            return new RestTemplate();
        }
    }

修改order-service服务中的service层下的OrderService类中的queryOrderById方法：

@Service
    public class OrderService {
        
    
        @Resource
        private OrderMapper orderMapper;
        @Resource
        private RestTemplate restTemplate;
    
        public Order queryOrderById(Long orderId) {
        
            // 1.查询订单
            Order order = orderMapper.findById(orderId);
            // 2.远程查询user
            // 2.1 url地址
            String url = "http://localhost:8081/user" + order.getUserId();
            // 2.2 发起调用
            User user = restTemplate.getForObject(url, User.class);
            // 3. 存入order
            order.setUser(user);
            // 4.返回
            return order;
        }
    }

然后再次重启两个服务，再去浏览器访问order服务，会发现user也查询出来了

![在这里插入图片描述][c668d7b0688c49e38a400dd63f189107.png]

--------------------

## 微服务组件及使用 ##

### Eureka注册中心 ###

#### 提供者和消费者 ####

如上面的分布式案例，在需要其他模块数据信息时，是用远程调用对应的模块服务，其中在服务调用关系中，会有两个不同的角色：  
**服务提供者**：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）

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

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

下面一个例子便于理解  
如果服务A调用了服务B，而服务B又调用了服务C，服务B的角色是什么？

*  对于A调用B的业务而言：A是服务消费者，B是服务提供者
 *  对于B调用C的业务而言：B是服务消费者，C是服务提供者

因此，服务B既可以是服务提供者，也可以是服务消费者。

--------------------

#### Eureka的结构和作用 ####

如果服务的提供者**部署了多个实例**，在进行服务的远程调用时，会发生以下问题：

*  order-service在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？
 *  有多个user-service实例地址，order-service调用时该如何选择？
 *  order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

而在这种集群项目结构下，Eureka义不容辞的来了

--------------------

Eureka是SpringCloud中的注册中心，也是最广为人知的注册中心  
**结构如下**

![在这里插入图片描述][79fe62dddc944531bbba439dff527a5f.png]

回答之前的各个问题。

> *问题1：order-service如何得知user-service实例地址？*

获取地址信息的流程如下：

*  user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端）。这个叫服务注册
 *  eureka-server保存服务名称到服务实例地址列表的映射关系
 *  order-service根据服务名称，拉取实例地址列表。这个叫服务发现或服务拉取

> *问题2：order-service如何从多个user-service实例中选择具体的实例？*

*  order-service从实例列表中利用负载均衡算法（例如轮询，随机，权重）选中一个实例地址
 *  向该实例地址发起远程调用

> *问题3：order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？*

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

> 注意：一个微服务，既可以是服务提供者，又可以是服务消费者，因此eureka将服务注册、服务发现等功能统一封装到了eureka-client端

--------------------

#### 搭建Eureka服务 ####

> **1.引入eureka依赖**

注册中心服务端：eureka-server，这必须是一个独立的微服务（独立的子项目，建议创建maven项目，如果你想用boot我也没意见），只需要在它的pom文件中加入eureka的依赖即可，其他的例如版本信息和其他依赖都在父工程中加了，它是继承了父工程的依赖

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

> **2.编写启动类**

给eureka-server服务编写一个启动类，一定要添加一个@EnableEurekaServer注解，开启eureka的注册中心功能：

@SpringBootApplication
    @EnableEurekaServer
    public class EurekaApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(EurekaApplication.class, args);
        }
    }

> **3.编写配置文件**

resource文件夹下编写一个application.yml文件

server:
      port: 10086
    spring:
      application:
        name: eureka-server
    eureka:
      client:
        service-url: 
          defaultZone: http://127.0.0.1:10086/eureka

> **4.启动服务**

配置完毕后，可以启动服务看看是否搭建成功，访问http://localhost:10086/

![在这里插入图片描述][1fe2f0240bea403a831c74a2f7111ff1.png]

--------------------

#### 注册服务 ####

> **1.引入依赖**

不同于上面搭建eureka服务的依赖了，这回注入的是client

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

注：在服务提供者的pom文件中引入该依赖

> **2.配置文件**

在服务提供者user-service中，修改application.yml文件，添加服务名称、eureka服务地址

spring:
      application:
        name: userservice
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:10086/eureka

> **启动多个user-service实例（可选）**

这里是为了演示一个服务有多个实例的场景时，轮询策略远程调用，我们添加一个SpringBoot的启动配置，再启动一个user-service。

首先，复制原来的user-service启动配置：

![在这里插入图片描述][860b90dbdda4475fa5c8ed073cd981e7.png]

然后，在弹出的窗口中，作一下配置：

![在这里插入图片描述][2f9e3ab3bf484dedab1d4b8721d162ee.png]

现在，SpringBoot窗口会出现两个user-service启动配置，第一个是8081端口，第二个是8082端口。  
启动新添的user-server实例

![在这里插入图片描述][52c32e82914142cc957a12136a11055d.png]

现在再访问http://localhost:10086 看看服务是否已经注册成功

![在这里插入图片描述][44f77062c2c2422c8e09d12afd6de1da.png]

--------------------

#### 服务发现 ####

将order-service的逻辑修改：向eureka-server拉取user-service的信息，实现服务发现。

> **1.引入依赖**

**服务发现、服务注册统一都封装在eureka-client依赖**，因此这一步与服务注册时一致。

在order-service的pom文件中，引入下面的eureka-client依赖：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

> **2.配置文件**

服务发现也需要知道eureka地址，因此第二步与服务注册一致，都是配置eureka信息：

在order-service中，修改application.yml文件，添加服务名称、eureka地址：

spring:
      application:
        name: orderservice
    eureka:
      client:
        service-url:
          defaultZone: http://127.0.0.1:10086/eureka

> **3.服务拉取和负载均衡**

最后，我们要去eureka-server中拉取user-service服务的实例列表，并且实现负载均衡。

在服务消费者order-service的OrderApplication中，给RestTemplate这个Bean添加一个@LoadBalanced注解：轮询策略

![在这里插入图片描述][548a14809e10451a841a2a7f28f6d84c.png]

修改order-service服务中的OrderService类中的queryOrderById方法。修改访问的url路径，**用服务名代替ip、端口**：

![在这里插入图片描述][430c6609e0aa4af29d9e04964bda76e9.png]

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

--------------------

> **4.最后测试结果**

![在这里插入图片描述][450864b9b1b6458b9285bda02a76827a.png]  
![在这里插入图片描述][dc9b812a173948b8b111523139090160.png]

成功远程调用了user-service服务查询道理user信息

--------------------

#### Eureka注册服务总结 ####

**1．搭建EurekaServer**

*  引入eureka-server依赖
 *  添加@EnableEurekaServer注解·在application.yml中配置eureka地址

**2．服务注册**

*  引入eureka-client依赖
 *  在application.yml中配置eureka地址

**3．服务发现**

*  引入eureka-client依赖
 *  在application.yml中配置eureka地址
 *  给RestTemplate添加@LoadBalanced注解·用服务提供者的服务名称远程调用

--------------------

### Ribbon负载均衡原理 ###

Ribbon（谐音：瑞本），我怕自己读不标准，记一下

上面做了Eureka服务注册后，就自动拉取服务并完成了负载均衡。那什么时候自动拉取，什么时候做的负载均衡呢，下面就来探究负载均衡原理

#### 负载均衡原理 ####

1.当服务消费者发起远程调用服务请求

--------------------

2.其中的LoadBalancerIntercepor会对请求进行拦截  
然后做了几件事：

*  `request.getURI()`：获取请求uri，本例中就是 http://user-service/user/8
 *  `originalUri.getHost()`：获取uri路径的主机名，其实就是服务id，也就是`user-service`
 *  `this.loadBalancer.execute()`：处理服务id，和用户请求。

--------------------

3.断点下一步继续跟进上面的execute方法（这一步完成了获取eureka中注册的对应的服务，并获取了指定的负载均衡策略）

![在这里插入图片描述][896df6eac5044c07ae5d2c3e183f4a2d.png]

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

--------------------

4.负载均衡策略IRule  
在上面的代码中，可以看到获取服务使通过一个`getServer`方法来做负载均衡:

下面就是源码跟进，不断跟到底，看看到底是谁在帮我们做负载均衡

![在这里插入图片描述][08379ef9b7c444d285d4504f05fd50c8.png]

> 最后下面是一个负载均衡流程图，这个图会更容易理解从请求远程服务调用负载均衡的流程

![在这里插入图片描述][f1744dede3574af095798e3b29020624.png]

**基本流程如下**：

*  拦截我们的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，发起真实请求

--------------------

#### 负载均衡策略 ####

Ribbon的负载均衡规则是一个叫做IRule的接口来定义的，**每一个子接口都是一种规则**：

![在这里插入图片描述][9efdca040a3742bda3982835605027aa.png]

不同规则的含义如下：

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

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

--------------------

> **自定义负载均衡策略**

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

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

@Bean
    public IRule randomRule(){
        
        return new RandomRule();
    }

这个是全局配置，order-service这个服务在调用其他微服务也都是会遵循这个配置的策略

--------------------

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

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

这个在yml文件中添加的配置只在当前微服务有效，是局部配置

**注意，一般用默认的负载均衡规则，不做修改。**

--------------------

#### 懒加载 ####

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。

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

ribbon:
      eager-load:
        enabled: true
        clients: userservice

--------------------

### Nacos注册中心 ###

由于国内公司一般都推崇阿里巴巴的技术，比如注册中心，SpringCloudAlibaba也推出了一个名为Nacos的注册中心，相比Eureka功能更加丰富，使用更广泛

#### 认识安装nacos ####

nacos1.4.1下载：[nacos下载][nacos]  
提取码：olww  
下载完毕后在bin目录下，键入cmd启动

![在这里插入图片描述][c54775dd6aee4a0e92f33c6182281caa.png]

输入以下命令，因为它默认是集群启动， 这里设置为单体启动

startup.cmd -m standalone

![在这里插入图片描述][0b2610fe86c24c7da3645900eb25bf73.png]

浏览器跟上这个地址  
http://localhost:8848/nacos/index.html

用户名密码都是nacos，登录进去

![在这里插入图片描述][bd95a6fad4c7477aac59aad0c43394d7.png]

--------------------

#### Nacos快速入门 ####

`1.父工程导入SpringCloudAlibaba的依赖`

<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>2.2.6.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>

`2.在user-service和order-service中的pom文件中引入nacos-discovery依赖`

<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

**记得注释掉原来的eureka依赖**

`3.配置nacos地址`  
在导入nacos依赖的项目的yml文件中加上nacos配置

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

`4.启动服务，然后再前面打开的nacos网页中查看`

![在这里插入图片描述][ccbd548d2af04b17a9063abbda938fe9.png]

--------------------

#### Nacos服务分级存储模型 ####

一般大厂都会做集群来容灾，保证当本地服务宕机后，仍然能够正常运转（访问别处的服务）  
比如当它的杭州服务器发生故障导致宕机，那么它就会访问上海的服务，来保证功能的正常运转  
有点互为备胎的意思

Nacos就将同一机房内的实例 划分为一个**集群**。  
user-service是服务，一个服务可以包含多个集群，如杭州、上海，每个集群下可以有多个实例，形成**分级模型**，——>其实就是分为服务——集群——实例这三层  
![在这里插入图片描述][c4a9ecf46b444b508ae7f1ef9f8570de.png]  
微服务互相访问时，应该尽可能访问同集群实例，因为本地访问速度更快。当本集群内不可用时，才访问其它集群

> 给服务配置集群

yml配置文件中加上

![在这里插入图片描述][c4ee6a68cf0f43939a7e8a38186aa868.png]  
名称随意

--------------------

> **NacosRule负载均衡策略**

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

①**优先**选择同集群服务实例列表  
②本地集群找不到提供者，才去其它集群寻找，并且会报警告  
③确定了可用实例列表后，再采用**随机**负载均衡挑选实例

--------------------

> **权重负载均衡**

实际部署中会出现这样的场景：

服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求。

但默认情况下NacosRule是同集群内随机挑选，不会考虑机器的性能问题。  
但我们需要考虑到能者多劳，所以权重配置就来了，根据不同的权重设置可以控制访问的频率，**权重越大访问频率越高**

> 当权重为0时，就不会通过该服务器进行访问了

以前一个服务要版本更新升级，就需要服务重启，但是不可能光天化日之下升级，导致用户都访问失败，往往是在夜深人静时偷偷升级。不是很方便。  
而权重策略的作用之一就是，项目更新升级时，把对应的服务器权重调低，放入少量用户测试看看刚上线功能是否通过，做到平滑升级。  
举个例子，某种游戏，有时候会发出公告，不停服更新，就是这么来的

> **实例的权重控制**

①Nacos控制台可以设置实例的权重值  
②0~1之间同集群内的多个实例，权重越高被访问的频率越高  
③权重设置为0则完全不会被访问

--------------------

#### Nacos环境隔离 ####

默认情况下，所有service、data、group都在同一个namespace，名为public  
Nacos提供了namespace来实现环境隔离功能。

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

***具体操作如下***

![在这里插入图片描述][df143f6bd2764bac9435d84b7d98f267.png]

![在这里插入图片描述][33df7ca716da489cbce2bcb7c1a8b396.png]

![在这里插入图片描述][40e39757385b41d98d52a43fc66d1cf4.png]

--------------------

> **Nacos环境隔离**

namespace用来做环境隔离，每个namespace都有唯一id，不同namespace下的服务不可见

--------------------

#### Nacos和Eureka的区别 ####

Nacos（谐音：哪克四）；Eureka（谐音：衣锐咔）我自己英语读的不标准，记录一下，免得下回和别人聊天，只会读拼写。搞得别人一脸懵圈说你和我说的是同一个技术吗？

回归正题

Nacos是主动把注册服务列表推送给服务消费者，如果有服务挂掉了，就立马推送新的服务列表  
Eureka是定时从注册中心拉去服务列表，所以它的服务列表更新效率稍逊于Nacos  
![在这里插入图片描述][bfdd287357394a6690106f987032e48d.png]

--------------------

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

*  临时实例：如果实例宕机超过一定时间（不主动发送心跳信息），会从服务列表剔除，默认的类型。
 *  非临时实例：nacos会主动询问实例的心跳信息，如果实例宕机，也不会从服务列表剔除，也可以叫永久实例。

在配置中设置实例类型  
![在这里插入图片描述][43d031a9aa914dc2a3654a04b7cf62be.png]

--------------------

> **最后总结**

`Nacos与eureka的共同点`

*  都支持服务注册和服务拉取
 *  都支持服务提供者心跳方式做健康检测

`Nacos与Eureka的区别`

*  Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
 *  临时实例心跳不正常会被剔除，非临时实例则不会被剔除
 *  Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
 *  Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式；Eureka采用AP方式

--------------------

### Nacos管理配置 ###

#### 统一配置管理 ####

> **使用场景**

当一个集群中微服务过多，成千上百个时，需要更改其中一个微服务的配置信息，那么其他远程调用该服务的成千上百个服务都需要重启，这在生产环境中几乎是不可能的

**所以，我们需要一种统一配置管理方案，可以集中管理所有实例的配置**

![在这里插入图片描述][0e508dd8f92e472d95f284dd545e156a.png]

--------------------

![在这里插入图片描述][e3ab480a9e02415b820e293b97dafccd.png]

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

--------------------

> **添加配置信息**

![在这里插入图片描述][785012a0792243a8b1c8a7a0d8c56963.png]

![在这里插入图片描述][ee772a705df542739bd4717c82918183.png]

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

--------------------

> **从微服务中拉去服务**

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

而nacos的地址等配置信息在applicationyml中，但如果尚未读取application.yml，又如何得知nacos地址  
因此spring引入了一种新的配置文件：bootstrap.yaml文件，**会在application.yml之前被读取**

![在这里插入图片描述][d20717a945f94d608e150d607fea0cd7.png]

`1.导入Nacos配置管理依赖`

<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>

`2.添加bootstrap.yaml`  
然后，在resource文件夹下中添加一个bootstrap.yaml文件

spring:
      application:
        name: userservice # 服务名称
      profiles:
        active: dev #开发环境，这里是dev 
      cloud:
        nacos:
          server-addr: localhost:8848 # Nacos地址
          config:
            file-extension: yaml # 文件后缀名

这里会根据spring.cloud.nacos.server-addr获取nacos地址，再根据name，active，extension来读取对应配置  
![在这里插入图片描述][6dabbfaa9c5f4d7eb71f23a99babb122.png]

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

![在这里插入图片描述][c217d6dc194e4224bb248cdddece5751.png]

![在这里插入图片描述][375c9c17dfb245e59cba2f0eae9e807b.png]

按照我们规定的格式完成日期格式化并返回

![在这里插入图片描述][0f12c7cfa6914c7cbd8e7415b6fc8a52.png]

表示成功拉去到了Nacos中的配置信息了

--------------------

#### 配置热更新 ####

Nacos中的配置文件变更后，微服务无需重启就可以感知（就是直接刷新网页就会更新配置）。可以通过下面两种配置方式实现:

> **方式一**

在@Value注入的变量所在类上添加注解@RefreshScope：  
![在这里插入图片描述][f2f76d7a4ef94cf2bbe8aeda53d11026.png]

--------------------

> **方式二**

使用@ConfigurationProperties注解代替@Value注解。

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

@Component
    @Data
    @ConfigurationProperties(prefix = "pattern")
    public class PatternProperties {
        
        private String dateformat;
    }

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

![在这里插入图片描述][702778179d6846448e2b24ac4546f358.png]

--------------------

#### 配置共享 ####

有一些属性在开发，测试等多个环境值都是一样的，为避免修改该配置的值，要取一个一个的修改；就引用了配置共享方法，把相同的配置放在共享配置中，就像类中的public static修饰的变量一样

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

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

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

**配置优先级**  
远程专属配置 > 远端共享配置 > 本地配置

![在这里插入图片描述][f50f1202f85e437caf275d4ead9f8cf0.png]

--------------------

#### 搭建Nacos集群 ####

学习阶段，没有那么多机子，只能搞搞简略版，把服务都配在本地一台上

前提：搭建mysql集群，初始化数据库表，条件有限也可以只用一台mysql数据库

①把nacos压缩包解压缩  
![在这里插入图片描述][d44b4dec757d4843ac477ebb175046b9.png]

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

![在这里插入图片描述][28d62044fac04b468073ec22e7cda813.png]  
③然后添加内容：（因为只是把三台配在本地没有三台服务器，所以都是本地ip，端口选没使用的就行）

![在这里插入图片描述][81e2e1881c92447f93086fea26d3111a.png]

127.0.0.1:8845
    127.0.0.1.8846
    127.0.0.1.8847

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

![在这里插入图片描述][b22b8761b70140be8796a6a11cc007d1.png]

⑤将nacos文件夹复制三份，然后分别修改三个文件夹中的application.properties，  
![在这里插入图片描述][117c8e94dbef41cb967525693f8132bf.png]

![在这里插入图片描述][342e2174ecfe4a78a706c7b2049d6f3e.png]

nacos1:

server.port=8845

nacos2:

server.port=8846

nacos3:

server.port=8847

⑥然后分别启动三个nacos节点、

就是bin目录下的startup.cmd，因为它默认就是集群启动的，双击即可

⑦使用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;
        }
    }

--------------------

⑧代码中application.yml文件配置如下：

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

--------------------

这时候在nacos中创建新的配置会存到数据库里面去，完成持久化了

> ***优化***

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

--------------------

### Feign远程调用 ###

前面都是完成了服务注册,配置中心nacos相关，但是服务拉取的部分是用的RestTemplate

以前利用RestTemplate发起远程调用的代码：  
![在这里插入图片描述][30470437dd0f469d9656694fe96647c1.png]  
存在下面的问题：

•代码可读性差，编程体验不统一

•参数复杂URL难以维护

--------------------

Feign是一个声明式的http客户端，其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。

--------------------

#### Feign替代RestTemplate ####

`①引入Feign依赖`  
pom文件中引入feign的依赖：

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

`②添加注解`  
在启动类上添加注解开启Feign的功能：

![在这里插入图片描述][c1f25e02bd224a1096216bf6011d3c5c.png]  
`③编写Feign的客户端`  
下面是以以前demo的order-service为例

@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来发送了。

`④在业务方法中替换以前的RestTemplate`  
就不会像以前那样在业务代码中添加url，可读性很低，代码也不简洁  
![在这里插入图片描述][04c5a97b862648e2b1d9fb75772469d9.png]

最后，可以看到最后也完成了远程调用，而且代码更加简洁，同时多试几次，会发现feign不仅实现了服务拉取，而且实现了负载均衡

![在这里插入图片描述][d8eb6614acdf48af8dac4d07f290a5aa.png]

![在这里插入图片描述][0795156a64e04e0eba0df7cd928c3288.png]

`⑤总结`

> *使用Feign的步骤：*

① 引入依赖

② 添加@EnableFeignClients注解

③ 编写FeignClient接口

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

--------------------

#### 自定义配置 ####

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

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

一般情况下，默认值就能满足我们使用，如果要自定义时，只需要创建自定义的@Bean覆盖默认Bean即可。

--------------------

> **配置文件方式**

基于配置文件修改feign的日志级别可以针对单个服务：

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

也可以针对所有服务：

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

--------------------

> **Java代码方式**

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

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

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

@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class)

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

@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration .class)

> **而日志的级别分为四种：**

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

> 调试错误时可以用FULL，但是平常时候一般还是用NONE 和 BASIC

--------------------

#### Feign的性能优化 ####

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

•URLConnection：默认实现，不支持连接池所以性能不是很好，**因为连接池可以减少连接的创建和销毁的连接损耗（因为每次连接都需要三次握手和四次挥手）**

•Apache HttpClient ：支持连接池

•OKHttp：支持连接池

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

这里用Apache的HttpClient来演示。

`①引入依赖`

<dependency>
        <groupId>io.github.openfeign</groupId>
        <artifactId>feign-httpclient</artifactId>
    </dependency>

`②配置文件中做相应的配置`

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

> ***总结，Feign的优化：***

1.日志级别尽量用basic

2.使用HttpClient或OKHttp代替URLConnection

*  ① 引入feign-httpClient依赖
 *  ② 配置文件开启httpClient功能，设置连接池参数

--------------------

#### Feign的最佳实践 ####

最佳实践就是前辈们不断踩坑后总结的经验，也是Feign最好的一种使用方式

feign客户端：  
![在这里插入图片描述][0181ac9d3f914b19851c4bd7a4632d2c.png]UserController：  
![在这里插入图片描述][57be7ba566d44c228422e999837884e4.png]

观察可以发现，Feign的客户端与服务提供者的controller代码非常相似，为了简化这种重复的代码编写，下面有两种实现方式

> **继承方式**

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

1）定义一个API接口，利用定义方法，并基于SpringMVC注解做声明。

2）Feign客户端和Controller都集成改接口

![在这里插入图片描述][831833f2295140dbbb1fc9ae07518abf.png]

优点：

*  简单容易
 *  实现了代码共享

缺点：

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

--------------------

> **抽取方式**

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

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

![在这里插入图片描述][bbe2fa12ccf74d0fa112868c07125020.png]  
缺点：一些服务不需要的依赖也被统一引入了

**总结**  
*Feign的最佳实践:*  
`①让controller和FeignClient继承同一接口`

`②将FeignClient、POJO、Feign的默认配置都定义到一个项目中，供所有消费者使用`

--------------------

> **代码实现**

下面是对第二种方式——抽取的实现

第一步，创建feign模块做统一api，并把前面demo中order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到feign-api项目中

![在这里插入图片描述][054ee6bbbc964c4685040a56d04ec469.png]

--------------------

第二步，在feign-api中然后引入feign的starter依赖

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

--------------------

第三步，可以把前面order-service中的实体类和feign的Client都删掉了，在其pom文件中导入刚编写的eign-api模块

![在这里插入图片描述][dfe11ee8688e408d9512e71668736cc2.png]

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

--------------------

第四步，注入到Spring容器中

当定义的FeignClient不在SpringBootApplication的扫描包范围时，这些FeignClient无法使用。有两种方式解决：  
方式一：指定FeignClient所在包

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

方式二：指定FeignClient字节码

@EnableFeignClients(clients = {
        UserClient.class})

一般推荐用第二种，精准打击

![在这里插入图片描述][062bbda85b174b1d83bdd46be850a473.png]

--------------------

### Gateway服务网关 ###

#### 初识Gateway网关 ####

Gateway网关是我们服务的门卫，是所有微服务的统一入口。

> **网关的三个核心的功能如下**

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

在SpringCloud中网关的实现包括两种：

*  gateway
 *  zuul

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

--------------------

#### Gateway快速入门 ####

要实现网关的基本路由功能，基本步骤如下：

1.  创建SpringBoot工程gateway，引入网关依赖
2.  编写启动类
3.  编写基础配置和路由规则
4.  启动网关服务进行测试

--------------------

> **代码实现**

`1.创建一个gateway模块作为服务，引入gateway和nacos服务发现依赖`

建议创建maven工程，boot工程的话要改版本

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

--------------------

`2.在gateway模块中编写启动类`

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

--------------------

`3.配置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/开头就符合要求

将符合`Path` 规则的一切请求，都代理到 `uri`参数指定的地址。

我们将 `/user/**`开头的请求，代理到`lb://userservice`，lb是负载均衡，根据服务名拉取服务列表，实现负载均衡。

--------------------

`4.启动网关服务，访问网关服务端口，测试结果如下图，可以通过网关然后访问到服务`

![在这里插入图片描述][2b37f00dcc834ed9b3203c5437d99926.png]  
报错503  
新版本的nacos一定要加上 spring-cloud-starter-loadbalancer 依赖，用于替换ribbon

--------------------

> 网关路由的流程图

![在这里插入图片描述][d0461f6de53e4cd8996fbf5455c5dd38.png]

--------------------

最后，总结流程步骤

**网关搭建步骤：**

1.  创建项目，引入nacos服务发现和gateway依赖
2.  创建GatewayApplication启动类
3.  配置application.yml，包括服务基本信息、nacos地址、路由

--------------------

**路由配置包括：**

1.  路由id：路由的唯一标示（一般为服务名但要求不重复）
2.  **路由目标（uri）：路由的目标地址，http代表固定地址，lb代表根据服务名负载均衡**
3.  路由断言（predicates）：判断路由的规则，
4.  路由过滤器（filters）：对请求或响应做处理

--------------------

#### 断言工厂 ####

我们在配置文件中写的断言规则只是字符串，这些字符串会被Predicate Factory读取并处理，转变为路由判断的条件  
例如Path=/user/\*\*是按照路径匹配

> **断言**(assertion)：是一种在程序中的一阶逻辑(如：一个结果为真或假的逻辑判断式)，目的为了表示与验证软件开发者预期的结果——当程序执行到断言的位置时，对应的断言应该为真。若断言不为真时，程序会中止执行，并给出错误信息。

大白话就是判断，返回值是true或者false

断言工厂在SpringCloudGateway还有十几个:

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

不需要记，随用随查即可，而且也记不住，一般只需要掌握Path这种路由工程就可以了

**总结：**

> PredicateFactory的作用是什么？

读取用户定义的断言条件，对请求做出判断

> Path=/user/\*\*是什么含义？

路径是以/user开头的就认为是符合的

--------------------

#### 过滤器工厂 ####

GatewayFilter是网关中提供的一种过滤器，可以对进入网关的请求和微服务返回的响应做处理：  
![在这里插入图片描述][a17fb59843be42f7bb255b0157161e8a.png]

> **路由过滤器的种类**

Spring提供了31种不同的路由过滤器工厂。下面是几种常见的过滤器：

<table> 
 <thead> 
  <tr> 
   <th><strong>名称</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>AddRequestHeader</td> 
   <td>给当前请求添加一个请求头</td> 
  </tr> 
  <tr> 
   <td>RemoveRequestHeader</td> 
   <td>移除请求中的一个请求头</td> 
  </tr> 
  <tr> 
   <td>AddResponseHeader</td> 
   <td>给响应结果中添加一个响应头</td> 
  </tr> 
  <tr> 
   <td>RemoveResponseHeader</td> 
   <td>从响应结果中移除有一个响应头</td> 
  </tr> 
  <tr> 
   <td>RequestRateLimiter</td> 
   <td>限制请求的流量</td> 
  </tr> 
 </tbody> 
</table>

*这里以请求投过滤器为例，来写个案例示范*

**需求**：给所有进入userservice的请求添加一个请求头：Hello World

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

spring:
      cloud:
        gateway:
          routes:
          - id: user-service 
            uri: lb://userservice 
            predicates: 
            - Path=/user/** 
            filters: # 过滤器
            - AddRequestHeader=Head, Hello World # 添加请求头

![在这里插入图片描述][3d6c06ca44994d159dfd8c3ed6b19c18.png]

--------------------

测试效果

![在这里插入图片描述][633c6de12aaf44b195db0bec94b3a2ae.png]  
![在这里插入图片描述][10955d122c4a42f98335cb23c90154a0.png]

结果如下

![在这里插入图片描述][c5b6887fd53a44708565247b4638f3b8.png]  
![在这里插入图片描述][f2d24a7caf784ff2b2e2b8508165f967.png]

--------------------

> 默认过滤器

上面加的过滤器是只针对对应的路由有效，若要像对所有路由都有效，就可以配置默认过滤器

如果要对所有的路由都生效，则可以将过滤器工厂写到default下

spring:
      cloud:
        gateway:
          routes:
          - id: user-service 
            uri: lb://userservice 
            predicates: 
            - Path=/user/**
          default-filters: # 默认过滤项
          - AddRequestHeader=Head, Hello World

--------------------

> **总结**

**过滤器的作用是什么？**

① 对路由的请求或响应做加工处理，比如添加请求头

② 配置在路由下的过滤器只对当前路由的请求生效

--------------------

**defaultFilters的作用是什么？**

对所有路由都生效的过滤器

--------------------

#### 全局过滤器 ####

虽然默认过滤器已经实现了全局过滤路由的功能了，但是不能自定义，无法进行定制过滤

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

定义方式是实现GlobalFilter接口。  
在filter中编写自定义逻辑，可以实现下列功能：

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

--------------------

> **自定义全局过滤器**

**范例**  
需求：定义全局过滤器，拦截请求，判断请求的参数是否满足下面条件：

*  参数中是否有authorization，
 *  authorization参数值是否为admin

如果同时满足则放行，否则拦截

在gateway中定义一个过滤器：

**这个@Order(-1)是指定过滤器执行的顺序，比如有很多过滤器时，这个就是指定谁先执行谁后执行，值越小，越先执行**

@Order(-1)
    @Component
    public class AuthorizeFilter implements GlobalFilter {
        
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        
            // 1.获取请求参数
            MultiValueMap<String, String> 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();
        }
    }

结果如下图

![在这里插入图片描述][fa6d50d2bd9e4510aa95b651ad1b20b8.png]

--------------------

> **过滤器执行顺序**

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

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

![在这里插入图片描述][ed683873789f484f8cbaf7c64d4393a8.png]  
**排序的规则**

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

--------------------

#### 跨域问题 ####

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

*  域名不同： www.taobao.com 和 www.taobao.org 和 www.jd.com 和 miaosha.jd.com
 *  域名相同，端口不同：localhost:8080和localhost8081

跨域问题：浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题  
解决方案：CORS  
[CORS详解][CORS]

--------------------

**解决跨域问题**

在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 # 是否允许携带cookie
                maxAge: 360000 # 这次跨域检测的有效期

--------------------

## 未完待续 ##

受篇幅限制，微服务的剩余组件：Docker，MQ，ES的使用及解析在下篇继续记录。感谢您的阅览

[a0fcda09fbf74a6aa3760548a4e4de85.png]: https://img-blog.csdnimg.cn/a0fcda09fbf74a6aa3760548a4e4de85.png
[1a0069336b264d668b442aa737660043.png]: https://img-blog.csdnimg.cn/1a0069336b264d668b442aa737660043.png
[68d0dcf41ae54b059205231bc2dce399.png]: https://img-blog.csdnimg.cn/68d0dcf41ae54b059205231bc2dce399.png
[d002bdf6901646c4a65eb6dd18ae353e.png]: https://img-blog.csdnimg.cn/d002bdf6901646c4a65eb6dd18ae353e.png
[e524914f193b474b9bbf8f74ba37fd14.png]: https://img-blog.csdnimg.cn/e524914f193b474b9bbf8f74ba37fd14.png
[67e67fc5ffd04336aa4ebbca99e5a28f.png]: https://img-blog.csdnimg.cn/67e67fc5ffd04336aa4ebbca99e5a28f.png
[bbc08ff09cea4fd79e64362017a221f6.png]: https://img-blog.csdnimg.cn/bbc08ff09cea4fd79e64362017a221f6.png
[af28a984fb304ef3962c15afad80b000.png]: https://img-blog.csdnimg.cn/af28a984fb304ef3962c15afad80b000.png
[a1e66d7553c7400583bb4d8a6963fa50.png]: https://img-blog.csdnimg.cn/a1e66d7553c7400583bb4d8a6963fa50.png
[03d29c4e55eb41ee8f81a71340d749bd.png]: https://img-blog.csdnimg.cn/03d29c4e55eb41ee8f81a71340d749bd.png
[909ed3f790474206b1b1b01c380df350.png]: https://img-blog.csdnimg.cn/909ed3f790474206b1b1b01c380df350.png
[fc0b76e91741417da3359b1775543042.png]: https://img-blog.csdnimg.cn/fc0b76e91741417da3359b1775543042.png
[c668d7b0688c49e38a400dd63f189107.png]: https://img-blog.csdnimg.cn/c668d7b0688c49e38a400dd63f189107.png
[79fe62dddc944531bbba439dff527a5f.png]: https://img-blog.csdnimg.cn/79fe62dddc944531bbba439dff527a5f.png
[1fe2f0240bea403a831c74a2f7111ff1.png]: https://img-blog.csdnimg.cn/1fe2f0240bea403a831c74a2f7111ff1.png
[860b90dbdda4475fa5c8ed073cd981e7.png]: https://img-blog.csdnimg.cn/860b90dbdda4475fa5c8ed073cd981e7.png
[2f9e3ab3bf484dedab1d4b8721d162ee.png]: https://img-blog.csdnimg.cn/2f9e3ab3bf484dedab1d4b8721d162ee.png
[52c32e82914142cc957a12136a11055d.png]: https://img-blog.csdnimg.cn/52c32e82914142cc957a12136a11055d.png
[44f77062c2c2422c8e09d12afd6de1da.png]: https://img-blog.csdnimg.cn/44f77062c2c2422c8e09d12afd6de1da.png
[548a14809e10451a841a2a7f28f6d84c.png]: https://img-blog.csdnimg.cn/548a14809e10451a841a2a7f28f6d84c.png
[430c6609e0aa4af29d9e04964bda76e9.png]: https://img-blog.csdnimg.cn/430c6609e0aa4af29d9e04964bda76e9.png
[450864b9b1b6458b9285bda02a76827a.png]: https://img-blog.csdnimg.cn/450864b9b1b6458b9285bda02a76827a.png
[dc9b812a173948b8b111523139090160.png]: https://img-blog.csdnimg.cn/dc9b812a173948b8b111523139090160.png
[896df6eac5044c07ae5d2c3e183f4a2d.png]: https://img-blog.csdnimg.cn/896df6eac5044c07ae5d2c3e183f4a2d.png
[08379ef9b7c444d285d4504f05fd50c8.png]: https://img-blog.csdnimg.cn/08379ef9b7c444d285d4504f05fd50c8.png
[f1744dede3574af095798e3b29020624.png]: https://img-blog.csdnimg.cn/f1744dede3574af095798e3b29020624.png
[9efdca040a3742bda3982835605027aa.png]: https://img-blog.csdnimg.cn/9efdca040a3742bda3982835605027aa.png
[nacos]: https://pan.baidu.com/s/1HkqfH52fqOiNCAcll0PJeg?pwd=olww
[c54775dd6aee4a0e92f33c6182281caa.png]: https://img-blog.csdnimg.cn/c54775dd6aee4a0e92f33c6182281caa.png
[0b2610fe86c24c7da3645900eb25bf73.png]: https://img-blog.csdnimg.cn/0b2610fe86c24c7da3645900eb25bf73.png
[bd95a6fad4c7477aac59aad0c43394d7.png]: https://img-blog.csdnimg.cn/bd95a6fad4c7477aac59aad0c43394d7.png
[ccbd548d2af04b17a9063abbda938fe9.png]: https://img-blog.csdnimg.cn/ccbd548d2af04b17a9063abbda938fe9.png
[c4a9ecf46b444b508ae7f1ef9f8570de.png]: https://img-blog.csdnimg.cn/c4a9ecf46b444b508ae7f1ef9f8570de.png
[c4ee6a68cf0f43939a7e8a38186aa868.png]: https://img-blog.csdnimg.cn/c4ee6a68cf0f43939a7e8a38186aa868.png
[df143f6bd2764bac9435d84b7d98f267.png]: https://img-blog.csdnimg.cn/df143f6bd2764bac9435d84b7d98f267.png
[33df7ca716da489cbce2bcb7c1a8b396.png]: https://img-blog.csdnimg.cn/33df7ca716da489cbce2bcb7c1a8b396.png
[40e39757385b41d98d52a43fc66d1cf4.png]: https://img-blog.csdnimg.cn/40e39757385b41d98d52a43fc66d1cf4.png
[bfdd287357394a6690106f987032e48d.png]: https://img-blog.csdnimg.cn/bfdd287357394a6690106f987032e48d.png
[43d031a9aa914dc2a3654a04b7cf62be.png]: https://img-blog.csdnimg.cn/43d031a9aa914dc2a3654a04b7cf62be.png
[0e508dd8f92e472d95f284dd545e156a.png]: https://img-blog.csdnimg.cn/0e508dd8f92e472d95f284dd545e156a.png
[e3ab480a9e02415b820e293b97dafccd.png]: https://img-blog.csdnimg.cn/e3ab480a9e02415b820e293b97dafccd.png
[785012a0792243a8b1c8a7a0d8c56963.png]: https://img-blog.csdnimg.cn/785012a0792243a8b1c8a7a0d8c56963.png
[ee772a705df542739bd4717c82918183.png]: https://img-blog.csdnimg.cn/ee772a705df542739bd4717c82918183.png
[d20717a945f94d608e150d607fea0cd7.png]: https://img-blog.csdnimg.cn/d20717a945f94d608e150d607fea0cd7.png
[6dabbfaa9c5f4d7eb71f23a99babb122.png]: https://img-blog.csdnimg.cn/6dabbfaa9c5f4d7eb71f23a99babb122.png
[c217d6dc194e4224bb248cdddece5751.png]: https://img-blog.csdnimg.cn/c217d6dc194e4224bb248cdddece5751.png
[375c9c17dfb245e59cba2f0eae9e807b.png]: https://img-blog.csdnimg.cn/375c9c17dfb245e59cba2f0eae9e807b.png
[0f12c7cfa6914c7cbd8e7415b6fc8a52.png]: https://img-blog.csdnimg.cn/0f12c7cfa6914c7cbd8e7415b6fc8a52.png
[f2f76d7a4ef94cf2bbe8aeda53d11026.png]: https://img-blog.csdnimg.cn/f2f76d7a4ef94cf2bbe8aeda53d11026.png
[702778179d6846448e2b24ac4546f358.png]: https://img-blog.csdnimg.cn/702778179d6846448e2b24ac4546f358.png
[f50f1202f85e437caf275d4ead9f8cf0.png]: https://img-blog.csdnimg.cn/f50f1202f85e437caf275d4ead9f8cf0.png
[d44b4dec757d4843ac477ebb175046b9.png]: https://img-blog.csdnimg.cn/d44b4dec757d4843ac477ebb175046b9.png
[28d62044fac04b468073ec22e7cda813.png]: https://img-blog.csdnimg.cn/28d62044fac04b468073ec22e7cda813.png
[81e2e1881c92447f93086fea26d3111a.png]: https://img-blog.csdnimg.cn/81e2e1881c92447f93086fea26d3111a.png
[b22b8761b70140be8796a6a11cc007d1.png]: https://img-blog.csdnimg.cn/b22b8761b70140be8796a6a11cc007d1.png
[117c8e94dbef41cb967525693f8132bf.png]: https://img-blog.csdnimg.cn/117c8e94dbef41cb967525693f8132bf.png
[342e2174ecfe4a78a706c7b2049d6f3e.png]: https://img-blog.csdnimg.cn/342e2174ecfe4a78a706c7b2049d6f3e.png
[30470437dd0f469d9656694fe96647c1.png]: https://img-blog.csdnimg.cn/30470437dd0f469d9656694fe96647c1.png
[c1f25e02bd224a1096216bf6011d3c5c.png]: https://img-blog.csdnimg.cn/c1f25e02bd224a1096216bf6011d3c5c.png
[04c5a97b862648e2b1d9fb75772469d9.png]: https://img-blog.csdnimg.cn/04c5a97b862648e2b1d9fb75772469d9.png
[d8eb6614acdf48af8dac4d07f290a5aa.png]: https://img-blog.csdnimg.cn/d8eb6614acdf48af8dac4d07f290a5aa.png
[0795156a64e04e0eba0df7cd928c3288.png]: https://img-blog.csdnimg.cn/0795156a64e04e0eba0df7cd928c3288.png
[0181ac9d3f914b19851c4bd7a4632d2c.png]: https://img-blog.csdnimg.cn/0181ac9d3f914b19851c4bd7a4632d2c.png
[57be7ba566d44c228422e999837884e4.png]: https://img-blog.csdnimg.cn/57be7ba566d44c228422e999837884e4.png
[831833f2295140dbbb1fc9ae07518abf.png]: https://img-blog.csdnimg.cn/831833f2295140dbbb1fc9ae07518abf.png
[bbe2fa12ccf74d0fa112868c07125020.png]: https://img-blog.csdnimg.cn/bbe2fa12ccf74d0fa112868c07125020.png
[054ee6bbbc964c4685040a56d04ec469.png]: https://img-blog.csdnimg.cn/054ee6bbbc964c4685040a56d04ec469.png
[dfe11ee8688e408d9512e71668736cc2.png]: https://img-blog.csdnimg.cn/dfe11ee8688e408d9512e71668736cc2.png
[062bbda85b174b1d83bdd46be850a473.png]: https://img-blog.csdnimg.cn/062bbda85b174b1d83bdd46be850a473.png
[2b37f00dcc834ed9b3203c5437d99926.png]: https://img-blog.csdnimg.cn/2b37f00dcc834ed9b3203c5437d99926.png
[d0461f6de53e4cd8996fbf5455c5dd38.png]: https://img-blog.csdnimg.cn/d0461f6de53e4cd8996fbf5455c5dd38.png
[a17fb59843be42f7bb255b0157161e8a.png]: https://img-blog.csdnimg.cn/a17fb59843be42f7bb255b0157161e8a.png
[3d6c06ca44994d159dfd8c3ed6b19c18.png]: https://img-blog.csdnimg.cn/3d6c06ca44994d159dfd8c3ed6b19c18.png
[633c6de12aaf44b195db0bec94b3a2ae.png]: https://img-blog.csdnimg.cn/633c6de12aaf44b195db0bec94b3a2ae.png
[10955d122c4a42f98335cb23c90154a0.png]: https://img-blog.csdnimg.cn/10955d122c4a42f98335cb23c90154a0.png
[c5b6887fd53a44708565247b4638f3b8.png]: https://img-blog.csdnimg.cn/c5b6887fd53a44708565247b4638f3b8.png
[f2d24a7caf784ff2b2e2b8508165f967.png]: https://img-blog.csdnimg.cn/f2d24a7caf784ff2b2e2b8508165f967.png
[fa6d50d2bd9e4510aa95b651ad1b20b8.png]: https://img-blog.csdnimg.cn/fa6d50d2bd9e4510aa95b651ad1b20b8.png
[ed683873789f484f8cbaf7c64d4393a8.png]: https://img-blog.csdnimg.cn/ed683873789f484f8cbaf7c64d4393a8.png
[CORS]: https://www.ruanyifeng.com/blog/2016/04/cors.html