微 服 务

 简介

单体架构：

        单体架构（monolithic structure）：整个项目中所有功能模块都在一个工程中开发，项目部署时需要对所有模块一起编译、打包，项目的架构设计、开发模式都非常简单。

        但随着项目的业务规模越来越大，团队开发人员也不断增加，单体架构就呈现出越来越多的问题：

        团队协作成本高：所有模块都在一个项目中，不同模块的代码之间物理边界越来越模糊。最终要把功能合并到一个分支，会陷入到解决冲突的泥潭之中。

        系统发布效率低：任何模块变更都需要发布整个系统，任何一处出现问题都会导致发布失败。

        系统可用性差：一些热点功能会耗尽系统资源，导致其它服务低可用。

微服务：

        微服务架构就是将单体架构中的功能模块从单体应用中拆分出来，独立部署为多个服务。同时还满足下面的一些特点：

        单一职责：一个微服务负责一部分业务功能，并且其核心数据不依赖于其它模块。
        团队自治：每个微服务都有自己独立的开发、测试、发布、运维人员，团队人员规模不超过10人
        服务自治：每个微服务都独立打包部署，访问自己独立的数据库。并且要做好服务隔离，避免对其它服务产生影响

SpringCloud：

        微服务拆分以后碰到的各种问题都有对应的解决方案和微服务组件，而SpringCloud框架是目前Java领域最全面的微服务组件的集合。

        目前SpringCloud最新版本为2022.0.x版本，对应的SpringBoot版本为3.x版本，但它们全部依赖于JDK17，目前在企业中使用相对较少。

SpringCloud版本	SpringBoot版本
2022.0.x aka Kilburn	3.0.x
2021.0.x aka Jubilee	2.6.x, 2.7.x (Starting with 2021.0.3)
2020.0.x aka Ilford	2.4.x, 2.5.x (Starting with 2020.0.3)
Hoxton	2.2.x, 2.3.x (Starting with SR5)
Greenwich	2.1.x
Finchley	2.0.x
Edgware	1.5.x
Dalston	1.5.x

        这里使用Spring Cloud 2021.0.x以及Spring Boot 2.7.x版本。

微服务拆分

         以黑马商城为例，拆分黑马商城。

拆分原则

        微服务拆分时粒度要小，具体可以从两个角度来分析：

        高内聚：每个微服务的职责要尽量单一，包含的业务相互关联度高、完整度高。
        低耦合：每个微服务的功能要相对独立，尽量减少对其它微服务的依赖，或者依赖接口的稳定性要强。

        在做服务拆分时一般有两种方式：

        纵向拆分：按照项目的功能模块来拆分。这种拆分模式可以尽可能提高服务的内聚性。
        横向拆分：看各个功能模块之间有没有公共的业务部分，如果有将其抽取出来作为通用服务。可以提高业务的复用性，避免重复开发。同时通用业务一般接口稳定性较强，也不会使服务之间过分耦合。

拆分商品服务功能

        一般微服务项目有两种不同的工程结构：

        完全解耦：每一个微服务都创建为一个独立的工程，甚至可以使用不同的开发语言来开发，项目完全解耦。
                优点：服务之间耦合度低
                缺点：每个项目都有自己的独立仓库，管理起来比较麻烦
        Maven聚合：整个项目为一个Project，然后每个微服务是其中的一个Module
                优点：项目代码集中，管理和运维方便
                缺点：服务之间耦合，编译时间较长

        这里采用Maven聚合结构，并且直接在原项目中进行拆分(hmall父工程之中已经定义了SpringBoot、SpringCloud的依赖版本，方便拆分)

        在hmall中创建item-service模块并设定JDK版本为11：

        引入依赖：

<dependencies>
    <!--common-->
    <dependency>
        <groupId>com.heima</groupId>
        <artifactId>hm-common</artifactId>
        <version>1.0.0</version>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--数据库-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--mybatis-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
    </dependency>
    <!--单元测试-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>
<build>
    <finalName>${project.artifactId}</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

        编写启动类：

@MapperScan("com.hmall.item.mapper")
@SpringBootApplication
public class HMallApplication {
    public static void main(String[] args) {
        SpringApplication.run(HMallApplication.class, args);
    }
}

        配置文件，可以从hm-service中拷贝，其中application-dev.yaml和application-local.yaml直接拷贝即可，application.yaml需要更改一些：

server:
  port: 8081
spring:
  application:
    name: item-service
  profiles:
    active: local
  datasource:
    url: jdbc:mysql://${hm.db.host}:3306/hm-item?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: ${hm.db.pw}
mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler
  global-config:
    db-config:
      update-strategy: not_null
      id-type: auto
logging:
  level:
    com.hmall: error
  pattern:
    dateformat: HH:mm:ss:SSS
  file:
    path: "logs/${spring.application.name}"
knife4j:
  enable: true
  openapi:
    title: 商品服务接口文档
    description: "信息"
    email: zhanghuyi@itcast.cn
    concat: 虎哥
    url: https://www.itcast.cn
    version: v1.0.0
    group:
      default:
        group-name: default
        api-rule: package
        api-rule-resources:
          - com.hmall.item.controller

        然后拷贝hm-service中与商品管理有关的代码到item-service(很多包可能要重新导)，如图：

        ItemServiceImpl类中的deductStock方法需要更改一下包路径：

@Service
public class ItemServiceImpl extends ServiceImpl<ItemMapper, Item> implements IItemService {
    @Override
    public void deductStock(List<OrderDetailDTO> items) {
        String sqlStatement = "com.hmall.item.mapper.ItemMapper.updateStock";
        boolean r = false;
        try {
            r = executeBatch(items, (sqlSession, entity) -> sqlSession.update(sqlStatement, entity));
        } catch (Exception e) {
            throw new BizIllegalException("更新库存异常，可能是库存不足!", e);
        }
        if (!r) {
            throw new BizIllegalException("库存不足！");
        }
    }
    @Override
    public List<ItemDTO> queryItemByIds(Collection<Long> ids) {
        return BeanUtils.copyList(listByIds(ids), ItemDTO.class);
    }
}

        执行hm-item.sql脚本，导入数据库表(在企业开发的生产环境中，每一个微服务都应该有自己的独立数据库服务，而不仅仅是database)

        启动item-service，可以访问商品微服务的swagger接口文档测试：http://localhost:8081/doc.html

拆分购物车功能

        与商品服务类似，在hmall下创建一个新的module，起名为cart-service

        引入依赖：

<dependencies>
    <!--common-->
    <dependency>
        <groupId>com.heima</groupId>
        <artifactId>hm-common</artifactId>
        <version>1.0.0</version>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--数据库-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--mybatis-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
    </dependency>
    <!--单元测试-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>
<build>
    <finalName>${project.artifactId}</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

        编写启动类启动类

        配置文件，同样可以拷贝自item-service，不过其中的application.yaml需要修改：

server:
  port: 8082
spring:
  application:
    name: cart-service
  profiles:
    active: local
  datasource:
    url: jdbc:mysql://${hm.db.host}:3306/hm-cart?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: ${hm.db.pw}
mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler
  global-config:
    db-config:
      update-strategy: not_null
      id-type: auto
logging:
  level:
    com.hmall: debug
  pattern:
    dateformat: HH:mm:ss:SSS
  file:
    path: "logs/${spring.application.name}"
knife4j:
  enable: true
  openapi:
    title: 商品服务接口文档
    description: "信息"
    email: zhanghuyi@itcast.cn
    concat: 虎哥
    url: https://www.itcast.cn
    version: v1.0.0
    group:
      default:
        group-name: default
        api-rule: package
        api-rule-resources:
          - com.hmall.cart.controller

        把hm-service中的与购物车有关功能拷贝过来，最终的项目结构如下：

        com.hmall.cart.service.impl.CartServiceImpl，其中有两个地方需要处理：

        需要获取登录用户信息，但登录校验功能目前没有复制过来，先写死固定用户id
        查询购物车时需要查询商品信息，而商品信息不在当前服务，需要先将这部分代码注释

         将其queryMyCarts方法和handleCarItems方法改为下列形式：

@Override
public List<CartVO> queryMyCarts() {
    // 1.查询我的购物车列表
    List<Cart> carts = lambdaQuery().eq(Cart::getUserId, 1L /*TODO UserContext.getUser()*/).list();
    if (CollUtils.isEmpty(carts)) {
        return CollUtils.emptyList();
    }
    // 2.转换VO
    List<CartVO> vos = BeanUtils.copyList(carts, CartVO.class);
    // 3.处理VO中的商品信息
    handleCartItems(vos);
    // 4.返回
    return vos;
}
private void handleCartItems(List<CartVO> vos) {
    // 1.获取商品id TODO 处理商品信息
    /*Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());
    // 2.查询商品
    List<ItemDTO> items = itemService.queryItemByIds(itemIds);
    if (CollUtils.isEmpty(items)) {
        throw new BadRequestException("购物车中商品不存在！");
    }
    // 3.转为 id 到 item的map
    Map<Long, ItemDTO> itemMap = items.stream().collect(Collectors.toMap(ItemDTO::getId, Function.identity()));
    // 4.写入vo
    for (CartVO v : vos) {
        ItemDTO item = itemMap.get(v.getItemId());
        if (item == null) {
            continue;
        }
        v.setNewPrice(item.getPrice());
        v.setStatus(item.getStatus());
        v.setStock(item.getStock());
    }*/
}

        执行ht-cart.sql脚本，导入数据库表。

        启动CartApplication，可以访问swagger文档页面测试：http://localhost:8082/doc.html

服务调用

        查询购物车时需要查询商品信息，而商品信息不在当前服务，需要把原本本地方法调用，改造成跨微服务的远程调用（RPC，即Remote Produce Call）。

        在cart-service中能模拟浏览器，发送http请求到item-service获取信息，即可完成跨微服务的远程调用

        Spring给我们提供了一个RestTemplate的API，可以方便的实现Http请求的发送。

RestTemplate：

        RestTemplate提供了大量的方法，方便我们发送Http请求，常见的Get、Post、Put、Delete请求都支持，如果请求参数比较复杂，还可以使用exchange方法来构造请求。

        在cart-service服务中定义一个配置类RemoteCallCongig将RestTemplate注册为一个Bean：

@Configuration
public class RemoteCallConfig {

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

        修改cart-service中CartServiceImpl的handleCartItems方法，发送http请求到item-service：

private final RestTemplate restTemplate;
private void handleCartItems(List<CartVO> vos) {
    // TODO 1.获取商品id
    Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());
    // 2.查询商品
    // List<ItemDTO> items = itemService.queryItemByIds(itemIds);
    // 2.1.利用RestTemplate发起http请求，得到http的响应
    ResponseEntity<List<ItemDTO>> response = restTemplate.exchange(
            "http://localhost:8081/items?ids={ids}",
            HttpMethod.GET,
            null,
            new ParameterizedTypeReference<List<ItemDTO>>() {
            },
            Map.of("ids", CollUtil.join(itemIds, ","))
    );
    // 2.2.解析响应
    if(!response.getStatusCode().is2xxSuccessful()){
        // 查询失败，直接结束
        return;
    }
    List<ItemDTO> items = response.getBody();
    if (CollUtils.isEmpty(items)) {
        return;
    }
    // 3.转为 id 到 item的map
    Map<Long, ItemDTO> itemMap = items.stream().collect(Collectors.toMap(ItemDTO::getId, Function.identity()));
    // 4.写入vo
    for (CartVO v : vos) {
        ItemDTO item = itemMap.get(v.getItemId());
        if (item == null) {
            continue;
        }
        v.setNewPrice(item.getPrice());
        v.setStatus(item.getStatus());
        v.setStock(item.getStock());
    }
}

服务注册和发现

注册中心原理

        在微服务远程调用的过程中，包括两个角色：

        服务提供者：提供接口供其它微服务访问，比如item-service
        服务消费者：调用其它微服务提供的接口，比如cart-service

        流程如下：

        服务启动时就会注册自己的服务信息（服务名、IP、端口）到注册中心
        调用者可以从注册中心订阅想要的服务，获取服务对应的实例列表（1个服务可能多实例部署）
        调用者自己对实例列表负载均衡，挑选一个实例
        调用者向该实例发起远程调用

         考虑到当服务提供者的实例宕机或者启动新实例，服务提供者和注册中心会进行下列操作：

        服务提供者会定期向注册中心发送请求，报告自己的健康状态（心跳请求）
        当注册中心长时间收不到提供者的心跳时，会认为该实例宕机，将其从服务的实例列表中剔除
        当服务有新实例启动时，会发送注册服务请求，其信息会被记录在注册中心的服务实例列表
        当注册中心服务列表变更时，会主动通知微服务，更新本地服务列表

Nacos注册中心

        目前开源的注册中心框架有很多，国内比较常见的有：

        Eureka：Netflix公司出品，目前被集成在SpringCloud当中，一般用于Java应用
        Nacos：Alibaba公司出品，目前被集成在SpringCloudAlibaba中，一般用于Java应用
        Consul：HashiCorp公司出品，目前集成在SpringCloud中，不限制微服务语言

        以上几种注册中心都遵循SpringCloud中的API规范，因此在业务开发使用上没有太大差异。由于Nacos是国内产品，中文文档比较丰富，而且同时具备配置管理功能，因此在国内使用较多。

        基于Docker来部署Nacos的注册中心，首先要准备MySQL数据库表，用来存储Nacos的数据。由于是Docker部署，所以需要将nacos.sql文件导入到Docker中的MySQL容器中

        然后将nacos.tar放到root目录下，再加载镜像：

        docker load -i nacos.tar

        进入root目录，然后执行下面的docker命令：

docker run -d \
--name nacos \
--env-file ./nacos/custom.env \
-p 8848:8848 \
-p 9848:9848 \
-p 9849:9849 \
--restart=always \
nacos/nacos-server:v2.1.0-slim

        启动完成后，访问下面地址：http://192.168.150.101:8848/nacos/，注意将192.168.150.101替换为自己的虚拟机IP地址。首次访问会跳转到登录页，账号密码都是nacos。

服务注册：

        在item-service的pom.xml中添加依赖：

<!--nacos 服务注册发现-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

        在item-service的application.yml中添加nacos地址配置：

spring:
  application:
    name: item-service # 服务名称
  cloud:
    nacos:
      server-addr: 192.168.150.101:8848 # nacos地址

        为了测试一个服务多个实例的情况可以多配置几个item-service的部署实例(只需要复制一个启动类，改一下启动端口即可)

服务发现：

        服务的消费者要去nacos订阅服务，这个过程就是服务发现，步骤如下：

        引入依赖
        配置Nacos地址
        发现并调用服务

        服务发现除了要引入nacos依赖以外，由于还需要负载均衡，因此要引入SpringCloud提供的LoadBalancer依赖：

<!--nacos 服务注册发现-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--
    这里Nacos的依赖于服务注册时一致，这个依赖中同时包含了服务注册和发现的功能。
    因为任何一个微服务都可以调用别人，也可以被别人调用，即可以是调用者，也可以是提供者。
    因此cart-service启动，同样会注册到Nacos
 -->

        在cart-service的application.yml中添加nacos地址配置：

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

 发现并调用服务：

        服务调用者cart-service可以去订阅item-service服务，服务发现需要用到一个工具DiscoveryClient，SpringCloud已经自动装配可以直接注入使用：

private final RestTemplate restTemplate;
private final DiscoveryClient discoveryClient;
private void handleCartItems(List<CartVO> vos) {
    // TODO 1.获取商品id
    Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());
    // 2.查询商品
    // List<ItemDTO> items = itemService.queryItemByIds(itemIds);
    List<ServiceInstance> instances = discoveryClient.getInstances("item-service");
    ServiceInstance instance = instances.get(RandomUtil.randomInt(instances.size()));
    // 2.1.利用RestTemplate发起http请求，得到http的响应
    ResponseEntity<List<ItemDTO>> response = restTemplate.exchange(
            instance.getUri() + "/items?ids={ids}",
            HttpMethod.GET,
            null,
            new ParameterizedTypeReference<List<ItemDTO>>() {
            },
            Map.of("ids", CollUtil.join(itemIds, ","))
    );
    // 2.2.解析响应
    if(!response.getStatusCode().is2xxSuccessful()){
        // 查询失败，直接结束
        return;
    }
    List<ItemDTO> items = response.getBody();
    if (CollUtils.isEmpty(items)) {
        return;
    }
    // 3.转为 id 到 item的map
    Map<Long, ItemDTO> itemMap = items.stream().collect(Collectors.toMap(ItemDTO::getId, Function.identity()));
    // 4.写入vo
    for (CartVO v : vos) {
        ItemDTO item = itemMap.get(v.getItemId());
        if (item == null) {
            continue;
        }
        v.setNewPrice(item.getPrice());
        v.setStatus(item.getStatus());
        v.setStock(item.getStock());
    }
}

OpenFeign

        利用RestTemplate实现了服务的远程调用，但是远程调用的代码太复杂。OpenFeign就利用SpringMVC的相关注解，然后基于动态代理帮我们生成远程调用的代码。

快速入门

        以cart-service中的查询我的购物车为例

        在cart-service服务的pom.xml中引入OpenFeign的依赖和loadBalancer依赖：

  <!--openFeign-->
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-openfeign</artifactId>
  </dependency>
  <!--负载均衡器-->
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-loadbalancer</artifactId>
  </dependency>

        在cart-service的启动类上添加@EnableFeignClients注解，启动OpenFeign功能：

@EnableFeignClients
@MapperScan("com.hmall.cart.mapper")
@SpringBootApplication
public class CartApplication  {
    public static void main(String[] args) {
        SpringApplication.run(CartApplication .class, args);
    }
}

        在cart-service中，定义一个新的接口，编写Feign客户端：

@FeignClient("item-service")
public interface ItemClient {
    @GetMapping("/items")
    List<ItemDTO> queryItemByIds(@RequestParam("ids") Collection<Long> ids);
    /*
     *这里只需要声明接口，无需实现方法。接口中的几个关键信息：
     *@FeignClient("item-service") ：声明服务名称
     *@GetMapping ：声明请求方式
     *@GetMapping("/items") ：声明请求路径
     *@RequestParam("ids") Collection<Long> ids ：声明请求参数
     *List<ItemDTO> ：返回值类型
     */
}

        在cart-service中CartServiceImpl的handleCartItems方法直接调用ItemClient的方法：

private final ItemClient itemClient;
private void handleCartItems(List<CartVO> vos) {
    // TODO 1.获取商品id
    Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());
    // 2.查询商品
    List<ItemDTO> items = itemClient.queryItemByIds(itemIds);
    if (CollUtils.isEmpty(items)) {
        return;
    }
    // 3.转为 id 到 item的map
    Map<Long, ItemDTO> itemMap = items.stream().collect(Collectors.toMap(ItemDTO::getId, Function.identity()));
    // 4.写入vo
    for (CartVO v : vos) {
        ItemDTO item = itemMap.get(v.getItemId());
        if (item == null) {
            continue;
        }
        v.setNewPrice(item.getPrice());
        v.setStatus(item.getStatus());
        v.setStock(item.getStock());
    }
}

        而且这里不再需要RestTemplate，也不必再注册RestTemplate。

连接池

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

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

        这里使用OK Http来代替HttpURLConnection实现连接池

        在cart-service的pom.xml中引入OK http 的依赖：

<!--OK http依赖 -->
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-okhttp</artifactId>
</dependency>

        在cart-service的application.yml配置文件中开启Feign的连接池功能：

feign:
  okhttp:
    enabled: true # 开启OKHttp功能

日志配置

        OpenFeign只会在FeignClient所在包的日志级别为DEBUG时，才会输出日志。而且其日志级别有4级：

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

        Feign默认的日志级别是NONE，所以默认是看不到请求日志的。

        新建一个DefaultFeignConfig配置类，定义Feign的日志级别：

public class DefaultFeignConfig {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.FULL;
    }
}

        要让日志级别生效，还需要配置这个类。有两种方式：

        局部生效：在某个FeignClient中配置，只对当前FeignClient生效

@FeignClient(value = "item-service", configuration = DefaultFeignConfig.class)

        全局生效：在@EnableFeignClients中配置，针对所有FeignClient生效。

@EnableFeignClients(defaultConfiguration = DefaultFeignConfig.class)

最佳实践

        如果拆分了交易微服务（trade-service），它也需要远程调用item-service中的根据id批量查询商品功能。这个需求与cart-service中是一样的，这就需要在trade-service中再次定义ItemClient接口，造成重复编码。

        避免重复编码的办法就是抽取。不过这里有两种抽取方案：

        方案1：抽取到微服务之外的公共module，抽取更加简单，工程结构也比较清晰，但缺点是整个项目耦合度偏高。
        方案2：每个微服务自己抽取一个module，抽取相对麻烦，工程结构相对更复杂，但服务之间耦合度降低。

        这里我们采用方案1

抽取Feign客户端

        在hmall下定义一个新的module，命名为hm-api：

        导依赖：

<dependencies>
    <!--open feign-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <!-- load balancer-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    </dependency>
    <!-- swagger 注解依赖 -->
    <dependency>
        <groupId>io.swagger</groupId>
        <artifactId>swagger-annotations</artifactId>
        <version>1.6.6</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

        将ItemDTO和ItemClient以及OpenFeign的日志配置都拷贝过来，最终结构如下：

        然后任何微服务要调用item-service中的接口，只需要引入hm-api模块依赖即可，无需自己编写Feign客户端

扫描包

        在cart-service的pom.xml中引入hm-api模块：

  <!--feign模块-->
  <dependency>
      <groupId>com.heima</groupId>
      <artifactId>hm-api</artifactId>
      <version>1.0.0</version>
  </dependency>

        在cart-service的启动类上添加声明，两种方式：

        方式1：声明扫描包：

@EnableFeignClients(basePackages = "com.hmall.api.client")
@MapperScan("com.hmall.cart.mapper")
@SpringBootApplication
public class CartApplication  {
    public static void main(String[] args) {
        SpringApplication.run(CartApplication .class, args);
    }
}

        方式2：声明要用的FeignClient

@EnableFeignClients(clients = {ItemClient.class})
@MapperScan("com.hmall.cart.mapper")
@SpringBootApplication
public class CartApplication  {
    public static void main(String[] args) {
        SpringApplication.run(CartApplication .class, args);
    }
}

网关路由

        
        网关就是网络的关口。数据在网络间传输，从一个网络传输到另一网络时就需要经过网关来做数据的路由和转发以及数据安全的校验。

        前端请求不能直接访问微服务，而是要请求网关：

        网关可以做安全控制，也就是登录身份校验，校验通过才放行
        通过认证后，网关再根据请求判断应该访问哪个微服务，将请求转发过去

        在SpringCloud当中，提供了两种网关实现方案：

        Netflix Zuul：早期实现，目前已经淘汰
        SpringCloudGateway：基于Spring的WebFlux技术，完全支持响应式编程，吞吐能力更强

快速入门

        网关本身也是一个独立的微服务，也需要创建一个模块开发功能。

        在hmall下创建一个新的module，命名为hm-gateway，作为网关微服务：

        在hm-gateway模块的pom.xml文件中引入依赖：

<dependencies>
    <!--common-->
    <dependency>
        <groupId>com.heima</groupId>
        <artifactId>hm-common</artifactId>
        <version>1.0.0</version>
    </dependency>
    <!--网关-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <!--nacos discovery-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!--负载均衡-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-loadbalancer</artifactId>
    </dependency>
</dependencies>
<build>
    <finalName>${project.artifactId}</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

        在hm-gateway模块的com.hmall.gateway包下新建一个启动类

        在hm-gateway模块的resources目录新建一个application.yaml文件来配置路由：

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: 192.168.150.101:8848
    gateway:
      routes:
        - id: item # 路由规则id，自定义，唯一
          uri: lb://item-service # 路由的目标服务，lb代表负载均衡，会从注册中心拉取服务列表
          predicates: # 路由断言，判断当前请求是否符合当前规则，符合则路由到目标服务
            - Path=/items/**,/search/** # 这里是以请求路径作为判断规则
        - id: cart
          uri: lb://cart-service
          predicates:
            - Path=/carts/**
        - id: user
          uri: lb://user-service
          predicates:
            - Path=/users/**,/addresses/**
        - id: trade
          uri: lb://trade-service
          predicates:
            - Path=/orders/**
        - id: pay
          uri: lb://pay-service
          predicates:
            - Path=/pay-orders/**

路由过滤

        路由规则的定义语法如下：

spring:
    gateway:
      routes:
        - id: item
          uri: lb://item-service
          predicates:
            - Path=/items/**,/search/**

        其中routes对应的类型是一个集合，也就是说可以定义很多路由规则。集合中的RouteDefinition就是具体的路由规则定义，其中常见的属性如下：

        id：路由的唯一标示
        predicates：路由断言，其实就是匹配条件
        filters：路由过滤条件，后面讲
        uri：路由目标地址，lb://代表负载均衡，从注册中心获取目标微服务的实例列表，并且负载均衡选择一个访问。

         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	权重处理

网关登录校验

        登录是基于JWT来实现的，校验JWT的算法复杂，而且需要用到秘钥。如果每个微服务都去做登录校验，这就存在着两大问题：

        每个微服务都需要知道JWT的秘钥，不安全
        每个微服务重复编写登录校验代码、权限校验代码，麻烦

        网关是所有微服务的入口，一切请求都需要先经过网关。可以把登录校验的工作放到网关去做，这样问题就解决了。

网关过滤器

        客户端请求进入网关后由HandlerMapping对请求做判断，找到与当前请求匹配的路由规则（Route），然后将请求交给WebHandler去处理。

        WebHandler会加载当前路由下需要执行的过滤器链（Filter chain），然后按照顺序逐一执行过滤器（后面称为Filter）。

        Filter内部的逻辑分为pre和post两部分，分别会在请求路由到微服务之前和之后被执行。只有所有Filter的pre逻辑都依次顺序执行通过后，请求才会被路由到微服务，然后倒序执行Filter的post逻辑。

        其中最终请求转发是由一个名为NettyRoutingFilter的过滤器来执行的，而且这个过滤器是整个过滤器链中顺序最靠后的一个。如果能够定义一个过滤器，在其中实现登录校验逻辑，并且将过滤器执行顺序定义到NettyRoutingFilter之前，就可以完成用户验证功能了。

        过滤器链之外还有一种过滤器，HttpHeadersFilter，用来处理传递到下游微服务的请求头。

        网关过滤器链中的过滤器有两种：

        GatewayFilter：路由过滤器，作用范围比较灵活，可以是任意指定的路由Route. 
        GlobalFilter：全局过滤器，作用范围是所有路由，不可配置。

        

        FilteringWebHandler在处理请求时，会将GlobalFilter装饰为GatewayFilter，然后放到同一个过滤器链中，排序以后依次执行。Gateway中内置了很多的GatewayFilter，详情可以参考官方文档：https://docs.spring.io/spring-cloud-gateway/docs/3.1.7/reference/html/#gatewayfilter-factories

        Gateway内置的GatewayFilter过滤器只要在yaml文件中简单配置即可使用

        有一个过滤器叫做AddRequestHeaderGatewayFilterFacotry，顾明思议，就是添加请求头的过滤器，可以给请求添加一个请求头并传递到下游微服务。使用的使用只需要在application.yaml中这样配置：

spring:
  cloud:
    gateway:
      routes:
      - id: test_route
        uri: lb://test-service
        predicates:
          -Path=/test/**
        filters:
          - AddRequestHeader=key, value # 逗号之前是请求头的key，逗号之后是value

        如果要让过滤器作用于所有的路由，则可以这样配置：

spring:
  cloud:
    gateway:
      default-filters: # default-filters下的过滤器可以作用于所有路由
        - AddRequestHeader=key, value
      routes:
      - id: test_route
        uri: lb://test-service
        predicates:
          -Path=/test/**

自定义过滤器

        无论是GatewayFilter还是GlobalFilter都支持自定义，只不过编码方式、使用方式略有差别。

自定义GatewayFilter

        自定义GatewayFilter不是直接实现GatewayFilter，而是实现AbstractGatewayFilterFactory(该类的名称一定要以GatewayFilterFactory为后缀！)：

@Component
public class PrintAnyGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {
    @Override
    public GatewayFilter apply(Object config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                // 获取请求
                ServerHttpRequest request = exchange.getRequest();
                // 编写过滤器逻辑
                System.out.println("过滤器执行了");
                // 放行
                return chain.filter(exchange);
            }
        };
    }
}

        然后在yaml配置中这样使用：

spring:
  cloud:
    gateway:
      default-filters:
            - PrintAny # 此处直接以自定义的GatewayFilterFactory类名称前缀类声明过滤器

        另外，这种过滤器还可以支持动态配置参数，不过实现起来比较复杂：

@Component
public class PrintAnyGatewayFilterFactory // 父类泛型是内部类的Config类型
                extends AbstractGatewayFilterFactory<PrintAnyGatewayFilterFactory.Config> {

    @Override
    public GatewayFilter apply(Config config) {
        // OrderedGatewayFilter是GatewayFilter的子类，包含两个参数：
        // - GatewayFilter：过滤器
        // - int order值：值越小，过滤器执行优先级越高
        return new OrderedGatewayFilter(new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                // 获取config值
                String a = config.getA();
                String b = config.getB();
                String c = config.getC();
                // 编写过滤器逻辑
                System.out.println("a = " + a);
                System.out.println("b = " + b);
                System.out.println("c = " + c);
                // 放行
                return chain.filter(exchange);
            }
        }, 100);
    }

    // 自定义配置属性，成员变量名称很重要，下面会用到
    @Data
    static class Config{
        private String a;
        private String b;
        private String c;
    }
    // 将变量名称依次返回，顺序很重要，将来读取参数时需要按顺序获取
    @Override
    public List<String> shortcutFieldOrder() {
        return List.of("a", "b", "c");
    }
        // 返回当前配置类的类型，也就是内部的Config
    @Override
    public Class<Config> getConfigClass() {
        return Config.class;
    }

}

        然后在yaml文件中使用：

spring:
  cloud:
    gateway:
      default-filters:
            - PrintAny=1,2,3 # 注意，这里多个参数以","隔开，将来会按照shortcutFieldOrder()方法返回的参数顺序依次复制

        上面这种配置方式参数必须严格按照shortcutFieldOrder()方法的返回参数名顺序来赋值。

        还有一种用法，可以手动指定参数名：

spring:
  cloud:
    gateway:
      default-filters:
            - name: PrintAny
              args: # 手动指定参数名，无需按照参数顺序
                a: 1
                b: 2
                c: 3

自定义GlobalFilter

        自定义直接实现GlobalFilter即可，而且也无法设置动态参数：

@Component
public class PrintAnyGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 编写过滤器逻辑
        System.out.println("未登录，无法访问");
        // 放行
        // return chain.filter(exchange);

        // 拦截
        ServerHttpResponse response = exchange.getResponse();
        response.setRawStatusCode(401);
        return response.setComplete();
    }

    @Override
    public int getOrder() {
        // 过滤器执行顺序，值越小，优先级越高
        return 0;
    }
}

登录校验

        登录校验需要用到JWT，而且JWT的加密需要秘钥和加密工具。直接在hm-service中拷贝过来：

        其中AuthProperties和JwtProperties所需的属性要在application.yaml中配置：

hm:
  jwt:
    location: classpath:hmall.jks # 秘钥地址
    alias: hmall # 秘钥别名
    password: hmall123 # 秘钥文件密码
    tokenTTL: 30m # 登录有效期
  auth:
    excludePaths: # 无需登录校验的路径
      - /search/**
      - /users/login
      - /items/**

        定义登录校验过滤器：

@Component
@RequiredArgsConstructor
@EnableConfigurationProperties(AuthProperties.class)
public class AuthGlobalFilter implements GlobalFilter, Ordered {
    private final JwtTool jwtTool;
    private final AuthProperties authProperties;
    private final AntPathMatcher antPathMatcher = new AntPathMatcher();
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取Request
        ServerHttpRequest request = exchange.getRequest();
        // 2.判断是否不需要拦截
        if(isExclude(request.getPath().toString())){
            // 无需拦截，直接放行
            return chain.filter(exchange);
        }
        // 3.获取请求头中的token
        String token = null;
        List<String> headers = request.getHeaders().get("authorization");
        if (!CollUtils.isEmpty(headers)) {
            token = headers.get(0);
        }
        // 4.校验并解析token
        Long userId = null;
        try {
            userId = jwtTool.parseToken(token);
        } catch (UnauthorizedException e) {
            // 如果无效，拦截
            ServerHttpResponse response = exchange.getResponse();
            response.setRawStatusCode(401);
            return response.setComplete();
        }
        // TODO 5.如果有效，传递用户信息
        System.out.println("userId = " + userId);
        // 6.放行
        return chain.filter(exchange);
    }
    private boolean isExclude(String antPath) {
        for (String pathPattern : authProperties.getExcludePaths()) {
            if(antPathMatcher.match(pathPattern, antPath)){
                return true;
            }
        }
        return false;
    }
    @Override
    public int getOrder() {
        return 0;
    }
}

微服务获取用户

        网关已经可以完成登录校验并获取登录用户身份信息。但是当网关将请求转发到微服务时，微服务还无法获取用户信息。

        可以将用户信息以请求头的方式传递到下游微服务。然后微服务可以从请求头中获取登录用户信息。由于微服务内部可能很多地方都需要用到登录用户信息，因此可以利用SpringMVC的拦截器来实现登录用户信息获取，并存入ThreadLocal

        修改登录校验拦截器的处理逻辑，在第5步保存用户信息到请求头中：

 // TODO 5.如果有效，传递用户信息
 //System.out.println("userId = " + userId);
 String userInfo = userId.toString();
 ServerWebExchange serverWebExchange = exchange
         .mutate()
         .request(b -> b.header("user-info", userInfo))
         .build();
 // 6.放行
 return chain.filter(serverWebExchange);

        在hm-common中已经有一个用于保存登录用户的ThreadLocal工具编写拦截器，获取用户信息并保存到UserContext，然后放行。

        由于每个微服务都有获取登录用户的需求，因此拦截器直接写在hm-common中，并写好自动装配。这样微服务只需要引入hm-common就可以直接具备拦截器功能。

        在hm-common模块下定义一个UserInfoInterceptor拦截器：

public class UserInfoInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.获取请求头中的用户信息
        String userInfo = request.getHeader("user-info");
        // 2.判断是否为空
        if (StrUtil.isNotBlank(userInfo)) {
            // 不为空，保存到ThreadLocal
                UserContext.setUser(Long.valueOf(userInfo));
        }
        // 3.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserContext.removeUser();
    }
}

        接着在hm-common模块下编写SpringMVC的配置类，配置登录拦截器：

@Configuration
@ConditionalOnClass(DispatcherServlet.class)
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserInfoInterceptor());
    }
}

        基于SpringBoot的自动装配原理，我们要将该配置类添加到resources目录下的META-INF/spring.factories文件中：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.hmall.common.config.MyBatisConfig,\
  com.hmall.common.config.JsonConfig,\
  com.hmall.common.config.MvcConfig

        之前若应cart-service模块中CartServiceImpl类的queryMyCarts方法无法获取登录用户，而将登录用户写死，现在可以恢复到原来的样子。

@Override
public List<CartVO> queryMyCarts() {
    // 1.查询我的购物车列表
    List<Cart> carts = lambdaQuery().eq(Cart::getUserId, UserContext.getUser()).list();
    if (CollUtils.isEmpty(carts)) {
        return CollUtils.emptyList();
    }
    // 2.转换VO
    List<CartVO> vos = BeanUtils.copyList(carts, CartVO.class);
    // 3.处理VO中的商品信息
    handleCartItems(vos);
    // 4.返回
    return vos;
}

OpenFeign传递用户

        请求到达微服务后还需要调用其它多个微服务，想实现微服务之间的用户信息传递，就必须在微服务发起调用时把用户信息存入请求头。微服务之间调用是基于OpenFeign来实现的，可以借助Feign中提供的一个拦截器接口：feign.RequestInterceptor，实现这个接口，然后实现apply方法，利用RequestTemplate类来添加请求头，将用户信息保存到请求头中。

        由于FeignClient全部都是在hm-api模块，因此可以在hm-api模块的DefaultFeignConfig中添加一个Bean来编写这个拦截器：

@Bean
public RequestInterceptor userInfoRequestInterceptor(){
    return new RequestInterceptor() {
        @Override
        public void apply(RequestTemplate template) {
            // 获取登录用户
            Long userId = UserContext.getUser();
            if(userId == null) {
                // 如果为空则直接跳过
                return;
            }
            // 如果不为空则放入请求头中，传递给下游微服务
            template.header("user-info", userId.toString());
        }
    };
}

        编写好后还需要在用到的地方加载该类，比如trade-service模块(可以在EnableFeignClients注解加上defaultConfiguration来加载DefaultFeignConfig中编写的Bean)：

@EnableFeignClients(clients = {ItemClient.class, CartClint.class}, defaultConfiguration = DefaultFeignConfig.class)
@MapperScan("com.hmall.trade.mapper")
@SpringBootApplication
public class TradeApplication {
    public static void main(String[] args) {
        SpringApplication.run(TradeApplication.class, args);
    }
}

配置管理

        已目前为止经解决了微服务相关的一些问题，但是仍然有问题需要解决：

        网关路由在配置文件中写死了，如果变更必须重启微服务
        某些业务配置在配置文件中写死了，每次修改都要重启服务
        每个微服务都有很多重复的配置，维护成本高

        但是这些问题都可以通过统一的配置管理器服务解决。而Nacos不仅仅具备注册中心功能，也具备配置管理的功能。

        网关的路由与微服务共享的配置可以统一交给Nacos保存和管理，在Nacos控制台修改配置后，Nacos会将配置变更推送给相关的微服务，并且无需重启即可生效，实现配置热更新。

配置共享 

添加共享配置 

        可以添加的共享配置由jdbc相关配置、日志配置、swagger以及OpenFeign的配置。

        在nacos控制台的配置管理->配置列表中点击+新建一个配置：

        在弹出的表单中填写信息： 

 

        jdbc详细的配置如下：

spring:
  datasource:
    url: jdbc:mysql://${hm.db.host:192.168.150.101}:${hm.db.port:3306}/${hm.db.database}?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: ${hm.db.un:root}
    password: ${hm.db.pw:123}
mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler
  global-config:
    db-config:
      update-strategy: not_null
      id-type: auto

        jdbc的相关参数并没有完全写死，例如：

        数据库ip：通过${hm.db.host:192.168.150.101}配置了默认值为192.168.150.101，同时允许通过${hm.db.host}来覆盖默认值
        数据库端口：通过${hm.db.port:3306}配置了默认值为3306，同时允许通过${hm.db.port}来覆盖默认值
        数据库database：可以通过${hm.db.database}来设定，无默认值 

        命名为shared-log.yaml的日志配置，其详细配置如下：

logging:
  level:
    com.hmall: debug
  pattern:
    dateformat: HH:mm:ss:SSS
  file:
    path: "logs/${spring.application.name}"

        命名为shared-swagger.yaml的swagger配置，其详细配置如下：

knife4j:
  enable: true
  openapi:
    title: ${hm.swagger.title:黑马商城接口文档}
    description: ${hm.swagger.description:黑马商城接口文档}
    email: ${hm.swagger.email:zhanghuyi@itcast.cn}
    concat: ${hm.swagger.concat:虎哥}
    url: https://www.itcast.cn
    version: v1.0.0
    group:
      default:
        group-name: default
        api-rule: package
        api-rule-resources:
          - ${hm.swagger.package}

        swagger相关配置没有完全写死，例如：

        title：接口文档标题，我们用了${hm.swagger.title}来代替，将来可以有用户手动指定
        email：联系人邮箱，我们用了${hm.swagger.email:zhanghuyi@itcast.cn}，默认值是zhanghuyi@itcast.cn，同时允许用户利用${hm.swagger.email}来覆盖。

拉取共享配置

        SpringCloud在初始化的时候会先读取一个名为bootstrap.yaml(或者bootstrap.properties)的文件，如果将nacos地址配置到bootstrap.yaml中，那么在项目引导阶段就可以读取nacos中的配置，从而在初始化SpringCloud的微服务时先将nacos及其各项配置初始化再初始化application中配置的内容。

        以art-service模块整合Nacos配置管理为例，需要先引入依赖：

  <!--nacos配置管理-->
  <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  </dependency>
  <!--读取bootstrap文件-->
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-bootstrap</artifactId>
  </dependency>

        然后新建bootstrap.yaml

spring:
  application:
    name: cart-service # 服务名称
  profiles:
    active: dev
  cloud:
    nacos:
      server-addr: 192.168.150.101 # nacos地址
      config:
        file-extension: yaml # 文件后缀名
        shared-configs: # 共享配置
          - dataId: shared-jdbc.yaml # 共享mybatis配置
          - dataId: shared-log.yaml # 共享日志配置
          - dataId: shared-swagger.yaml # 共享日志配置

        修改application.yaml

server:
  port: 8082
feign:
  okhttp:
    enabled: true # 开启OKHttp连接池支持
hm:
  swagger:
    title: 购物车服务接口文档
    package: com.hmall.cart.controller
  db:
    database: hm-cart

        最后重启服务，所有配置即可生效。

配置热更新

        有很多的业务相关参数，可能会根据实际情况临时调整，可以在Nacos中添加配置在微服务读取配置，这样就可以不用重启，直接生效。

        下面以购物车业务的购物车数量上限为例。

        在nacos中添加一个配置文件，将购物车的上限数量添加到配置中：

        文件的dataId格式：

        [服务名]-[spring.active.profile].[后缀名]

        文件名称由三部分组成：

        服务名：我们是购物车服务，所以是cart-service
        spring.active.profile：就是spring boot中的spring.active.profile，可以省略，则所有profile共享该配置
        后缀名：例如yaml

        这里直接使用cart-service.yaml这个名称，不管是dev还是local环境都可以共享该配置，内容如下：

hm:
  cart:
    maxAmount: 1 # 购物车商品数量上限

        在cart-service中新建一个属性读取类：

@Data
@Component
@ConfigurationProperties(prefix = "hm.cart")
public class CartProperties {
    private Integer maxAmount;
}

        在业务中使用该属性加载类，更改CartServiceImpl类中的checkCartsFull方法：

private final CartProperties cartProperties;
private void checkCartsFull(Long userId) {
    int count = lambdaQuery().eq(Cart::getUserId, userId).count();
    if (count >= cartProperties.getMaxAmount()) {
        throw new BizIllegalException(StrUtil.format("用户购物车课程不能超过{}", 10));
    }
}

动态路由

        网关的路由配置全部是在项目启动时加载，一经加载就会缓存到内存中的路由表内，不会改变，也不会监听路由变更。监听Nacos的配置变更，可以使用 Nacos 动态监听配置接口中的addListener接口来实现。

        addListener接口中需要传入三个参数：

参数名	参数类型	描述
dataId	string	配置 ID，保证全局唯一性，只允许英文字符和 4 种特殊字符（"."、":"、"-"、"_"）。不超过 256 字节。
group	string	配置分组，一般是默认的DEFAULT_GROUP。
listener	Listener	监听器，配置变更进入监听器的回调函数。

        在使用之前需要先在网关gateway引入依赖：

<!--统一配置管理-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<!--加载bootstrap-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>

        然后在网关gateway创建bootstrap.yaml配置文件：

spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: 192.168.150.101
      config:
        file-extension: yaml
        shared-configs:
          - dataId: shared-log.yaml # 共享日志配置

        修改gateway的application.yml配置文件，将之前的路由移除：

server:
  port: 8080 # 端口
hm:
  jwt:
    location: classpath:hmall.jks # 秘钥地址
    alias: hmall # 秘钥别名
    password: hmall123 # 秘钥文件密码
    tokenTTL: 30m # 登录有效期
  auth:
    excludePaths: # 无需登录校验的路径
      - /search/**
      - /users/login
      - /items/**

        定义配置监听器：

@Slf4j
@Component
@RequiredArgsConstructor
public class DynamicRouteLoader {
    private final RouteDefinitionWriter writer;
    private final NacosConfigManager nacosConfigManager;
    // 路由配置文件的id和分组
    private final String dataId = "gateway-routes.json";
    private final String group = "DEFAULT_GROUP";
    // 保存更新过的路由id
    private final Set<String> routeIds = new HashSet<>();
    @PostConstruct
    public void initRouteConfigListener() throws NacosException {
        // 1.注册监听器并首次拉取配置
        String configInfo = nacosConfigManager.getConfigService()
                .getConfigAndSignListener(dataId, group, 5000, new Listener() {
                    @Override
                    public Executor getExecutor() {
                        return null;
                    }
                    @Override
                    public void receiveConfigInfo(String configInfo) {
                        updateConfigInfo(configInfo);
                    }
                });
        // 2.首次启动时，更新一次配置
        updateConfigInfo(configInfo);
    }
    private void updateConfigInfo(String configInfo) {
        log.debug("监听到路由配置变更，{}", configInfo);
        // 1.反序列化
        List<RouteDefinition> routeDefinitions = JSONUtil.toList(configInfo, RouteDefinition.class);
        // 2.更新前先清空旧路由
        // 2.1.清除旧路由
        for (String routeId : routeIds) {
            writer.delete(Mono.just(routeId)).subscribe();
        }
        routeIds.clear();
        // 2.2.判断是否有新的路由要更新
        if (CollUtils.isEmpty(routeDefinitions)) {
            // 无新路由配置，直接结束
            return;
        }
        // 3.更新路由
        routeDefinitions.forEach(routeDefinition -> {
            // 3.1.更新路由
            writer.save(Mono.just(routeDefinition)).subscribe();
            // 3.2.记录路由id，方便将来删除
            routeIds.add(routeDefinition.getId());
        });
    }
}

        在Nacos控制台添加路由，路由文件名为gateway-routes.json，类型为json：

        配置内容如下：

[
    {
        "id": "item",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/items/**", "_genkey_1":"/search/**"}
        }],
        "filters": [],
        "uri": "lb://item-service"
    },
    {
        "id": "cart",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/carts/**"}
        }],
        "filters": [],
        "uri": "lb://cart-service"
    },
    {
        "id": "user",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/users/**", "_genkey_1":"/addresses/**"}
        }],
        "filters": [],
        "uri": "lb://user-service"
    },
    {
        "id": "trade",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/orders/**"}
        }],
        "filters": [],
        "uri": "lb://trade-service"
    },
    {
        "id": "pay",
        "predicates": [{
            "name": "Path",
            "args": {"_genkey_0":"/pay-orders/**"}
        }],
        "filters": [],
        "uri": "lb://pay-service"
    }
]