四整合微服务网关SpringCloudGateway

‘

一、微服务网关

介于客户端和服务器之间的中间层，所有外部请求都会先经过微服务网关

二、为什么需要微服务网关

1、传统无网关访问的访问模式（客户端直接访问服务接口）的弊端

复杂性 —- 客户端完成一个业务可能需要调用多个微服务接口，然而分布式微服务可能对应多个不同的ip与端口

访问方式不友好 – 某些服务可能使用了并不友好的协议，如使用RPC和AMQP等只适合内部使用的协议

认证复杂 —– 每个微服务需要独立认证

跨域处理困难

重构困难——-如果后期需要服务拆分或者服务合并，这种模式的实施将会极为困难

2、基于网关的访问模式（类似于面向对象中的门面模式）

使用网关可以针对性的解决传统访问模式的弊端：

减少客户端对微服务的交互次数，降低客户端与服务端的耦合度
易于认证，只需要在网关统一认证
便于监控，可以在网关收集交互数据进行监控
便于重构，因为客户端对微服务的访问路径及端口都是统一而少量的

思考：为什么不用nginx直接作为网关呢？

nginx作为负载均衡的利刃确实可以带来很多的集约化便利，但是它的主要着力点是对ip及端口的统一转发及分配，而不是api。本文介绍的微服务网关主要着力于微服务api的负载均衡和代理，如果使用nginx作为api网关，nginx需要为每一个api做代理配置，这个数量级是很高的，维护起来十分困难，微服务网关必须可以做到api前缀适配和路由转发功能，所以nginx并不适合作为api网关。

除此之外，网关还提供了负载均衡，限流降级等服务，有利于优化系统性能，分散压力。

三、微服务网关Spring Cloud Gateway

目前，市面上比较常用的微服务网关解决方案主要是Nginx+ Lua、Kong、Spring Cloud Zuul，Spring Cloud Gateway等，其中Spring Cloud Gateway是Spring Cloud后期研发用于取待Zuul的一个网关组件，具有路由转发、权限校验、限流控制等功能。

1、Spring Cloud Gateway的组成

Route(路由) ———— 网关的基本组件对象，指向一个api/服务，定义了一个id，一个目标uri，一组谓词和一组过滤器，如果谓词匹配为真，则匹配路由
Predicate(谓词) ——- 作为匹配路由的先行条件，是一个Java 8 Function Predicate,允许开发人员匹配HTTP请求的任何信息
Filter(过滤器) ———- 特定工程构建的Spring Framework GatewayFilter 的实例，用于在发送下游请求之前或之后处理请求与响应

2、Gateway的谓词（Predicate）

谓词工厂	谓词配置写法	谓词意义
After Route Predicate Factory	predicates:- After=2017-01-20T17:42:47.789-07:00[America/Denver]	允许匹配指定日期时间之后发生的请求
Before Route Predicate Factory	predicates:- Before=2019-01-20T17:42:47.789-07:00[America/Denver]	允许匹配指定日期时间之前发生的请求
Between Route Predicate Factory	predicates:- Between=2017-01-20T17:42:47.789-07:00[America/Denver], 2019-01-21T17:42:47.789-07:00[America/Denver]	允许匹配datetime1之后和datetime2之前发生的请求。datetime1必须在datetime2之前
Cookie Route Predicate Factory	predicates:- Cookie=chocolate, ch.p	允许匹配具有指定名称的cookie的请求
Header Route Predicate Factory	predicates:- Header=X-Request-Id, \d+	接收2个参数，一个header中的名称和一个正则表达式。允许匹配含有指定名称的header且其值符合正则表达式的请求
Host Route Predicate Factory	predicates:- Host=**.somehost.org	接收一个参数：主机名模式。该模式是一种 Ant 样式模式作为分隔符。允许匹配与该模式匹配的主机头部
Method Route Predicate Factory	predicates:- Method=GET	允许匹配指定请求方式的请求
Path Route Predicate Factory	predicates:- Path=/foo/{segment}	允许匹配指定路径前缀的请求
Query Route Predicate Factory	predicates:- Query=baz	接收2个参数: 一个必须的参数和一个可选的表达式。允许匹配请求参数中包含了指定参数的请求
RemoteAddr Route Predicate Factory	predicates: – RemoteAddr=192.168.1.1/24	允许匹配指定ip规则的请求

3、Gateway的过滤器（Filter）

gateway过滤器的生命周期与其作用范围有关，其生命周期只有两个：“pre” 和 “post”。“pre”和 “post” 分别会在请求被执行前调用和被执行后调用

Spring Cloud Gateway的源码包Filter中包含三个接口：GatewayFilterChain，GatewayFilter，GlobalFilter GatewayFilterChain-—-网关过滤链表接口，用于过滤器的链式调用

GatewayFilter—– 网关路由过滤器，有且只有一个方法filter，执行当前过滤器，并在此方法中决定过滤器链表是否继续往下执行。需要通过spring.cloud.route.filter在路由上配置或通过spring.cloud.default-filter将该过滤器作为全局过滤器

GlobalFilter—-请求业务以及路由的URI转换为真实业务服务的请求地址的核心过滤器，不需要配置，模式系统初始化时加载，并作用在每个路由上。

四、Spring Cloud Gateway的工作原理

①客户端向网关发送请求 ②网关映射处理匹配谓词+匹配路由通过后，将请求转交到网关Web处理程序 ③网关Web处理程序请求通过一系列过滤器处理后发送到指定代理服务 ④指定代理服务处理完业务响应同样经过一系列过滤器处理后返回给客户端

五、实践整合Spring Cloud Gateway

1、第一步：在父工程下创建网关服务工程：springcloud-gateway

并引入依赖spring-cloud-starter-gateway

<!--微服务网关组件依赖-->
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

<!--健康检查监控-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

注意：spring-cloud-starter-gateway依赖使用的netty+webflux实现,已经是个网络工程，不要加入web依赖，否则会报错

完整POM文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <parent>
        <artifactId>com.springcloud</artifactId>
        <groupId>com.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.gateway</groupId>
    <artifactId>spring-cloud-gateway</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--微服务网关组件依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>

        <!--健康检查监控-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--配置中心客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-client</artifactId>
        </dependency>
        <!--注册中心客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    <!-- 添加spring-boot的maven插件，不能少，打jar包时得用 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2、第二步：在resource目录下创建bootstrap.yml文件，同时进行路由代理配置

server:
  port: 9999
spring:
  profiles:
    active: dev
  application:
    name: springcloud-gateway
  cloud:
    # 配置中心
    config:
      fail-fast: true
      name: ${spring.application.name}
      profile: ${spring.profiles.active}
      uri: http://localhost:8080

    #网关配置中心
    gateway:
      discovery:
        locator:  #路由访问方式：http://Gateway_HOST:Gateway_PORT/大写的serviceId/**，其中微服务应用名默认大写访问。
          enabled: true #是否与服务发现组件进行结合，通过 serviceId(必须设置成大写) 转发到具体的服务实例。默认为false，设为true便开启通过服务中心的自动根据 serviceId 创建路由的功能。
          lower-case-service-id: true #允许通过模块名小写代理
      routes:
        - id: springcloud-client
          uri: lb://springcloud-client #网关路由到springcloud-client模块，lb指向内部注册模块
          predicates: #转发谓词，用于设置匹配路由的规则
            - Path=/client/** #通过请求路径匹配
  #            - Method=GET #通过请求方式匹配
  #            - RemoteAddr=127.0.0.1/25 #通过请求id匹配，只有在某个 ip 区间号段的请求才会匹配路由，其中/后的是子网掩码
  #            - After=2018-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间进行匹配，在指定时间之后才会匹配路由
  #            - Before=2018-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间进行匹配，在指定时间之前才会匹配路由
  #            - Between=2018-01-20T06:06:06+08:00[Asia/Shanghai], 2019-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间段进行匹配，处于指定时间段才会匹配路由
  main:
    allow-bean-definition-overriding: true #是否允许同Bean覆盖

# 注册中心配置
eureka:
  instance:
    prefer-ip-address: true #优先使用IP地址注册
  client:
    service-url:
      defaultZone: http://127.0.0.1:8761/eureka/

3、第三步：编写启动类，Gateway并不需要特殊注解，使用十分便捷

package com.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * @类名 SpringCloudGatewayApplication
 * @描述 TODO
 * @版本 1.0
 * @创建人 XuKang
 * @创建时间 2021/6/17 16:04
 **/
@SpringBootApplication
@EnableEurekaClient
public class SpringCloudGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudGatewayApplication.class, args);
    }
}

4、第四步：客户端依旧使用springcloud-client工程，依序启动spring-cloud-eureka-service，spring-cloud-config-service，spring-cloud-config-client，spring-cloud-gateway工程

通过7900端口访问Client模块，确保服务正常访问

通过Gateway的9999端口访问Client接口，结果如下

可以看到Gateway将client前缀的路径路由到了client模块

5、第五步：添加其他谓词测试路由匹配，只允许通过GET请求

在bootstrap.yml文件中放开配置：- Method=GET #通过请求方式匹配

server:
  port: 9999
spring:
  profiles:
    active: dev
  application:
    name: springcloud-gateway
  cloud:
    # 配置中心
    config:
      fail-fast: true
      name: ${spring.application.name}
      profile: ${spring.profiles.active}
      uri: http://localhost:8080

    #网关配置中心
    gateway:
      discovery:
        locator:  #路由访问方式：http://Gateway_HOST:Gateway_PORT/大写的serviceId/**，其中微服务应用名默认大写访问。
          enabled: true #是否与服务发现组件进行结合，通过 serviceId(必须设置成大写) 转发到具体的服务实例。默认为false，设为true便开启通过服务中心的自动根据 serviceId 创建路由的功能。
          lower-case-service-id: true #允许通过模块名小写代理
      routes:
        - id: springcloud-client
          uri: lb://springcloud-client #网关路由到springcloud-client模块，lb指向内部注册模块
          predicates: #转发谓词，用于设置匹配路由的规则
            - Path=/client/** #通过请求路径匹配
            - Method=GET #通过请求方式匹配
  #            - RemoteAddr=127.0.0.1/25 #通过请求id匹配，只有在某个 ip 区间号段的请求才会匹配路由，其中/后的是子网掩码
  #            - After=2018-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间进行匹配，在指定时间之后才会匹配路由
  #            - Before=2018-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间进行匹配，在指定时间之前才会匹配路由
  #            - Between=2018-01-20T06:06:06+08:00[Asia/Shanghai], 2019-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间段进行匹配，处于指定时间段才会匹配路由
  main:
    allow-bean-definition-overriding: true #是否允许同Bean覆盖

# 注册中心配置
eureka:
  instance:
    prefer-ip-address: true #优先使用IP地址注册
  client:
    service-url:
      defaultZone: http://127.0.0.1:8761/eureka/

重启服务后，使用postman的post方式访问client模块的postName接口

	@PostMapping("/postName")
    public String postName(@RequestBody Map<String,String> param){
        return param.get("name");
    }

访问成功

加上这个，不然会报错通过Gateway的9999端口访问client的postName接口，访问失败，报404

6、第六步：编写全局过滤器 GlobalTokenFilter，实现GlobalFilter接口，模拟进行登陆认证。注意要加上@Component注解

package com.gateway.config;

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

/**
 * @类名 GlobalTokenFilter
 * @描述 配置全局过滤器
 * @版本 1.0
 * @创建人 XuKang
 * @创建时间 2021/6/18 10:51
 **/
@Slf4j
@Component //将GlobalTokenFilter注册成bean方可生效
public class GlobalTokenFilter implements GlobalFilter, Ordered {

    /**
     * 过滤器执行体
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        /**
         * 获取token
         */
        String token = exchange.getRequest().getQueryParams().getFirst("token");
        if (token == null || token.isEmpty()) {
            log.error("您尚未登陆，请登陆后重试");
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().writeWith(Flux.just(exchange.getResponse().bufferFactory().wrap("您尚未登陆，请登陆后重试".getBytes())));
        }

        /**
         * 继续执行下一过滤器/调用接口
         */
        return chain.filter(exchange);
    }

    /**
     * 设置当前过滤器的优先级，值越大，优先级越低
     */
    @Override
    public int getOrder() {
        return -100;
    }
}

通过网关9999端口访问Client的getName接口，被拦截由于过滤器中是通过从请求参数中获取名为“token”的参数作为判断是否登陆的依据，所以此时添加“token”请求参数后再次访问，访问通过：

8、第八步：编写自定义网关路由过滤器-RequestTimeFilter，实现GatewayFilter接口，用于记录路由请求时间

package com.gateway.config;
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.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
 * @类名 RequestTimeFilter
 * @描述 编写自定义网关路由过滤器
 * @版本 1.0
 * @创建人 XuKang
 * @创建时间 2021/6/18 10:57
 * @修改人 XuKang
 * @修改时间 2021/6/18 10:57
 **/
@Slf4j
@Component
public class RequestTimeFilter implements GatewayFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        exchange.getAttributes().put("startTime", System.currentTimeMillis());
        log.info("===================pre阶段====================");
        return chain.filter(exchange).then(
                Mono.fromRunnable(() -> {
                    Long startTime = exchange.getAttribute("startTime");
                    if (startTime != null) {
                        log.info("=========post阶段==============，执行路径：{}，所耗时间：{}",exchange.getRequest().getURI().getRawPath(),(System.currentTimeMillis() - startTime) + "ms");
                    }
                }));
    }
    /**
     * 设置当前过滤器的优先级，值越大，优先级越低
     * @return
     */
    @Override
    public int getOrder() {
        return 100;
    }
}

注：这种写法无法实现在配置文件中进行过滤器配置，需要手动关联路由，如下创建配置类

package com.gateway.config;

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @类名 GatewayConfig
 * @描述 网关配置
 * @版本 1.0
 * @创建人 XuKang
 * @创建时间 2021/6/18 10:58
 **/
@Configuration
public class GatewayConfig {
    /**
     * 添加路由并给路由添加过滤器
     * @param
     * @return
     */
    @Bean
    public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route(r -> r.path("/client/**")
                        .filters(f -> f.filter(new RequestTimeFilter())
                                .addResponseHeader("X-Response-Default-Foo", "Default-Bar"))
                        .uri("lb://springcloud-client")
                        .order(0)
                        .id("springcloud-client")
                )
                .build();
    }
}

访问日志如下：

9、第九步：编写过滤器工厂-GatewayFilterFactory，实现自定义过滤器配置

很多时候我们还是希望自定义的网关路由过滤器可以通过配置文件的形式添加到路由上，这时候需要通过过滤器工厂来实现

package com.gateway.config;
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.GlobalFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

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

/**
 * @类名 RequestTimeGatewayFilterFactory
 * @描述 自定义网关路由过滤器工厂
 * @版本 1.0
 * @创建人 XuKang
 * @创建时间 2021/6/18 11:02
 * @修改人 XuKang
 * @修改时间 2021/6/18 11:02
 **/
@Slf4j
@Component //将过滤器工厂注册为bean
public class RequestTimeGatewayFilterFactory extends AbstractGatewayFilterFactory<RequestTimeGatewayFilterFactory.Config> {
    public RequestTimeGatewayFilterFactory() {
        super(Config.class);
    }
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("enabled");
    }
    /**
     * 过滤器执行体
     * @param config
     * @return
     */
    @Override
    public GatewayFilter apply(RequestTimeGatewayFilterFactory.Config config) {
        return (exchange, chain)->{
            if(!config.isEnabled()){ //如果没有启用过滤器,则自动跳过
                return chain.filter(exchange);
            }
            exchange.getAttributes().put("startTime", System.currentTimeMillis());
            log.info("===================pre阶段====================");
            return chain.filter(exchange).then(
                    Mono.fromRunnable(() -> {
                        Long startTime = exchange.getAttribute("startTime");
                        if (startTime != null) {
                            log.info("=========post阶段==============，执行路径：{}，所耗时间：{}",exchange.getRequest().getURI().getRawPath(),(System.currentTimeMillis() - startTime) + "ms");
                        }
                    }));
        };
    }
    /**
     * 过滤器工厂在配置文件中的配置属性
     */
    public static class Config {
        // 控制是否开启认证
        private boolean enabled;
        public Config() {}

        public boolean isEnabled() {
            return enabled;
        }
        public void setEnabled(boolean enabled) {
            this.enabled = enabled;
        }
    }
}

在配置文件中进行路由过滤器配置：filters

    #网关配置中心
    gateway:
      discovery:
        locator:  #路由访问方式：http://Gateway_HOST:Gateway_PORT/大写的serviceId/**，其中微服务应用名默认大写访问。
          enabled: true #是否与服务发现组件进行结合，通过 serviceId(必须设置成大写) 转发到具体的服务实例。默认为false，设为true便开启通过服务中心的自动根据 serviceId 创建路由的功能。
          lower-case-service-id: true #允许通过模块名小写代理
      routes:
        - id: springcloud-client
          uri: lb://springcloud-client #网关路由到springcloud-client模块，lb指向内部注册模块
          predicates: #转发谓词，用于设置匹配路由的规则
            - Path=/client/** #通过请求路径匹配
            - Method=GET #通过请求方式匹配
  #            - RemoteAddr=127.0.0.1/25 #通过请求id匹配，只有在某个 ip 区间号段的请求才会匹配路由，其中/后的是子网掩码
  #            - After=2018-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间进行匹配，在指定时间之后才会匹配路由
  #            - Before=2018-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间进行匹配，在指定时间之前才会匹配路由
  #            - Between=2018-01-20T06:06:06+08:00[Asia/Shanghai], 2019-01-20T06:06:06+08:00[Asia/Shanghai] #根据时间段进行匹配，处于指定时间段才会匹配路由
          filters:
            - RequestTime=true #此处仅需要配置过滤器工厂前缀及其属性值启动即可（注意“-”后面一定要跟空格，否则报错）

日志如下：

六、总结

1、微服务网关介于客户端和服务器之间的中间层，所有外部请求都会先经过微服务网关 2、传统无网关访问的访问模式前端直接访问微服务接口，维护困难，且灵活性不佳。而基于网关的访问模式则通过集中式的网关组件管理微服务接口，降低客户端与服务端的耦合度，针对性地解决了传统模式的弊端 3、Spring Cloud Gateway由Route(路由)、Predicate(谓词)、Filter(过滤器)等内容组成，其中路由负责代理接口路径或指向服务，谓词负责为服务的访问提供先行条件，只有条件通过才会放行，过滤器负责在接口访问前后进行特殊操作。 4、Spring Cloud Gateway网关服务工程需引入依赖 spring-cloud-starter-gateway