springboot使用Gateway做网关并且配置全局拦截器

一、为什么要用网关

统一入口：

作用：作为所有客户端请求的统一入口。
说明：所有客户端请求都通过网关进行路由，网关负责将请求转发到后端的微服务

路由转发：

作用：根据请求的URL、方法等信息将请求路由到不同的微服务。
说明：网关可以根据配置的路由规则，将请求转发到正确的微服务，实现请求的路由和负载均衡。

负载均衡：

作用：实现请求的负载均衡。
说明：网关可以集成负载均衡组件（如Ribbon），根据负载均衡策略将请求分发到不同的服务实例，提高系统的可用性和扩展性。

服务发现：

作用：与服务注册中心集成，实现服务的自动发现。
说明：网关可以与Eureka等服务注册中心集成，动态获取服务实例的信息，实现服务的自动发现和路由。

认证与授权：

作用：提供统一的安全认证和授权机制。
说明：网关可以集成认证和授权组件（如OAuth2、JWT），对所有进入的请求进行安全检查，确保只有合法的请求才能访问后端服务。

跨域资源共享（CORS）：

作用：处理跨域请求。
说明：网关可以处理跨域请求，允许来自不同域的客户端访问后端服务，解决了浏览器的同源策略限制。

二、Gateway简单使用

第一步：引入Gateway的maven依赖到pom.xml文件

        <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-gateway</artifactId>
        </dependency>

第二步：编写配置文件application.yml文件，如下所示:

server:
  port: 10086   # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848    # nacos 地址
    gateway:
      routes:         # 网关路由配置
        - id: provider      # 路由id，自定义，只要唯一即可
          # uri: http://127.0.0.1:8081   # 路由的目标地址 (直接写死地址的方式，不推荐)
          uri: lb://provider    # 路由的目标地址 lb是负载均衡，后面跟服务名称(推荐)
          predicates:       # 路由断言，判断请求是否符合路由规则的条件
            - Path=/provider/**      # 按照路径匹配，以/user/开头的请求就符合要求

第三步：启动测试

当然要注意的是我们需要开启另一个服务provider服务，并且这个服务需要配置方法前缀/provider，当我们通过网关访问的时候就可以直接的访问到provider服务了。

三、Gateway断言工厂

路由断言主要用来判断路由的规则。

配置文件中写的断言规则只是字符串，这些字符串会被Predicate Factory读取并处理。

例如Path=/user/**是按照路径匹配，这个规则是由org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory类来处理。

像这样的断言工厂在SpringCloudGateway还有十几个:

当然这个地方可能给的不是很全所以我贴出官网地址：大家需要的可以去看官网：Spring Cloud Gatewayhttps://docs.spring.io/spring-cloud-gateway/docs/3.1.4-SNAPSHOT/reference/html/#gateway-request-predicates-factories

简单示例，下面我配置一个在访问之前需要到一定的时间才可以访问，并且看一下效果

server:
  port: 10086   # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848    # nacos 地址
    gateway:
      routes:         # 网关路由配置
        - id: provider      # 路由id，自定义，只要唯一即可
          # uri: http://127.0.0.1:8081   # 路由的目标地址 (直接写死地址的方式，不推荐)
          uri: lb://provider    # 路由的目标地址 lb是负载均衡，后面跟服务名称(推荐)
          predicates:       # 路由断言，判断请求是否符合路由规则的条件
            - Path=/provider/**      # 按照路径匹配，以/user/开头的请求就符合要求
            - After=2031-01-20T17:42:47.789-07:00[America/Denver]

因为我配置了需要在2031年1月20号后才可以访问明显现在是2024年不可以访问到，所以会报错404。

四、Gateway路由过滤器

客户端请求先找到路由，路由匹配时经过过滤器层层筛选，最终访问到微服务。

当然微服务的请求反悔时，也会经过过滤器的筛选，只不过我们一般只对请求过滤，而不会对响应过滤。

SpringCloudGateWay目前已经提供了34种不同的过滤器工厂。感兴趣的大家也可以去上面给出的官网地址查看。

下面我在路由过滤器中添加一个请求头，并且需要在provider请求中加入一个参数去拿到请求头中的参数

server:
  port: 10086   # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848    # nacos 地址
    gateway:
      routes:         # 网关路由配置
        - id: provider      # 路由id，自定义，只要唯一即可
          # uri: http://127.0.0.1:8081   # 路由的目标地址 (直接写死地址的方式，不推荐)
          uri: lb://provider    # 路由的目标地址 lb是负载均衡，后面跟服务名称(推荐)
          predicates:       # 路由断言，判断请求是否符合路由规则的条件
            - Path=/provider/**      # 按照路径匹配，以/user/开头的请求就符合要求
          filters: # 过滤器配置
            - AddRequestHeader=token, test # 添加请求头

provider请求变为，需要拿到请求头中的信息

    @GetMapping("/provider/t")
    public String t(@RequestHeader(value = "token",required = false)String token){
        return "恭喜您测试成功啦！"+token;
    }

测试

当然这是局部配置我们也可以针对所有的路由进行全局配置（但是这个配置是需要和路由s是同级的），如下所示：

server:
  port: 10086   # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848    # nacos 地址
    gateway:
      routes:         # 网关路由配置
        - id: provider      # 路由id，自定义，只要唯一即可
          # uri: http://127.0.0.1:8081   # 路由的目标地址 (直接写死地址的方式，不推荐)
          uri: lb://provider    # 路由的目标地址 lb是负载均衡，后面跟服务名称(推荐)
          predicates:       # 路由断言，判断请求是否符合路由规则的条件
            - Path=/provider/**      # 按照路径匹配，以/user/开头的请求就符合要求
      default-filters: # 默认过滤器配置
        - AddRequestHeader=token, test  # 添加请求头

五、Gateway全局过滤器

上面的gateway路由器可以配置全局的，为什么还需要有一个全局过滤器呢，因为上面的过滤器都是只可以针对与一些逻辑的拦截，但是不可以涉及到一些业务的处理，所以就有这个全局过滤器可以通过编写代码的方式来编写业务逻辑进行对用户访问的鉴权放行等等。

package com.example.demo.filter;

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.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class GateWayFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                // 1.获取请求参数
                //1.这里的request并不是servlet中的request
                //2.返回值是一个多键的map集合、也就是说这个map集合的键可以重复
                MultiValueMap<String, String> params = exchange.getRequest().getQueryParams();
                // 2.获取userName参数
                String userName = params.getFirst("userName");
                // 3.校验
                if ("root".equals(userName)) {
                    // 放行
                    return chain.filter(exchange);
                }
                // 4.拦截
                // 4.1.禁止访问，设置状态码
                exchange.getResponse().setStatusCode(HttpStatus.valueOf(500));
                // 4.2.结束处理
                return exchange.getResponse().setComplete();
    }

    //过滤器优先级，数字越小优先级越高
    @Override
    public int getOrder() {
        return -1;
    }
}

测试：

我们先正常的访问之前的请求，会发现无法使用此页面也就是被拒绝访问了

当我们加上一个参数后把userName=root加上之后就可以正确的访问到请求了

过滤器链执行顺序

SpringCloudGateWay中，有三种过滤器：

默认过滤器default-filters
只对具体某个路由生效的局部过滤器filters
使用java代码编写的全局过滤器GlobalFilter

过滤器最终都会转化成GlobalFilter（使用的是适配器模式）所以我们就可以把这三种过滤器看成一个整体而顺序也入下图显示的一致。

由上图知过滤器的执行顺序为：默认过滤器 → 当前路由过滤器 → 全局过滤器。

六、Gateway跨域请求配置

1.跨域请求定义

跨域：请求位置和被请求位置不同源就会发生跨域。

这里的不同源包括两个点：

域名不同：www.baidu.com 和 www.taobao.com。（IP不同也是相同道理）
端口不同：127.0.0.1:8080和127.0.0.1:8081。

而浏览器又会禁止请求的发起者与服务端发生跨域AJAX请求。

如果发生了跨域请求，服务器端是能够正常响应的，但是响应的结果会被浏览器拦截。

2.跨域常见解决方案

使用CORS方式。

CORS是一个W3C标准，全称是"跨域资源共享"（Cross-origin resource sharing）。

它允许浏览器向跨源服务器，发出XMLHttpRequest请求，从而克服了AJAX只能同源使用的限制。

3.跨域请求解决方案

方式一：配置application.yml文件：

spring:
  cloud:
    gateway:
      globalcors: # 全局的跨域配置
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
               # options请求 就是一种询问服务器是否浏览器可以跨域的请求
               # 如果每次跨域都有询问服务器是否浏览器可以跨域对性能也是损耗
               # 可以配置本次跨域检测的有效期maxAge
               # 在maxAge设置的时间范围内，不去询问，统统允许跨域
        corsConfigurations:
          '[/**]':
            allowedOrigins:   # 允许哪些网站的跨域请求 
              - "http://localhost:8090"
            allowedMethods:   # 允许的跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*"  # 允许在请求中携带的头信息
            allowCredentials: true # 允许在请求中携带cookie
            maxAge: 360000    # 本次跨域检测的有效期(单位毫秒)
                  # 有效期内，跨域请求不会一直发option请求去增大服务器压力

方式二：使用编码方式定义配置类：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.cors.reactive.CorsUtils;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;
 
@Configuration
public class CorsConfig {
    private static final String MAX_AGE = "18000L";
 
    @Bean
    public WebFilter corsFilter() {
        return (ServerWebExchange ctx, WebFilterChain chain) -> {
            ServerHttpRequest request = ctx.getRequest();
            // 使用SpringMvc自带的跨域检测工具类判断当前请求是否跨域
            if (!CorsUtils.isCorsRequest(request)) {
                return chain.filter(ctx);
            }
            HttpHeaders requestHeaders = request.getHeaders();                                  // 获取请求头
            ServerHttpResponse response = ctx.getResponse();                                    // 获取响应对象
            HttpMethod requestMethod = requestHeaders.getAccessControlRequestMethod();          // 获取请求方式对象
            HttpHeaders headers = response.getHeaders();                                        // 获取响应头
            headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, requestHeaders.getOrigin());   // 把请求头中的请求源（协议+ip+端口）添加到响应头中（相当于yml中的allowedOrigins）
            headers.addAll(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, requestHeaders.getAccessControlRequestHeaders());
            if (requestMethod != null) {
                headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, requestMethod.name());    // 允许被响应的方法（GET/POST等，相当于yml中的allowedMethods）
            }
            headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");          // 允许在请求中携带cookie（相当于yml中的allowCredentials）
            headers.add(HttpHeaders.ACCESS_CONTROL_EXPOSE_HEADERS, "*");                // 允许在请求中携带的头信息（相当于yml中的allowedHeaders）
            headers.add(HttpHeaders.ACCESS_CONTROL_MAX_AGE, MAX_AGE);                           // 本次跨域检测的有效期(单位毫秒，相当于yml中的maxAge)
            if (request.getMethod() == HttpMethod.OPTIONS) {                                    // 直接给option请求反回结果
                response.setStatusCode(HttpStatus.OK);
                return Mono.empty();
            }
            return chain.filter(ctx);                                                           // 不是option请求则放行
        };
    }
 
}