SpringCloud Alibaba实战之Gateway

原创已于 2025-08-16 19:25:29 修改 · 897 阅读

15 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#spring cloud #gateway #java

于 2025-08-16 17:14:52 首次发布

spring 专栏收录该内容

26 篇文章

订阅专栏

Springcloud Alibaba相关组件系列文章如下：

SpringCloud Alibaba实战之Nacos-CSDN博客

SpringCloud Alibaba实战之OpenFeign-CSDN博客

SpringCloud Alibaba实战之Sentinel-CSDN博客

SpringCloud Alibaba实战之Gateway-CSDN博客

SpringCloud Alibaba实战之Seata-CSDN博客

Gateway

官方文档：Spring Cloud Gateway

网关的原理：

Springcloud Gateway支持Reactive Server和Server MVC两种网关，推荐使用前者。

1、Gateway简单使用

需求：客户端发送的/api/order/**请求都转发到service-order服务，客户端发送的/api/product/**请求都转发到service-product服务，以上转发都有负载均衡效果。

1. 在springcloud父工程下创建gateway模块

在gateway的pom.xml文件中引入网关、服务注册与发现、负载均衡等相关的依赖。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>springcloud-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>gateway</artifactId>
    <packaging>jar</packaging>

    <name>gateway</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 网关 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <!-- 服务注册与发现，网关需要从注册中心获取服务地址 -->
        <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>
</project>

2. 在gateway模块中创建application.yml和application-route.yml文件：

server:
  port: 80
spring:
  application:
    name: gateway
  profiles:
    include: route
  cloud:
    nacos:
      # 配置nacos地址，将微服务注册到nacos上
      server-addr: 127.0.0.1:8848

spring:
  cloud:
    gateway:
      routes:
        - id: order-route
          uri: lb://service-order
          predicates:
            - Path=/api/order/**
          filters:
            - RewritePath=/api/?(?<segment>.*), /$\{segment}
        - id: product-route
          uri: lb://service-product
          predicates:
            - Path=/api/product/**
          filters:
            - RewritePath=/api/?(?<segment>.*), /$\{segment}

注意application-route.yml文件中的filters：RewritePath=/api/?(?<segment>.*), /$\{segment}，RewritePath是一个路径重写的过滤器，此处配置的路径重写规则是将前缀/api去掉，这个/api前缀是在predicates断言中配置的Path=/api/order/**。例如通过Gateway给service-order服务发送创建订单的请求http://localhost:80/api/order/create，由于service-order服务创建订单的接口是/order/create，没有前缀/api，结果就会报错404 Not Found。所以此处使用RewritePath过滤器重写路径，或者修改service-order和service-product服务的controller，在每个接口前面都加上/api前缀。

3. 在gateway模块中创建启动类并启动gateway微服务。

package com.springcloud.demo.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

4. 由于需要验证gateway服务调用和负载均衡的功能，所以启动多个service-order和service-product服务。通过postman调用经过gateway网关转发的service-order和service-product服务接口。

2、自定义路由断言

路由断言工厂都继承自AbstractRoutePredicateFactory，可参考QueryRoutePredicateFactory自定义路由断言工厂，如下图所示。在路由断言工厂中定义一个静态内部类Config，在Config中定义可以配置的参数，在路由断言工厂的构造函数中引用内部类Config，并在路由断言工厂中重写shortcutFieldOrder()和apply(Config config)两个方法。

现在有个需求：用户在创建订单时必须先登录，携带用户名和密码才能创建订单。

可以自定义一个用于校验登录的路由断言工厂类LoginRoutePredicateFactory（注意：类名称后缀必须是RoutePredicateFactory），如下所示。

package com.springcloud.demo.gateway.predicate;

import jakarta.validation.constraints.NotEmpty;
import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.cloud.gateway.handler.predicate.GatewayPredicate;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.server.ServerWebExchange;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

@Component
public class LoginRoutePredicateFactory extends AbstractRoutePredicateFactory<LoginRoutePredicateFactory.Config> {
    public LoginRoutePredicateFactory() {
        super(Config.class);
    }

    @Override
    public List<String> shortcutFieldOrder() {
        // 列举自定义路由断言可以使用的参数，需要与静态内部类Config中的属性名一致
        return Arrays.asList("username", "password");
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return new GatewayPredicate() {
            @Override
            public boolean test(ServerWebExchange exchange) {
                ServerHttpRequest request = exchange.getRequest();
                String value = request.getQueryParams().getFirst(config.username);
                return value != null && value.equals(config.password);
            }
        };
    }

    @Validated
    public static class Config {
        @NotEmpty
        private String username;
        @NotEmpty
        private String password;

        public String getUsername() {
            return username;
        }

        public void setUsername(String username) {
            this.username = username;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }
    }

}

在Gateway服务的application-route.yml文件中使用自定义的LoginRoutePredicateFactory，只需要填写类名称的前缀Login即可（name: Login），args填写静态内部类Config中定义的属性。此处username: zhangsan，password: 123456表示请求参数的key和value必须是zhangsan和123456，否则找不到路由路径，不会路由到service-order服务。

spring:
  cloud:
    gateway:
      routes:
        - id: order-route
          uri: lb://service-order
          # predicates属性的类型是List<PredicateDefinition>
          predicates:  # PredicateDefinition中有name和args两个属性
#            - Path=/api/order/**  # 简写
#            - Login=zhangsan,123456  # 简写
            - name: Path  # Path表示使用PathRoutePredicateFactory断言工厂
              args:  # patterns是PathRoutePredicateFactory.Config的属性
                patterns: /api/order/**
            - name: Login  # Login表示使用自定义的LoginRoutePredicateFactory
              args:  # LoginRoutePredicateFactory中有username和password两个属性
                username: zhangsan
                password: 123456
          filters:
            - RewritePath=/api/?(?<segment>.*), /$\{segment}
        - id: product-route
          uri: lb://service-product
          predicates:
            - Path=/api/product/**
          filters:
            - RewritePath=/api/?(?<segment>.*), /$\{segment}
        - id: seckill-order-route
          uri: lb://service-order
          predicates:
            - name: Path
              args:
                patterns: /api/order/**
            - name: Login
              args:
                username: zhangsan
                password: 123456
          filters:
            - RewritePath=/api/?(?<segment>.*), /$\{segment}

例如请求参数是zhangsan=12345，与application-route.yml文件中配置的username和password不匹配，得到的响应结果是404 Not Found。

将请求参数改成zhangsan=123456可以得到正确的响应结果。

3、自定义网关过滤器

可参考AbstractNameValueGatewayFilterFactory自定义一个网关过滤器工厂，继承AbstractGatewayFilterFactory，如下图所示。在网关过滤器工厂中定义一个静态内部类Config，在Config中定义可以配置的参数，在网关过滤器工厂的构造函数中引用内部类Config，并在网关过滤器工厂中重写shortcutFieldOrder()和apply(Config config)两个方法。

现在有个需求：发起创建订单请求时给请求头或响应头中加上token。此处只是模拟如何自定义网关过滤器，其实已有的AddRequestHeaderGatewayFilterFactory可以实现这个需求。

自定义一个网关过滤器工厂类AddTokenGatewayFilterFactory（类名称后缀必须是GatewayFilterFactory）继承AbstractGatewayFilterFactory，如下所示。

package com.springcloud.demo.gateway.filter;

import jakarta.validation.constraints.NotEmpty;
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.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.Arrays;
import java.util.List;
import java.util.UUID;

@Component
public class AddTokenGatewayFilterFactory extends AbstractGatewayFilterFactory<AddTokenGatewayFilterFactory.Config> {
    public AddTokenGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                String value = UUID.randomUUID().toString();
                if ("request".equals(config.getValue())) {
                    ServerHttpRequest request = exchange.getRequest();
                    request = request.mutate().header(config.getName(), value).build();
                    return chain.filter(exchange.mutate().request(request).build());
                } else if ("response".equals(config.getValue())) {
                    return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                        ServerHttpResponse response = exchange.getResponse();
                        HttpHeaders headers = response.getHeaders();
                        headers.add(config.getName(), value);
                    }));
                } else {
                    return chain.filter(exchange);
                }
            }
        };
    }

    @Override
    public List<String> shortcutFieldOrder() {
        // 列举自定义网关过滤器可以使用的参数，需要与静态内部类Config中的属性名一致
        return Arrays.asList(GatewayFilter.NAME_KEY, GatewayFilter.VALUE_KEY);
    }


    @Validated
    public static class Config {
        @NotEmpty
        protected String name;

        @NotEmpty
        protected String value;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }
}

在Gateway服务的application-route.yml文件中使用自定义的AddTokenGatewayFilterFactory，只需要填写类名称的前缀AddToken即可（name: AddToken），args填写静态内部类Config中定义的属性，或者使用简写格式：- AddToken=X-Token,request。

spring:
  cloud:
    gateway:
      routes:
        - id: order-route
          uri: lb://service-order
          # predicates属性的类型是List<PredicateDefinition>
          predicates:  # PredicateDefinition中有name和args两个属性
#            - Path=/api/order/**  # 简写
#            - Login=zhangsan,123456  # 简写
            - name: Path  # Path表示使用PathRoutePredicateFactory断言工厂
              args:  # patterns是PathRoutePredicateFactory.Config的属性
                patterns: /api/order/**
#            - name: Login  # Login表示使用自定义的LoginRoutePredicateFactory
#              args:  # LoginRoutePredicateFactory中有username和password两个属性
#                username: zhangsan
#                password: 123456
          filters:
            - RewritePath=/api/?(?<segment>.*), /$\{segment}
            - AddToken=X-Token,request  # 给请求头添加 X-Token
            - AddToken=X-Token,response  # 给响应头添加 X-Token
        - id: product-route
          uri: lb://service-product
          predicates:
            - Path=/api/product/**
          filters:
            - RewritePath=/api/?(?<segment>.*), /$\{segment}
        - id: seckill-order-route
          uri: lb://service-order
          predicates:
            - name: Path
              args:
                patterns: /api/order/**
            - name: Login
              args:
                username: zhangsan
                password: 123456
          filters:
            - RewritePath=/api/?(?<segment>.*), /$\{segment}

通过postman发起请求创建订单，观察请求头和响应头中是否都有X-Token字段。

4、支持跨域访问

可以给需要支持跨域的controller类加上@CrossOrigin注解，或者通过CorsFilter过滤器给某个微服务配置支持跨域访问。如果有很多微服务，且每个微服务都需要支持跨域访问，通过CorsFilter过滤器给每个微服务都配置跨域访问比较繁琐，Springcloud Gateway支持在网关层面进行跨域设置，再通过网关访问微服务就是支持跨域的了。

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]':  # 允许所有的请求跨域
            allowed-origin-patterns: '*'  # 允许所有的请求
            allowed-headers: '*'  # 允许所有的请求头
            allowed-methods: '*'  # 允许所有的请求方式