Spring Cloud Gateway 网关核心原理与使用指南

2. 编写启动类

package com.cloud.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);
    }
}

3. 配置文件

server:
  port: 10030 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      discovery:
        server-addr: nacos 的 ip 地址 + 端口号
    gateway:
      routes:
        # 网关路由配置
        - id: product-service # 路由 ID，自定义，唯一即可
          uri: lb://product-service # 目标服务地址
          predicates:
            # 路由条件
            - Path=/product/**
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/order/**

配置字段说明：

• id：自定义路由 ID，保持唯一
• uri：目标服务地址，支持普通 URI 及 lb://应用注册服务名称。lb 表示负载均衡，使用 lb:// 方式表示从注册中心获取服务地址。
• predicates：路由条件，根据匹配结果决定是否执行该请求路由，上述代码中，我们把符合 Path 规则的一切请求，都代理到 uri 参数指定的地址。

三、Route Predicate Factories

3.1 Predicate

Predicate 是 Java 8 提供的一个函数式编程接口，它接收一个参数并返回一个布尔值，用于条件过滤，请求参数的校验。

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    // ...
}

写一个判断字符串为空的 Predicate 函数：

package predicate;

import java.util.function.Predicate;

/**
 * 字符串为空或 null 时返回 true
 */
public class StringPredicate implements Predicate<String> {
    @Override
    public boolean test(String s) {
        return s == null || s.isEmpty();
    }
}

使用匿名内部类和 lambda 表达式实现：

package predicate;

import org.junit.Test;
import java.util.function.Predicate;

public class StringPredicateTest {
    @Test
    public void test() {
        StringPredicate stringPredicate = new StringPredicate();
        System.out.println(stringPredicate.test("")); // true
        System.out.println(stringPredicate.test("123")); // false
        System.out.println(stringPredicate.test(null)); // true
    }

    // 匿名内部类
    @Test
    public void test2() {
        Predicate<String> stringPredicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s == null || s.isEmpty();
            }
        };
        System.out.println(stringPredicate.test("")); // true
        System.out.println(stringPredicate.test("123")); // false
        System.out.println(stringPredicate.test(null)); // true
    }

    // lambda 表达式
    @Test
    public void test3() {
        Predicate<String> stringPredicate = s -> s == null || s.isEmpty();
        System.out.println(stringPredicate.test("")); // true
        System.out.println(stringPredicate.test("123")); // false
        System.out.println(stringPredicate.test(null)); // true
    }
}

其他方法：

• isEqual(Object targetRef) : 比较两个对象是否相等，参数可以为 Null
• and(Predicate other)：短路与操作，返回一个组成 Predicate
• or(Predicate other)：短路或操作，返回一个组成 Predicate
• test(T t)：传入一个 Predicate 参数，用来做判断
• negate()：返回表示此 Predicate 逻辑否定的 Predicate

3.2 Route Predicate Factories

Route Predicate Factories (路由断言工厂，也称为路由谓词工厂)，在 Spring Cloud Gateway 中，Predicate 提供了路由规则的匹配机制。 我们在配置文件中写的断言规则只是字符串，这些字符串会被 Route Predicate Factory 读取并处理，转变为路由判断的条件。

这个规则是由 org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory 来实现的。 Spring Cloud Gateway 默认提供了很多 Route Predicate Factory，这些 Predicate 会分别匹配 HTTP 请求的不同属性，并且多个 Predicate 可以通过 and 逻辑进行组合。

参考链接：https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/request-predicates-factories.html#page-title

3.3 Gateway Filter Factories(网关过滤器工厂)

Predicate 决定了请求由哪一个路由处理，如果在请求处理前后需要加一些逻辑，这就是 Filter(过滤器) 的作用范围了。 Filter 分为两种类型：Pre 类型和 Post 类型。

• Pre 类型过滤器：路由处理之前执行 (请求转发到后端服务之前执行)，在 Pre 类型过滤器中可以做鉴权，限流等。
• Post 类型过滤器：请求执行完成后，将结果返回给客户端之前执行。

Spring Cloud Gateway 中内置了很多 Filter，用于拦截和链式处理 web 请求。比如权限校验，访问超时等设定。 Spring Cloud Gateway 从作用范围上，把 Filter 可分为 GatewayFilter 和 GlobalFilter。

• GatewayFilter：应用到单个路由或者一个分组的路由上。
• GlobalFilter：应用到所有的路由上，也就是对所有的请求生效。

3.3.1 GatewayFilter

官方文档：https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/gatewayfilter-factories.html#page-title

GatewayFilter 同 Predicate 类似，都是在配置文件 application.yml 中配置，每个过滤器的逻辑都是固定的。比如 AddRequestParameterGatewayFilterFactory 只需要在配置文件中写 AddRequestParameter，就可以为所有的请求添加一个参数。

3.3.2 GlobalFilter

官方链接：https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/global-filters.html#gateway-combined-global-filter-and-gatewayfilter-ordering

GlobalFilter 是 Spring Cloud Gateway 中的全局过滤器，它和 GatewayFilter 的作用是相同的。GlobalFilter 会应用到所有的路由请求上，全局过滤器通常用于实现与安全性，性能监控和日志记录等相关的全局功能。 Spring Cloud Gateway 内置的全局过滤器也有很多，比如：

• Gateway Metrics Filter：网关指标，提供监控指标
• Forward Routing Filter：用于本地 forword，请求不转发到下游服务器
• LoadBalancer Client Filter：针对下游服务，实现负载均衡。

3.4 过滤器执行顺序

一个项目中，既有 GatewayFilter，又有 GlobalFilter 时，执行的先后顺序是： 请求路由后，网关会把当前项目中的 GatewayFilter 和 GlobalFilter 合并到一个过滤器链 (集合) 中，并进行排序，依次执行过滤器。

每一个过滤器都必须指定一个 int 类型的 order 值，默认值为 0，表示该过滤的优先级。order 值越小，优先级越高，执行顺序越靠前。Filter 通过实现 Order 接口或者添加@Order 注解来指定 order 值。Spring Cloud Gateway 提供的 Filter 由 Spring 指定。用户也可以自定义 Filter，由用户指定。当过滤器的 order 值一样时，会按照 defaultFilter > GatewayFilter > GlobalFilter 的顺序执行。

3.5 自定义过滤器

Spring Cloud Gateway 提供了过滤器的扩展功能，开发者可以根据实际业务来定义过滤器，同样自定义过滤器也支持 GatewayFilter 和 GlobalFilter 两种。

3.5.1 自定义 GatewayFilter

自定义 GatewayFilter，需要去实现对应的接口 GatewayFilterFactory，Spring Boot 默认帮我们实现的抽象类是 AbstractGatewayFilterFactory，我们可以直接使用。 我们在前面配置文件中使用过滤器的时候会传参数，我们需要自定义类来接收参数。

package com.cloud.gateway;

import lombok.Data;

@Data
public class CustomConfig {
    private String name;
}

自定义过滤器：

1. 类名统一以 GatewayFilterFactory 结尾，因为默认情况下，过滤器的 name 会采用该定义类的前缀。这里的 name=Custom(yml 配置中使用)
2. apply 方法中，同时包含 Pre 和 Post 过滤，then 方法中是请求执行结束之后处理的
3. CustomConfig 是一个配置类，该类只有一个属性 name，和 yml 的配置对应
4. 该类需要交给 Spring 管理，所以需要加 @Component 注解
5. getOrder 表示该过滤器的优先级，值越大，优先级越低。

package com.cloud.gateway;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
@Slf4j
public class CustomGatewayFilterFactory extends AbstractGatewayFilterFactory<CustomConfig> implements Ordered {
    public CustomGatewayFilterFactory() {
        super(CustomConfig.class);
    }

    /**
     * Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain)
     * ServerWebExchange: HTTP 请求 - 响应交互的契约，提供对 HTTP 请求和响应的访问，服务器端请求属性，请求实例，响应实例等，类似 Context 角色
     * GatewayFilterChain: 过滤器链
     * Mono: Reactor 核心类，数据流发布者，Mono 最多只触发一个事件，所以可以把 Mono 用于在异步任务完成时发出通知.
     * Mono.fromRunnable: 创建一个包含 Runnable 元素的数据流
     */
    @Override
    public GatewayFilter apply(CustomConfig config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                log.info("[Pre] Filter Request, name:" + config.getName());
                return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                    log.info("[Post] Response Filter");
                }));
            }
        };
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }
}

配置：

server:
  port: 10030 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    gateway:
      routes:
        # 网关路由配置
        - id: product-service # 路由 ID，自定义，唯一即可
          uri: lb://product-service # 目标服务地址
          predicates:
            # 路由条件
            - Path=/product/**
          filters:
            - name: Custom
              args:
                name: custom filter

3.5.2 自定义 GlobalFilter

GlobalFilter 的实现比较简单，它不需要额外的配置，只需要实现 GlobalFilter 接口，自动会过滤所有的 Filter。

package com.cloud.gateway;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Slf4j
@Component
public class CustomGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("[Pre] CustomGlobalFilter enter...");
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            log.info("[Post] CustomGlobalFilter return...");
        }));
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }
}