一，网关路由

由于每个微服务都有不同的地址或端口，入口不同，在与前端联调的时候存在问题：

• 请求不同数据时要访问不同的入口，需要维护多个入口地址，麻烦
• 前端无法调用nacos，无法实时更新服务列表

单体架构时我们只需要完成一次用户登录、身份校验，就可以在所有业务中获取到用户信息。而微服务拆分后，每个微服务都独立部署，这就存在一些问题：

• 每个微服务都需要编写登录校验、用户信息获取的功能吗？
• 当微服务之间调用时，该如何传递用户信息？

通过网关技术解决上述问题。

• 网关路由，解决前端请求入口的问题。
• 网关鉴权，解决统一登录校验和用户信息获取的问题。
• 统一配置管理，解决微服务的配置文件重复和配置热更新问题。

1.1 网关路由

1.1.1 什么是网关

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

更通俗的来讲，网关就像是以前园区传达室的大爷。

• 外面的人要想进入园区，必须经过大爷的认可，如果你是不怀好意的人，肯定被直接拦截。
• 外面的人要传话或送信，要找大爷。大爷帮你带给目标人。

现在，微服务网关就起到同样的作用。前端请求不能直接访问微服务，而是要请求网关：

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

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

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

1.1.2 快速入门

由于网关本身也是一个独立的微服务，因此也需要创建一个模块开发功能。大概步骤如下：

1. 创建网关微服务

2. 引入 SpringCloudGateway、NacosDiscovery 依赖

   <!--网关-->
   <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>
   

3. 编写启动类

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

4. 配置网关路由

   在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/**
   
   

5. 启动GatewayApplication，以 http://localhost:8080 拼接微服务接口路径来测试。例如：

   http://localhost:8080/items/page?pageNo=1&pageSize=1

1.1.3 路由过滤

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

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

其中 routes 对应的类型如下：

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

四个属性含义如下：

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

这里我们重点关注predicates，也就是路由断言。SpringCloudGateway 中支持的断言类型有很多：

2.2 网关鉴权

单体架构时我们只需要完成一次用户登录、身份校验，就可以在所有业务中获取到用户信息。而微服务拆分后，每个微服务都独立部署，不再共享数据。也就意味着每个微服务都需要做登录校验，这显然不可取。

2.2.1 鉴权思路分析

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

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

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

• 只需要在网关和用户服务保存秘钥
• 只需要在网关开发登录校验功能

此时，登录校验的流程如图：

不过，这里存在几个问题：

• 网关路由是配置的，请求转发是Gateway内部代码，我们如何在转发之前做登录校验？
• 网关校验JWT之后，如何将用户信息传递给微服务？
• 微服务之间也会相互调用，这种调用不经过网关，又该如何传递用户信息？

2.2.2 网关过滤器

登录校验必须在请求转发到微服务之前做，否则就失去了意义。而网关的请求转发是Gateway内部代码实现的，要想在请求转发之前做登录校验，就必须了解Gateway内部工作的基本原理。

如图所示：

1. 客户端请求进入网关后由HandlerMapping对请求做判断，找到与当前请求匹配的路由规则（Route），然后将请求交给WebHandler去处理。
2. WebHandler则会加载当前路由下需要执行的过滤器链（Filter chain），然后按照顺序逐一执行过滤器（后面称为**Filter**）。
3. 图中Filter被虚线分为左右两部分，是因为Filter内部的逻辑分为pre和post两部分，分别会在请求路由到微服务之前和之后被执行。
4. 只有所有Filter的pre逻辑都依次顺序执行通过后，请求才会被路由到微服务。
5. 微服务返回结果后，再倒序执行Filter的post逻辑。
6. 最终把响应结果返回。

如图中所示，最终请求转发是有一个名为NettyRoutingFilter的过滤器来执行的，而且这个过滤器是整个过滤器链中顺序最靠后的一个。如果我们能够定义一个过滤器，在其中实现登录校验逻辑，并且将过滤器执行顺序定义到NettyRoutingFilter之前，这就符合我们的需求了！

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

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

注意：过滤器链之外还有一种过滤器，HttpHeadersFilter，用来处理传递到下游微服务的请求头。例如org.springframework.cloud.gateway.filter.headers.XForwardedHeadersFilter可以传递代理请求原本的 host 头到下游微服务。

其实GatewayFilter和GlobalFilter这两种过滤器的方法签名完全一致：

/**
 * 处理请求并将其传递给下一个过滤器
 * @param exchange 当前请求的上下文，其中包含request、response等各种数据
 * @param chain 过滤器链，基于它向下传递请求
 * @return 根据返回值标记当前请求是否被完成或拦截，chain.filter(exchange)就放行了。
 */
Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);

FilteringWebHandler在处理请求时，会将GlobalFilter装饰为GatewayFilter，然后放到同一个过滤器链中，排序以后依次执行。

Gateway中内置了很多的GatewayFilter，详情可以参考官方文档：Spring Cloud Gateway

Gateway内置的GatewayFilter过滤器使用起来非常简单，无需编码，只要在yaml文件中简单配置即可。而且其作用范围也很灵活，配置在哪个Route下，就作用于哪个Route.

例如，有一个过滤器叫做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/**

2.2.3 自定义过滤器

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

• 自定义GatewayFilter

  自定义GatewayFilter不是直接实现GatewayFilter，而是实现AbstractGatewayFilterFactory。最简单的方式是这样的：

  @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);
              }
          };
      }
  }
  

  注意：该类的名称一定要以GatewayFilterFactory为后缀！

  然后在 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 则简单很多，直接实现 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;
      }
  }
  

2.2.4 登录校验

利用自定义GlobalFilter来完成登录校验。

package com.hm.gateway.filter;

import com.hmall.common.exception.UnauthorizedException;
import com.hmall.common.utils.CollUtils;
import com.hm.gateway.config.AuthProperties;
import com.hm.gateway.util.JwtTool;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.List;

@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;
    }
}

2.2.5 微服务获取用户

现在，网关已经可以完成登录校验并获取登录用户身份信息。但是当网关将请求转发到微服务时，微服务又该如何获取用户身份呢？

由于网关发送请求到微服务依然采用的是Http请求，因此我们可以将用户信息以请求头的方式传递到下游微服务。然后微服务可以从请求头中获取登录用户信息。考虑到微服务内部可能很多地方都需要用到登录用户信息，因此我们可以利用SpringMVC的拦截器来实现登录用户信息获取，并存入ThreadLocal，方便后续使用。

据图流程图如下：

因此，接下来我们要做的事情有：

• 改造网关过滤器，在获取用户信息后保存到请求头，转发到下游微服务
• 编写微服务拦截器，拦截请求获取用户信息，保存到ThreadLocal后放行

1. 保存用户到请求头

   首先，我们修改登录校验拦截器的处理逻辑，保存用户信息到请求头中：
   

2. 拦截器获取用户

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

   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();
       }
   }
   

   然后配置这个拦截器

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

   不过，需要注意的是，这个配置类默认是不会生效的，因为它所在的包是com.hmall.common.config，与其它微服务的扫描包不一致，无法被扫描到，因此无法生效。

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

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

2.2.6 OpenFeign传递用户

前端发起的请求都会经过网关再到微服务，由于我们之前编写的过滤器和拦截器功能，微服务可以轻松获取登录用户信息。

但有些业务是比较复杂的，请求到达微服务后还需要调用其它多个微服务。比如下单业务，流程如下：

下单的过程中，需要调用商品服务扣减库存，调用购物车服务清理用户购物车。而清理购物车时必须知道当前登录的用户身份。但是，订单服务调用购物车时并没有传递用户信息，购物车服务无法知道当前用户是谁！

由于微服务获取用户信息是通过拦截器在请求头中读取，因此要想实现微服务之间的用户信息传递，就必须在微服务发起调用时把用户信息存入请求头。

微服务之间调用是基于OpenFeign来实现的，并不是我们自己发送的请求。我们如何才能让每一个由OpenFeign发起的请求自动携带登录用户信息呢？

这里要借助 Feign 中提供的一个拦截器接口：feign.RequestInterceptor

public interface RequestInterceptor {
  /**
   * Called for every request. 
   * Add data using methods on the supplied {@link RequestTemplate}.
   */
  void apply(RequestTemplate template);
}

我们只需要实现这个接口，然后实现 apply 方法，利用RequestTemplate类来添加请求头，将用户信息保存到请求头中。这样以来，每次 OpenFeign 发起请求的时候都会调用该方法，传递用户信息。

由于FeignClient全部都是在api-service模块，因此我们在api-service模块的com.hm.api.config.DefaultFeignConfig中编写这个拦截器：

在com.hm.api.config.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());
        }
    };
}