浅谈springcloud入门（六）-服务网关Gateway

愚者的utopia

已于 2023-07-24 09:09:53 修改

阅读量377

点赞数

CC 4.0 BY-SA版权

于 2023-07-23 23:16:33 首次发布

本文链接：https://blog.csdn.net/HCutopia/article/details/131885892

SpringCloudGateway作为SpringCloud的一个子项目，旨在提供一种简单的方式来构建API网关。它基于WebFlux的响应式编程模型，相比Zuul有更好的性能。文章介绍了Gateway的出现背景，与Zuul的区别，以及其作为微服务统一入口的作用。核心组件包括过滤器和路由，其中过滤器分为GatewayFilter和GlobalFilter，路由则涉及断言Predicates来匹配HTTP请求。此外，文章还展示了如何配置和使用Gateway，包括断言工厂的多种应用场景，以及自定义过滤器的实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、GateWay的出现

在SpringCloud中网关的实现主要包括两种：gateway和zuul

Zuul是基于Servlet的实现，属于阻塞式编程。而SpringCloudGateway则是基于Spring5中提供的WebFlux，属于响应式编程的实现，具备更好的性能。

Zuul是Netflix的开源项目，Spring Cloud将其收纳成为自己的一个子组件。zuul用的是多线程阻塞模型，它本质上就是一个同步 Servlet，这样的模型比较简单，他都问题是多线程之间上下文切换是有开销的，线程越多开销就越大。线程池数量固定意味着能力接受的请求数固定，当后台请求变慢，面对大量的请求，线程池中的线程容易被耗尽，后续的请求会被拒绝。

在Zuul 2.0中它采用了 Netty 实现异步非阻塞编程模型，异步非阻塞模式对线程的消耗比较少，对线程上线文切换的消耗也比较小，并且可以接受更多的请求。它的问题就是线程模型比较复杂，要求深究底层原理需要花一些功夫。

Spring Cloud Gateway是Spring Cloud自己的产物，基于Spring 5 和Spring Boot 2.0 开发，Spring Cloud Gateway的出现是为了代替zuul,在Spring Cloud 高版本中没有对zuul 2.0进行集成，SpringCloud Gateway使用了高性能的Reactor模式通信框架Netty。

Spring Cloud Gateway 的目标，不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如：安全，监控/指标，和限流。

所以说其实Gateway和zuul 2.0差别不是特别大，都是采用Netty高性能通信框架，性能都挺不错。

二、GateWay的作用

网关(Gateway)又称网间连接器、协议转换器。默认网关在网络层以上实现网络互连，是最复杂的网络互连设备，仅用于两个高层协议不同的网络互连。网关的结构也和路由器类似，不同的是互连层。网关既可以用于广域网互连，也可以用于局域网互连。

网关是一种充当转换重任的计算机系统或设备。使用在不同的通信协议、数据格式或语言，甚至体系结构完全不同的两种系统之间，网关是一个翻译器。与网桥只是简单地传达信息不同，网关对收到的信息要重新打包，以适应目的系统的需求。同层–应用层。

网关（Gateway）是将两个使用不同协议的网络段连接在一起的设备。
网关的作用就是对两个网络段中的使用不同传输协议的数据进行互相的翻译转换。

Gateway网关是我们服务的守门神，所有微服务的统一入口。

三、GateWay的核心组成

Spring Cloud Gataway有几个核心组成：

Filter（过滤器）：

Spring Cloud Gateway的Filter和Zuul的过滤器类似，可以在请求发出前后进行一些业务上的处理 ,这里分为两种类型的Filter，分别是Gateway Filter网关filter和Global Filter全局Filter, 他们的区别在后续会讲到。

Route（路由）：

网关配置的基本组成模块，和Zuul的路由配置模块类似。一个Route模块由一个 ID，一个目标 URI，一组断言和一组过滤器定义。如果断言为真，则路由匹配，目标URI会被访问。说白了就是把url请求路由到对应的资源(服务)，或者说是一个请求过来Gateway应该怎么把这个请求转发给下游的微服务，转发给谁。

Predicate（断言）：

这是一个 Java 8 的 Predicate，可以使用它来匹配来自 HTTP 请求的任何内容，例如 headers 或参数。断言的输入类型是一个 ServerWebExchange。简单理解就是处理HTTP请求的匹配规则，在什么样的请情况下才能命中资源继续访问。

四、GateWay的工作原理

下图描述了网关如何工作,当网关收到请求的时候,会根据定义好的路由映射进行匹配,查看当前的请求地址能够匹配那个mapping, 然后将相关的请求发送到下面的web handler, handler中有一些过滤器组成了责任链对请求进行pre处理,然后最终送达到响应的服务器,在目标返回结果之后再通过过滤器进行post处理,最终返回给调用这个,过滤器的虚线用于区分是前置处理还是后置处理,其实整体过程类似于SpringMVC。

五、GateWay的使用

1.创建工程导入依赖

<dependencies>
        <!--服务注册与发现-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
    </dependencies>

2.启动类配置

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

3.yml配置

该配置中将断言，跨域，超时一并配置，详情请看代码说明。

server:
  port: 10060 # user服务端口号

eureka:
  client:
    serviceUrl: # Eureka客户端配置，指向注册中心地址
      defaultZone: http://localhost:10010/eureka/
  instance: # 打开IP注册
    instance-id: ${spring.application.name}:${server.port} # 设置实例名称
    prefer-ip-address: true # 开启IP注册

# 指定服务名称，此服务下的集群所有服务都叫此服务名
spring:
  application:
    name: gateway-server
  cloud:
    gateway:
      httpclient:
        connect-timeout: 1000
        response-timeout: 5s
      discovery:
        locator:
          enabled: false #开放服务名访问方式
          lower-case-service-id: true #服务名小写
      routes:
        - id: order-server #指定服务名
          uri: lb://order-server #去注册中心找这个服务名
          predicates: #断言，匹配访问的路径 如果路径中有/order/ 那么请求就会给lb://order-server
            - Path=/server/order/**    #服务访问路径
          filters:
            - StripPrefix=2    #请求转发的时候会去掉 /order访问路径
    globalcors: #跨域配置
      cors-configurations:
        '[/**]':
          allowedOrigins: "*" #允许的站点
          allowedMethods:
            - GET
            - POST
            - DELETE
            - PUT
            - HEAD
            - CONNECT
            - TRACE
            - OPTIONS
          allowHeaders:
            - Content-Type

这里除了要注册到Eureak以外，还需要配置Gataway的路由

spring.cloud.gateway.discovery.locator.enabled=false: 不开放服务名访问方式
spring.cloud.gateway.discovery.locator.lower-case-service-id: true 忽略服务名大小写，大写小写都可以匹配
spring.cloud.gateway.routes.id : 指定了路由的服务名，可以自己定义
spring.cloud.gateway.routes.uri=lb://user-server : 去注册中心找服务，采用负载均衡的方式请求。其实就是找要调用的服务。
spring.cloud.gateway.routes.predicates: 断言，这里使用的Path=/user/**，即匹配访问的路径如果匹配/user/就可以将请求路由(分发)到user-server这个服务上。
spring.cloud.gateway.routes.filters :这里使用StripPrefix=1主要是处理前缀 /user ,访问目标服务的时候会去掉前缀访问。这个需要根据url情况来定义。

4.测试

启动注册中心，启动用户服务，启动网关访问：http://localhost:10060/server/order/order/1,请求将会打到用户服务上，并返回用户数据。

六、Predicate断言工厂

1.什么是断言工厂

什么是断言工程，在Spring Cloud Gateway官方文档有如下解释：

Spring Cloud Gateway将路由作为Spring WebFlux HandlerMapping基础架构的一部分进行匹配。Spring Cloud Gateway包括许多内置的路由断言工厂。所有这些断言都与HTTP请求的不同属性匹配。您可以将多个路由断言工厂与逻辑and语句结合使用。

这里不难理解，其实断言工厂就是用来判断http请求的匹配方式。比如我们再上面案例中配置的：“Path=/user/**” ，就是使用的是 “Path Route Predicate Factory” 路径匹配工厂，意思是http请求的资源地址必须是 /user 才会被匹配到对应的路由，然后继续执行对应的服务获取资源。

在Spring Cloud Gateway中，针对不同的场景内置的路由断言工厂，比如

Query Route Predicate Factory：根据查询参数来做路由匹配
RemoteAddr Route Predicate Factory：根据ip来做路由匹配
Header Route Predicate Factory：根据请求头中的参数来路由匹配
Host Route Predicate Factory：根据主机名来进行路由匹配
Method Route Predicate Factory ：根据方法来路由匹配
Cookie Route Predicate Factory：根据cookie中的属性值来匹配
Before Route Predicate Factory：指定时间之间才能匹配
After Route Predicate Factory：指定时间之前才能匹配
Weight Route Predicate Factory：根据权重把流量分发到不同的主机

2.根据查询参数断言- Query Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: https://example.org
        predicates:
        - Query=green

上面配置表达的试试是如果请求参数中包含了 green，那么就会断言成功，从而执行uri后面的地址。

3.根据path断言-Path Route Predicate Factory(重要)

spring:
  cloud:
    gateway:
      routes:
      - id: path_route
        uri: https://example.org
        predicates:
        - Path=/red/{segment},/blue/{segment}

请求路径如: /red/1或/red/blue或/blue/green 就可以断言成功

4.根据权重比例断言-Weight Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: weight_high
        uri: https://weighthigh.org
        predicates:
        - Weight=group1, 8
      - id: weight_low
        uri: https://weightlow.org
        predicates:
        - Weight=group1, 2

大约80％的请求转发到weighthigh.org，将大约20％的流量转发到weightlow.org。

5.根据远程ip断言 - RemoteAddr Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: remoteaddr_route
        uri: https://example.org
        predicates:
        - RemoteAddr=192.168.1.1/24

如果请求的远程地址为 192.168.1.1到192.168.1.24之间，则此路由匹配

6.指定时间之后断言-After Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: after_route
        uri: https://example.org
        predicates:
        - After=2017-01-20T17:42:47.789-07:00[America/Denver]

在atfer配置的时间之后才能访问

7.在指定时间之前断言-Before Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: before_route
        uri: https://example.org
        predicates:
        - Before=2017-01-20T17:42:47.789-07:00[America/Denver]

在before配置的时间之前才能访问

8.在指定时间段之间断言-Between Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: between_route
        uri: https://example.org
        predicates:
        - Between=2017-01-20T17:42:47.789-07:00[America/Denver], 2017-01-21T17:42:47.789-07:00[America/Denver]

请求时间在两个时间之内者允许访问

9.根据cookie断言-Cookie Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: cookie_route
        uri: https://example.org
        predicates:
        - Cookie=chocolate, ch.p

cookies中必须有Cookie配置的属性才能匹配

10.根据请求头断言-Header Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: header_route
        uri: https://example.org
        predicates:
        - Header=X-Request-Id, \d+

请求头必须出现 X-Request-Id 才可以访问

11.根据主机断言-Host Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: host_route
        uri: https://example.org
        predicates:
        - Host=**.somehost.org,**.anotherhost.org

如果请求的主机头具有值.somehost.org,或者.anotherhost.org这匹配路由

12.根据请求方式断言-Method Route Predicate Factory

spring:
  cloud:
    gateway:
      routes:
      - id: method_route
        uri: https://example.org
        predicates:
        - Method=GET,POST

只允许 GET和POST请求。

七、Gateway 的 Filter 过滤器

Gateway的Filter的zuul的Filter有相似之处，与zuul不同的是，Gateway的filter从生命周期上可以为“pre”和“post”类型。根据作用范围可分为针对于单个路由的gateway filter，和针对于所有路由的Global Filer。

gateway中过滤器主要分为网关(路由)过滤器和全局过滤器两个,网关(路由)过滤器主要是个某个服务指定的过滤器,全局过滤器主要是给所有的路由设置的。

1.自定义网关过滤器

网关过滤器用于拦截并通过责任链处理web请求,修改http的请求传入数据和http响应的传出数据,可以实现AOP处理我们的与应用无关的操作,比如安全控制等,主要包含路径过滤器,header过滤器,参数过滤器,body过滤器,状态过滤器,会话过滤器,重定向过滤器,重试过滤器,限流RateLimiter过滤器,熔断器过滤器。

在Spring Cloud Gateway自定义过滤器，过滤器需要实现GatewayFilter和Ordered这两个接口。我们下面来演示自定义filter计算请求的耗时。

public class RequestTimeFilter implements GatewayFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //开始时间
        long beginTime = new Date().getTime();
        //执行完成之后
        return chain.filter(exchange).then(
                Mono.fromRunnable(() -> {
                    //结束时间
                    long endTime = new Date().getTime();
                    //时间差
                    long time = endTime - beginTime;
                    System.out.println("当前请求：" + exchange.getRequest().getURI().getPath() + "耗时：" + time);
                    
                })
        );
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

getOrder返回filter的优先级，越大的值优先级越低，在filterI方法中计算了请求的开始时间和结束时间。

最后我们还需要把该Filter配置在对应的路由上，配置如下：

@Configuration
public class FilterConfig {

    //配置Filter作用于那个访问规则上
    @Bean
    public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) {

        return builder.routes().route(r -> r.path("/server/user/**")
                //去掉2个前缀
                        .filters(f -> f.stripPrefix(2)
                        .filter(new RequestTimeFilter())
                        .addResponseHeader("X-Response-test", "test"))
                        .uri("lb://user-server")
                        .order(0)
                        .id("test-RequestTimeFilter")
                ).build();
    }
}

2.全局过滤器

全局过滤器和网关过滤器一样,但是全局过滤器不需要通过配置文件或者配置类进行设置,它作用在所有路由上面,经过GatewayFilterAdapter包装为GatewayFilterChain责任链,它主要将我们的请求转换为真实的请求地址并进行访问,不需要经过配置,会自动在系统启动的时候进行加载。

这里我们模拟了一个登陆检查的Filter。

@Component
public class TimeGlobleFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //拿到请求对象
        ServerHttpRequest request = exchange.getRequest();
        //拿到token
        List<String> token = request.getHeaders().get("token");
        if(token == null || token.isEmpty()){
            //响应对象
            ServerHttpResponse response = exchange.getResponse();


            DataBuffer buffer = null;
            try {
                byte[] bytes = "登录".getBytes("utf-8");
                buffer = response.bufferFactory().wrap(bytes);

                //设置完成相应，不会继续执行后面的filter
                //response.setComplete();
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                response.getHeaders().add("Content-Type","application/json;charset=UTF-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }

            //把结果写给客户端
            return response.writeWith(Mono.just(buffer));
        }
        //放行
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

总结：

网关搭建步骤：

创建项目，引入nacos服务发现和gateway依赖

配置application.yml，包括服务基本信息、nacos地址、路由

路由配置包括：

路由id：路由的唯一标示

路由目标（uri）：路由的目标地址，http代表固定地址，lb代表根据服务名负载均衡

路由断言（predicates）：判断路由的规则，

路由过滤器（filters）：对请求或响应做处理