简介：来源：SpringCloud微服务开发与实战，java黑马商城项目微服务实战开发（涵盖MybatisPlus、Docker、MQ、ES、Redis高级等）

认识网关

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

• 网关可以做安全控制，也就是登录身份校验，校验通过才放行
• 通过认证后，网关再根据请求判断应该访问哪个微服务，将请求转发过去
  
  在SpringCloud当中，提供了两种网关实现方案：
• Netflix Zuul：早期实现，目前已经淘汰
• SpringCloudGateway：基于Spring的WebFlux技术，完全支持响应式编程，吞吐能力更强。
  SpringCloudGateway官网：https://spring.io/projects/spring-cloud-gateway#learn
  

网关路由-快速入门

接下来，我们先看下如何利用网关实现请求路由。由于网关本身也是一个独立的微服务，因此也需要创建一个模块开发功能。大概步骤如下：

• 创建网关微服务
• 引入SpringCloudGateway、NacosDiscovery依赖
• 编写启动类
• 配置网关路由

1、创建项目
首先，我们要创建一个新的module，比如命名为gateway，作为网关微服务：

2、引入依赖
在gateway模块的pom.xml文件中引入依赖

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

3、编写启动类
在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.254.129: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/**

网关路由-路由属性

网关路由对应的Java类型是RouteDefinition，其中常见的属性有

• id:路由唯一标示
• uri:路由目标地址
• predicates: 路由断言，判断请求是否符合当前路由
• filters:路由过滤器，对请求或响应做特殊处理

Spring Cloud Gateway官网：https://docs.spring.io/spring-cloud-gateway/docs/3.1.9/reference/html/

1、路由断言
12种Route Predicate Factories实现示例

2、路由过滤器
33种路由过滤器官网实现示例

在default-filters下设置的过滤器对所有路由生效：

spring:
  cloud:
    gateway:
      routes:
        - id: item
          uri: lb://item-service
          predicates:
            - Path=/items/**,/search/**
      default-filters:
        - AddRequestHeader=truth, anyone long-press like button will be rich

网关登录校验-思路分析

注意：NettyRoutingFilter是做请求转发的，所以应该在NettyRoutingFilter之前且在过滤器的pre逻辑之前进行登录校验

网关登录校验-自定义过滤器

自定义GlobalFilter过滤器

进行登录校验一般都选择自定义GlobalFilter过滤器

自定义GagtewayFilter过滤器

自定义GagtewayFilter过滤器比较麻烦，大多数情况都选择自定义GlobalFilter过滤器

自定义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

网关登录校验-网关实现登录校验（网关到微服务的用户传递）

整体实现思路：

一、在网关的登录校验过滤器中，将从token解析出来的用户Id写入请求头并传递到微服务：
需求:修改gateway模块中的登录校验拦截器，在校验成功后保存用户到下游请求的请求头中
提示: 要修改转发到微服务的请求，需要用到ServerWebExchange类提供的API，示例如下:

package com.hmall.gateway.filter;

import com.hmall.common.exception.UnauthorizedException;
import com.hmall.common.utils.CollUtils;
import com.hmall.gateway.config.AuthProperties;
import com.hmall.gateway.utils.JwtTool;
import lombok.AllArgsConstructor;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
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
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    @Autowired
    private AuthProperties authProperties;

    @Autowired
    private JwtTool jwtTool;

    private final AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1、获取request
        ServerHttpRequest request = exchange.getRequest();
        //2、判断是否需要做登录拦截（即判断此请求路径是否在hm.auth的排除路径里）（排除路径就是：不需要登录就可以访问的路径）
        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){
            //拦截，设置响应状态码为401
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }

        //TODO 5、传递用户信息
        String userInfo = userId.toString();
        ServerWebExchange swe = exchange.mutate()
                .request(builder -> builder.header("user-info", userInfo))
                .build();
        //6、放行
        return chain.filter(swe);
    }

    private boolean isExclude(String path) {
        for (String pathPattern : authProperties.getExcludePaths()) {
            if (antPathMatcher.match(pathPattern,path)){
                return true;
            }
        }
        return false;
    }

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

二、在common（公共模块）中编写SpringMVC拦截器，获取登录用户：
需求:由于每个微服务都可能有获取登录用户的需求，因此我们直接在common公共模块定义拦截器，这样微服务只需要引入依赖即可生效，无需重复编写。

拦截器类实现：

package com.hmall.common.interceptors;

import cn.hutool.core.util.StrUtil;
import com.hmall.common.utils.UserContext;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//只用来获取登录用户的信息，不需要做登录拦截，因为真正的登录拦截校验已经在网关做过了
public class UserInfoInterceptor implements HandlerInterceptor {
    @Override//preHandle是在Controller之前执行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.获取请求头中的用户信息
        String userInfo = request.getHeader("user-info");
        // 2.判断是否为空
        if (StrUtil.isNotBlank(userInfo)) {//StrUtil.isNotBlank(userInfo)：判断userInfo字符串不能为null且不能为空
            // 不为空，保存到ThreadLocal
            UserContext.setUser(Long.valueOf(userInfo));//UserContext是ThreadLocal工具类，方便调用
        }
        // 3.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserContext.removeUser();//在Controller执行完后一定要清理用户
    }
}

ThreadLocal工具类实现：

package com.hmall.common.utils;

public class UserContext {
    private static final ThreadLocal<Long> tl = new ThreadLocal<>();

    /**
     * 保存当前登录用户信息到ThreadLocal
     * @param userId 用户id
     */
    public static void setUser(Long userId) {
        tl.set(userId);
    }

    /**
     * 获取当前登录用户信息
     * @return 用户id
     */
    public static Long getUser() {
        return tl.get();
    }

    /**
     * 移除当前登录用户信息
     */
    public static void removeUser(){
        tl.remove();
    }
}

注意：Spring MVC的拦截器要想生效，必须要进行配置，也就是需要注册
重点：SpringBoot自动装配原理：要想使在不同包路径下的Spring扫不到的那些配置类生效**，则需要在resource目录下的META-INF包下定义一个spring.factories文件去记录这些配置类
扩展： 在新版本的springboot中spring.factories文件名已经改了。

配置类实现：

package com.hmall.common.config;

import com.hmall.common.interceptors.UserInfoInterceptor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

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

spring.factories文件实现：

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

可以遇到的问题与报错：
①因为此模块是common公共模块，在微服务中网关模块pom.xml也可能需要引入common公共模块依赖； ②又因为WebMvcConfigurer属于spring mvc包下的，而网关不是SpringMvc环境的，而是一种非阻塞式的响应式编程。
所以为了避免冲突，使此配置类只在微服务生效而不在网关生效 。
解决方法：
关键：Springboot自动装配原理是可以带条件的。
方法：在配置类中加一个条件@ConditionalOnClass(DispatcherServlet.class)
详解：DispatcherServlet.class（SpringMvc的核心API）判断此类在此环境中是否存在，存在则生效；这样就可以使此配置类只在微服务生效而不在网关生效，避免了冲突。

知识扩展：
@ConditionalOnClass(DispatcherServlet.class) 注解是 Spring Boot 的条件化配置注解之一。它的作用是使得该配置类（MvcConfig）只在 DispatcherServlet 类存在于类路径中时才会被加载。这意味着：

1. 条件化加载：如果项目中没有 DispatcherServlet 类，Spring Boot 就不会加载这个配置类。通常，DispatcherServlet 是 Spring MVC 的核心组件，因此这个条件常用于确保该配置只在启用了 Spring MVC 的环境下生效。

2. 用于模块化：通过这种方式，你可以确保配置类只在需要时才会被创建，从而减少不必要的配置和开销。

3. 增强灵活性：这种做法使得应用更具灵活性，因为你可以在不同的环境中选择性地加载不同的配置。
   总结：
   @ConditionalOnClass(DispatcherServlet.class) 的使用在这里确保只有在有 Spring MVC 环境时，相关的拦截器和配置才会被应用，避免在不需要 MVC 功能的情况下进行不必要的配置。

网关登录校验-OpenFeign传递用户信息（微服务之间的用户传递）

总结