SpringCloud

一、认识微服务

1、单体架构

1. 单体架构是将业务的所有功能集中在一个项目中开发，打成一个包部署。
2. 优点：架构简单、部署成本低
3. 缺点：耦合度高

2、分布式架构

1. 分布式架构是根据业务功能对系统进行拆分，每个业务模块作为独立项目开发，称为一个服务。
2. 优点：降低耦合度、有利于服务升级和拓展

3、微服务

1. 微服务是一种经过良好架构设计的分布式架构方案，微服务架构特征：
   • 单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责，避免重复业务开发
   • 面向服务：微服务对外暴露业务接口
   • 自治：团队独立、技术 独立、数据独立、部署独立
   • 隔离性强：服务调用做好隔离
2. 优点：拆分粒度更小、服务更独立、耦合度更低
3. 缺点：架构非常复杂，运维、监控、部署难度提高

4、微服务技术对比

	Dubbo	SpringCloud	SpringCloudAlibaba
注册中心	zookeeper、Redis	Eureka、Consul	Nacos、Eureka
服务远程调用	Dubbo协议	Feign（http协议）	Dubbo、Feign
配置中心	无	SpringCloudConfig	SpringCloudConfig、Nacos
服务网关	无	SpringCloudGateway、Zuul	SpringCloudGateway、Zuul
服务监控和保护	dubbo-admin，功能弱	Hystix	Sentinel

5、企业需求

二、SpringCloud

1、SpringCloud

1. SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。
2. SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验：

2、版本兼容

3、服务拆分及远程调用

1. 单一职责：不同微服务，不要重复开发相同业务
2. 立：不要访问其它微服务的数据库
3. 服务：将自己的业务暴露为接口，供其它微服务调用

4、微服务远程调用步骤

1. 注册RestTemplate

• der-service的 yMvcConfig 注册RestTemplate：用于发送 http 请求

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Bean   // 创建 restTemplate 并注入 Spring 容器，用于发送 http 请求
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

2. 远程调用RestTemplate

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;
    
    public Order queryOrderById(Long orderId) {
        // 1、查询订单
        Order order = orderMapper.selectById(orderId);
        // 2、查询用户
        String url = "http://localhost/user/" + order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        // 3、封装user信息
        order.setUser(user);
        // 4、返回
        return order;
  }
}

5、提供者与消费者

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

三、Eureka注册中心

1、Eureka的作用

1. EurekaServer：服务端，注册中心
   • 记录服务信息
   • 心跳监控
2. EurekaClient：客户端
   • provider：服务提供者，例如案例中的 user-service
     • 注册自己的信息到EurekaServer
     • 每隔30秒向EurekaServer发送心跳
   • consumer：服务消费者，例如案例中的 order-service
     • 根据服务名称从EurekaServer拉取服务列表
     • 基于服务列表做负载均衡，选中一个微服务后发起远程调用

2、搭建EurekaServer

1. 引入依赖

• 创建 服务端 项目，引入spring-cloud-starter-netflix-eureka-server的依赖

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

2. 添加注解

• 编写启动类，添加@EnableEurekaServer注解

@EnableEurekaServer // 开启 Eureka 注册中心
@SpringBootApplication
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}

3. 添加配置信息

spring:
  application:
    # 配置服务名称（eureka也是微服务，自己启动后会将自己也注册到服务中，用于 eureka 集群通讯）
    name: eurakaService
eureka:
  client:
    service-url:
      # 配置 eureka 地址信息
      defaultZone: http://127.0.0.1:10086/eureka/

3、服务注册

1. 引入依赖

• 在 Provider 项目引入 spring-cloud-starter-netflix-eureka-client 的依赖

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

2. 添加配置信息

spring:
  application:
    # 配置服务名称（启动后会注册到 Eureka 服务中）
    name: userservice
eureka:
  client:
    service-url:
      # 配置 eureka 地址信息(注册中心)
      defaultZone: http://127.0.0.1:10086/eureka/

4、服务发现

1. 引入依赖

• 在 Consumer 项目引入 spring-cloud-starter-netflix-eureka-client 的依赖

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

2. 添加配置信息

spring:
  application:
    # 配置服务名称（启动后会注册到 Eureka 服务中）
    name: orderservice
eureka:
  client:
    service-url:
      # 配置 eureka 地址信息(注册中心)
      defaultZone: http://127.0.0.1:10086/eureka/

3. 添加注解

• 给 RestTemplate 添加 @LoadBalanced 注解

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Bean   // 创建 restTemplate 并注入 Spring 容器，用于发送 http 请求
    @LoadBalanced   // Ribbon 负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

4. 远程调用

• 用服务提供者的服务名称远程调用

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1、查询订单
        Order order = orderMapper.selectById(orderId);
        // 2、查询用户(url 使用注册中心中注册的服务名称)
        String url = "http://userservice/user/" + order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        // 3、封装user信息
        order.setUser(user);
        // 4、返回
        return order;
    }
}

四、Ribbon负载均衡

1、负载均衡流程

2、负载均衡拦截器

3、负载均衡策略

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

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

4、自定义负载均衡策略

1. 代码方式

• 在 order-service 中的 MyMvcConfig 类中，定义一个新的 Rule
• 默认为轮询

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Bean   // 设置随机负载均衡 作用于全局
    public IRule randomRule() {
        return new RandomRule();
    }
}

2. 配置文件方式

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

# 针对某一个微服务而言
userservice:
  ribbon:
    # 负载均衡规则
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

5、饥饿加载

1. Ribbon默认是采用懒加载，即 第一次访问时 才会去创建LoadBalanceClient，请求时间会很长
2. 而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载（在消费者端）：

ribbon:
  eager-load:
    # 开启饥饿加载
    enabled: true
    # 指定对 userservice 这个服务饥饿加载
    clients: 
      - userservice

五、Nacos注册中心

1、认识Nacos

• Nacos是阿里巴巴的产品，现在是SpringCloud中的一个组件。相比Eureka功能更加丰富，在国内受欢迎程度较高。

2、Nacos安装指南

1. 下载安装包

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

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

2. 解压

• 将这个包解压到任意非中文目录下。

3. 端口配置

• Nacos的默认端口是8848，如果你电脑上的其它进程占用了8848端口，请先尝试关闭该进程。
• 也可以进入nacos的conf目录下的application.properties文件，修改配置文件中的端口：

4. 启动

进入bin目录 startup.cmd

启动命令（单机启动）：startup.cmd -m standalone

5. 访问

在浏览器输入地址：http://127.0.0.1:8848/nacos 即可访问， 默认的账号和密码都是nacos

3、服务注册到Nacos

1. 父工程中引入依赖

• 在 父工程中 添加 spring-cloud-alilbaba 的管理依赖：

<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. 客户端引入依赖

• 客户端 添加 nacos 的依赖：

<!-- nacos客户端依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

3. 添加配置信息

• user-service & order-service 中的 application.yml 文件，添加nacos地址：

spring:
  cloud:
    # 配置 nacos 注册中心
    nacos:
      discovery:
        # nacos 服务端地址
        server-addr: localhost:8848
  # 配置中心服务名称
  application:
    name: gulimall-coupon

• 启动类添加 @EnableDiscoveryClient

package com.erer.gulimall.coupon;

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

4、分级存储模型

5、服务跨集群调用问题

1. 服务调用尽可能选择本地集群的服务，跨集群调用延迟较高
2. 本地集群不可访问时，再去访问其它集群

6、服务集群属性

1. 修改集群配置

• 修改application.yml，添加如下内容：

spring:
  cloud:
    nacos:
      # nacos 服务端地址
      server-addr: localhost:8848 
      discovery:
        # 配置集群名称，也就是机房位置，例如：HZ，杭州
        cluster-name: HZ 

2. 查看控制台

• 在Nacos控制台可以看到集群变化：

3. 修改负载均衡规则

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

userservice:
  ribbon:
    # 优先访问 本集群，本集群采用随机访问
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule 

7、根据权重负载均衡

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

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

2. Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高

• 在Nacos控制台可以设置实例的权重值，首先选中实例后面的编辑按钮

• 将权重设置为0.1，测试可以发现8081被访问到的频率大大降低

8、环境隔离 - namespace

Nacos中服务存储和数据存储的最外层都是一个名为namespace的东西，用来做最外层隔离

1. 创建namespace

• 在Nacos控制台可以创建namespace，用来隔离不同环境

2. 填写命名空间

• 然后填写一个新的命名空间信息：

3. 获取ID

• 保存后会在控制台看到这个命名空间的id：

4. 添加配置信息

• 修改 order-service 的application.yml，添加 namespace：

spring:
  cloud:
    nacos:
      erver-addr: localhost:8848
      discovery:
        # 配置集群名称，也就是机房位置，例如：HZ，杭州
        cluster-name: HZ
        # 命名空间，填ID（进行环境隔离）
        namespace: 2a69a5b2-823e-4870-9ad5-ba83b0700f17

5. 重启

• 重启order-service后，再来查看控制台：

6. 访问

• 此时访问order-service，因为namespace不同，会导致找不到userservice，控制台会报错：

9、nacos 注册中心细节分析

• 临时实例：1（5：服务主动发请求给注册中心，注册中心接收不到直接剔除） == 》 2（3、7） == 》 4
• 非临时实例：1 （6：注册中心主动发起请求、询问，没有反馈，标记不健康等待恢复健康）== 》 2（3、7） == 》 4

10、临时实例和非临时实例

1. 临时实例宕机时，会从nacos的服务列表中剔除，而非临时实例则不会
2. 服务注册到Nacos时，可以选择注册为临时或非临时实例，通过下面的配置来设置：

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

六、Nacos与Eureka的区别

1、共同点

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

2、区别

• Nacos的服务实例分为两种类型
  • 临时实例：如果实例宕机超过一定时间，会从服务列表剔除，默认的类型。
  • 非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例。
• Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
• 临时实例心跳不正常会被剔除，非临时实例则不会被剔除
• Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
• Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式；Eureka采用AP方式

七、Nacos配置管理

1、统一配置管理

2、配置获取步骤

1. 添加配置信息表

• 在Nacos中添加配置信息表：

2. 添加数据集

• 在弹出表单中填写配置信息（有热更新需求的配置）：

3. 引入config依赖

• 在微服务中引入nacos的config依赖

<!--nacos配置管理依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

4. 创建 bootstrap.yml

• 在 userservice 中的 resource 目录添加一个 bootstrap.yml 文件
  • 这个文件是引导文件，优先级高于 application.yml
  • 配置nacos地址、当前环境、服务名称、文件后缀名，这些决定了程序启动时去nacos读取哪个文件

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

5. 配置自动刷新

• 配置自动刷新：Nacos中的配置文件变更后，微服务无需重启就可以感知。不过需要通过下面两种配置实现：

方式一：在@Value注入的变量所在类上添加注解@RefreshScope

@RestController
@RequestMapping("/user")
@RefreshScope	// Nacos 配置自动刷新
public class UserController {
    @Value("${pattern.dateformat}")
    private String dateformat;

    // 测试 Nacos 配置管理
    @GetMapping("now")
    public String now() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
    }
}

方式二：使用@ConfigurationProperties注解

@Data
@Component  // 使用在类上用于实例化Bean
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
    private String dateformat;
}

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private PatternProperties patternProperties;

    // 测试 Nacos 配置管理
    @GetMapping("now")
    public String now() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(patternProperties.getDateformat()));
    }
}

3、多环境配置共享

1. 微服务启动时会从nacos读取多个配置文件

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

2. 无论profile如何变化，[spring.application.name].yaml这个文件一定会加载，因此多环境共享配置可以写入这个文件

3. 多种配置的优先级：

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');

2. 下载nacos

3. 配置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文件，添加数据库配置然后修改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=123

4. 启动

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

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

server.port=8845

server.port=8846

server.port=8847

• 然后分别启动三个nacos节点：

startup.cmd

5. nginx反向代理

• 找到课前资料提供的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;
    }
}

• 而后在浏览器访问：http://localhost/nacos 即可。
• 代码中 application.yml 文件配置如下：

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

6. 优化

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

八、HTTP客户端Feign

1、Feign的介绍

• Feign是一个声明式的http客户端，官方地址：https://github.com/OpenFeign/feign
• 代码可读性强，编程体验统一
• 参数简短 URL 容易维护
• 内部集成 Ribbon负载均衡

2、定义和使用Feign客户端

1. 引入依赖

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

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

2. 添加注解

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

@SpringBootApplication
@EnableFeignClients		// 开启 Feign 自动装配功能
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

3. 编写Feign客户端

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

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

@FeignClient("userservice")                      // 服务名称
public interface UserClient {
    @GetMapping("/user/{id}")                    // 请求路径及参数
    User findById(@PathVariable("id") Long id);
}

4. 发起请求

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private UserClient userClient;

    public Order queryOrderById(Long orderId) {
        // 1、查询订单
        Order order = orderMapper.selectById(orderId);
        // 2、Feign 远程调用
        User user = userClient.findById(order.getUserId());
        // 3、封装user信息
        order.setUser(user);
        // 4、返回
        return order;
    }
}

3、自定义Feign的配置

Feign运行自定义配置来覆盖默认配置，可以修改的配置如下（一般我们需要配置的就是日志级别）：

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

而日志的级别分为四种：

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

1. 配置文件方式

# feign 配置 日志级别
feign:
  client:
    config:
      # 全局配置
      # default:
      # 针对 userservice 服务进行配置
      userservice:
        # 日志级别
        loggerLevel: Full

2. 配置Feign日志的方式

• 先声明一个类，然后声明一个 Logger.Level 的对象：

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

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

@SpringBootApplication
@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration.class)
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

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

@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration .class) 
public interface UserClient {
    @GetMapping("/user/{id}")                    // 请求路径及参数
    User findById(@PathVariable("id") Long id);
}

4、Feign的性能优化

1. 底层的客户端实现

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

2.优化Feign的性能

• 使用连接池代替默认的 URLConnection
• 日志级别，最好用 BASIC 或 NONE

3. 性能优化连接池配置

• 引入依赖：

<!--httpClient的依赖 -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

• 配置连接池：

# feign 配置
feign:
  httpclient:
    # 开启 feign 对 HttpClient 的支持
    enabled: true
    # 最大的连接数
    max-connections: 200
    # 每个路径的最大连接数
    max-connections-per-route: 50 

5、Feign的最佳实践

1. 继承

继承是：给消费者的 FeignClient 和提供者的 controller 定义统一的父接口作为标准。

• 服务紧耦合
• 父接口参数列表中的映射不会被继承

// 父接口
public interface UserAPI{
    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);
}

// 消费者的 FeignClient 
@FeignClient(value = "userservice")
public interface UserClient extends UserAPI{}

// 提供者的 controller
@RestController
public class UserController implements UserAPI{
    public User findById(@PathVariable("id") Long id){
        // ...实现业务
     }
}

2. 抽取

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

6、抽取

1. 创建模块

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

2. 引入依赖

• 在feign-api中然后引入feign的starter依赖

<!-- Feign 客户端依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

• 编写的 UserClient、User、DefaultFeignConfiguration

3. 引用模块

• 在 order-service 的 pom 文件中引入 feign-api 的依赖：

<dependency>
    <groupId>cn.itcast.demo</groupId>
    <artifactId>feign-api</artifactId>
    <version>1.0</version>
</dependency>

4. 解决扫描包问题

• 指定 Feign 应该扫描的包：

@EnableFeignClients(basePackages = "erer.springcloud.feign.clients")
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

• 指定需要加载的 Client 接口：

@EnableFeignClients(clients = {UserClient.class})
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

7、异步任务请求头丢失

1. 创建 Feign 拦截器

package com.erer.gulimall.order.config;
@Configuration
public class OrderWebConfig implements WebMvcConfigurer {
    /**
     * Feign拦截器：获取当前线程请求头信息(解决 Feign 远程调用丢失请求头问题)
     * Feign 远程调用其他服务（登录拦截器的服务），其他服务也可以感知当前登录的用户
     * template：新的请求
     **/
    @Bean("requestInterceptor")
    public RequestInterceptor requestInterceptor() {
        RequestInterceptor requestInterceptor = template -> {
            // 使用 RequestContextHolder 获取刚进来的请求数据
            ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            if (requestAttributes != null) {
                // 老请求
                HttpServletRequest request = requestAttributes.getRequest();
                // 同步请求头的数据（主要是cookie）
                String cookie = request.getHeader("Cookie");
                template.header("Cookie", cookie);
            }
        };
        return requestInterceptor;
    }
}

2. 远程调用

package com.erer.gulimall.order.service.impl;
@Service("orderService")
public class OrderServiceImpl extends ServiceImpl<OrderDao, OrderEntity> implements OrderService {
    @Override
    public OrderConfirmVo confirmOrder() throws ExecutionException, InterruptedException {
        // 获取当前线程请求头信息
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 异步任务
        CompletableFuture<Void> addressFuture = CompletableFuture.runAsync(() -> {
            // 每一个线程都要获取之前线程的请求头数据
            RequestContextHolder.setRequestAttributes(requestAttributes);
            // Feign拦截器：获取当前线程请求头信息(解决 Feign 远程调用丢失请求头问题)
            List<MemberAddressVo> address = memberFeignService.getAddress(memberResponseVo.getId());
            confirmVo.setAddress(address);
        }, threadPoolExecutor);
        // 异步任务
        CompletableFuture<Void> cartInfoFuture = CompletableFuture.runAsync(() -> {
            // 每一个线程都要获取之前线程的请求头数据
            RequestContextHolder.setRequestAttributes(requestAttributes);
            // Feign拦截器：获取当前线程请求头信息(解决 Feign 远程调用丢失请求头问题)
            List<OrderItemVo> currentCartItems = cartFeignService.getCurrentCartItems();
            confirmVo.setItems(currentCartItems);
        }, threadPoolExecutor);
    }
}

九、统一网关Gateway

1、网官路由访问的流程

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

2、网关的技术实现

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

• lgateway：基于Spring5中提供的WebFlux，属于响应式编程的实现，具备更好的性能。
• lzuul：基于Servlet的实现，属于阻塞式编程。

3、搭建网关服务

1. 创建模块

首先创建一个 module，命名为 gateway

2. 引入依赖

<!--网关-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!--nacos服务发现依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

3. 编写启动类

package cn.itcast.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
// 开启 gateway 网关服务注册发现
@EnableDiscoveryClient
public class GatewayApplication {
	public static void main(String[] args) {
		SpringApplication.run(GatewayApplication.class, args);
	}
}

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

创建application.yml文件，网关路由可以配置的内容包括：

• 路由id：路由唯一标示
• uri：路由目的地，支持lb和http两种
• predicates：路由断言，判断请求是否符合要求，符合则转发到路由目的地
• filters：路由过滤器，处理请求或响应

server:
  # 配置网关端口
  port: 10010

spring:
  application:
    # 配置服务名称（启动后会注册到 注册中心）
    name: gateway
  cloud:
    # Nacos注册中心
    nacos:
      # 配置 nacos 服务端地址
      server-addr: localhost:8848
    gateway:
      # 网关路由配置
      routes:
        # 路由id，自定义，只要唯一即可
        - id: user-service
          # 路由的目标地址 lb 就是负载均衡，后面跟服务名称
          uri: lb://userservice
          # 路由断言：也就是判断请求是否符合路由规则的条件
          predicates:
            # 路径断言，判断路径是否以 /user/ 开头
            - Path=/user/**
        - id: order-service
          uri: lb://orderservice
          predicates:
            - Path=/order/**

4、路由断言工厂

• 配置文件中写的 断言 的字符串，会被 Route Predicate Factory （路由断言工厂）读取并处理，转变为路由判断的条件
• 例如路径匹配 Path=/user/** 由org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory类处理
• 参考文档 https://docs.spring.io/spring-cloud-gateway/docs/3.0.3/reference/html/#the-after-route-predicate-factory
• 像这样的断言工厂在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	权重处理

5、网关过滤器

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

1. 路由过滤器

Spring提供了31种不同的路由过滤器工厂（Gateway Filter Factory）。

参考文档：https://docs.spring.io/spring-cloud-gateway/docs/3.0.3/reference/html/#gatewayfilter-factories

例如：

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

• AddRequestHeader：给所有进入userservice 的请求 添加 一个请求头

spring:
  application:
    # 配置服务名称（启动后会注册到 注册中心）
    name: gateway
  cloud:
    # Nacos注册中心
    nacos:
      # 配置 nacos 服务端地址
      server-addr: localhost:8848
    gateway:
      # 网关路由配置
      routes:
        # 路由id，自定义，只要唯一即可
        - id: user-service
          # 路由的目标地址 lb 就是负载均衡，后面跟服务名称
          uri: lb://userservice
          # 路由断言：也就是判断请求是否符合路由规则的条件
          predicates:
            # 路径断言，判断路径是否以 /user/ 开头
            - Path=/user/**
          # 路由过滤器
          filters:
            # 请求头过滤器
            - AddRequestHeader=Truth, ZuiNanBuGuoJianChi!
        - id: order-service
          uri: lb://orderservice
          predicates:
            - Path=/order/**
          filters:
            - AddRequestHeader=Truth, ZuiNanBuGuoJianChi!

2. 默认过滤器

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

spring:
  application:
    # 配置服务名称（启动后会注册到 注册中心）
    name: gateway
  cloud:
    # Nacos注册中心
    nacos:
      # 配置 nacos 服务端地址
      server-addr: localhost:8848
    gateway:
      # 网关路由配置
      routes:
        # 路由id，自定义，只要唯一即可
        - id: user-service
          # 路由的目标地址 lb 就是负载均衡，后面跟服务名称
          uri: lb://userservice
          # 路由断言：也就是判断请求是否符合路由规则的条件
          predicates:
            # 路径断言，判断路径是否以 /user/ 开头
            - Path=/user/**
        - id: order-service
          uri: lb://orderservice
          predicates:
            - Path=/order/**
      # 默认过滤项
      default-filters:
        - AddRequestHeader=Truth, ZuiNanBuGuoJianChi!

3. 全局过滤器

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

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

• 自定义全局过滤器

@Component
//@Order(-1)      // 设置优先级，数值越小优先级越高
public class AuthorizeFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1、获取请求参数
        ServerHttpRequest request = exchange.getRequest();
        MultiValueMap<String, String> params = request.getQueryParams();
        // 2、获取请求参数中的 authorization
        String authorization = params.getFirst("authorization");
        // 3、判断参数是否等于 admin
        if ("admin".equals(authorization)) {
            // 4、相等放行
            return chain.filter(exchange);
        }
        // 5、不相等，拦截
        // 设置状态码
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        return exchange.getResponse().setComplete();
    }

    // 设置优先级，数值越小优先级越高
    @Override
    public int getOrder() {
        return -1;
    }
}

6、过滤器执行顺序

1. 执行顺序

• 请求进入网关会碰到三类过滤器：当前路由的过滤器、DefaultFilter、GlobalFilter
• 请求路由后，会将当前路由过滤器和DefaultFilter、GlobalFilter，合并到一个过滤器链（集合）中，排序后依次执行：

2. 排序规则

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

3. 加载方法：

• org.springframework.cloud.gateway.route.RouteDefinitionRouteLocator#getFilters()方法是先加载 defaultFilters，然后再加载某个route的filters，然后合并。
• org.springframework.cloud.gateway.handler.FilteringWebHandler#handle()方法会加载全局过滤器，与前面的过滤器合并后根据order排序，组织过滤器链

7、跨域问题

1. 跨域

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

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

2. 跨域问题

• 跨域问题：浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题
• 访问：http://localhost:8000/index.html
• 出现如下问题：

3. 解决方案

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

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

• 访问：http://localhost:8000/index.html