引子

当前微服务架构已成为中大型系统的标配，但在享受拆分带来的敏捷性时，流量治理与安全管控的复杂度也呈指数级上升。因此，我们需要构建微服务网关来为系统“保驾护航”。本文将会通过一个项目（核心模块包含 鉴权服务、文件服务、主服务 共 3 个微服务），采用 Spring Cloud Alibaba 2023.0.0.0 版本技术栈（核心组件：Nacos 2.5.0 注册中心与配置中心），分享如何构建一个微服务网关。

为什么需要微服务网关

我们当前模拟的这个项目中包含了三个业务服务，如果部署到线上的话，每个服务都有自己的ip（或域名）以及端口号。因此，我们的业务入口是分散的且暴露在外的，我们无法统一拦截异常流量以及限制接口访问等。但有了微服务网关，我们就可以将所有的请求都先集中在网关这里（有点类似于一个房子的大门口），由网关对所有请求进行统一的管理。

实践

在知晓了网关的作用后，我们将实践如何在一个现成的微服务项目中整合gateway网关以及做功能开发。当然，在这之前，我们需要先完成整合。首先，我们需要建一个网关模块，如下：

完成模块的创建后，导入gateway相关的依赖，如下：

    <dependencies>
        <dependency>
            <groupId>com.pitayafruits</groupId>
            <artifactId>wechat-pojo</artifactId>
            <version>1.0-SNAPSHOT</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-web</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
    </dependencies>

说明一下：这里引入的pojo包含了项目中常用的方法、工具类等；web则是因为网关本身也是一个可以访问的服务，所以需要引入；gateway则是这里需要使用的网关的依赖。然后来对它进行基础的配置，如下：

server:
  port: 1000
  tomcat:
    uri-encoding: UTF-8
    max-swallow-size: -1 # 不限制请求体大小

spring:
  application:
    name: gateway
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        username: nacos
        password: naocs
        
# 日志级别
logging:
  level:
    root: info

我们使用了nacos来管理服务，网关自然也是一个服务，因此也需要把它注册到nacos。

1.统一路由

引入网关的首要作用是统一访问的入口，所有的服务访问都要先经过网关。因此，第一个要实现的功能就是统一路由。而它的实现也是非常简单，只需要在配置文件中做下简单配置即可：

spring:
    gateway:
      discovery:
        locator:
          enabled: true # 开启从注册中心动态创建路由的功能，利用微服务名进行路由
      routes:           # 路由配置信息(数组/list)
        - id: authRoute # 每项路由规则都有一个唯一的id编号，可以自定义
          uri: lb://auth-service # lb=负载均衡，会动态寻址
          predicates:
            - Path=/a/**
        - id: fileRoute
          uri: lb://file-service
          predicates:
            - Path=/f/**
        - id: mainRoute
          uri: lb://main-service
          predicates:
            - Path=/m/**
      globalcors: # 允许跨域的相关配置
        cors-configurations:
          '[/**]':
            allowedOriginPatterns: "*"
            allowedHeaders: "*"
            allowedMethods: "*"
            allowCredentials: true

这里对routes下的相关配置说明下：id是给每个服务的路由一个唯一编号，保证唯一即可，通常我们采用的写法是服务名+route;uri则是服务名称，如果写成ip或者域名，那么地址发生变化，我们还需要重新修改配置，但是服务名称是可以固定不变的；接下来是predicates,它可以配置多个值，我们一个服务里会有多个controller，把每个controller的路由配置在这里即可，/**表示指定的controller下的所有方法。

另外，如果负载均衡这个写法无法被识别，说明你当前使用的spring-cloud版本中默认并不包含相关依赖，我们需要手动引入它。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

完成上述配置后，我们此时其他服务的API将无法直接访问，而统一通过网关来访问。例如原本main-service中的127.0.0.1:88/m/hello 变成了 127.0.0.1:1000/m/hello。

2.限流防刷

提到网关，一个绕不开的话题就是限流。如果有人恶意刷我们的接口，我们就需要对某些IP进行访问限制，比如在XX秒内访问同一接口超过XX次，就需要限制访问。它的实现非常简单，声明一个处理类继承gateway的相关过滤接口即可。代码如下：

java">@Component
public class IPLimitFilter implements GlobalFilter {

    private static final Integer continueCounts = 3;

    private static final Integer timeInterval = 20;

    private static final Integer limitTimes = 30;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return doLimit(exchange, chain);
    }

    /**
     * 限制ip请求次数的判断
     *
     * @param exchange 请求交换器
     * @param chain     过滤器链
     * @return 返回值
     */
    public Mono<Void> doLimit(ServerWebExchange exchange,
                              GatewayFilterChain chain) {
        // 获取ip
        ServerHttpRequest request = exchange.getRequest();
        String ip = IPUtil.getIP(request);

        // 正常ip定义
        final String ipRedisKey = "gateway-ip" + ip;
        // 被拦截的黑名单，如果在redis中存在，那么就不允许访问
        final String ipRedisLimitKey = "gateway-ip:limit" + ip;

        // 判断当前ip的剩余时间，如果大于0，则表示还处于黑名单
        long limitLeftTimes = redis.ttl(ipRedisLimitKey);
        if ( limitLeftTimes > 0 ) {
            return renderErrorMsg(exchange, ResponseStatusEnum.SYSTEM_ERROR_BLACK_IP);
        }

        // 在redis中更新次数
        long requestCounts = redis.increment(ipRedisKey, 1);
        // 如果第一次访问，就需要设置间隔时间
        if (requestCounts == 1) {
            redis.expire(ipRedisKey, timeInterval);
        }
        // 如果还能获得正常请求次数，说明用户的正常请求落在正常时间内，超过则限制
        if (requestCounts > continueCounts) {
            redis.set(ipRedisLimitKey, ipRedisLimitKey, limitTimes);
            return renderErrorMsg(exchange, ResponseStatusEnum.SYSTEM_ERROR_BLACK_IP);
        }
        // 放行请求
        return chain.filter(exchange);
    }
    
    //过滤器的顺序，数字越小优先级越大.
    @Override
    public int getOrder() {
        return 1;
    }

我们需要借助redis来实现根据时间对指定ip的控制，这里的逻辑是：如果某个ip在30秒访问超过三次，就限制访问，如果限制了，则20秒后再恢复。

3.登录鉴权

关于登录鉴权，我们目前通常会采用无状态的做法：即用户登录后，后端返回token给前端，前端后续所有的请求都在headers中携带token，后端服务不存储token，只对前端发来的token进行校验和解析。而网关作为所有服务的入口，自然而然地也就可以承担起这个职责了。

java">import com.google.gson.Gson;
import com.pitayafruits.base.BaseInfoProperties;
import com.pitayafruits.grace.result.GraceJSONResult;
import com.pitayafruits.grace.result.ResponseStatusEnum;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.MimeTypeUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.List;

@Component
@Slf4j
@RefreshScope
public class SecurityFilterToken extends BaseInfoProperties implements GlobalFilter, Ordered {

    @Resource
    private ExcludeUrlProperties excludeUrlProperties;

    private AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        // 获取用户请求路径
        String url = exchange.getRequest().getURI().getPath();

        // 获取所有需要排除校验的url
        List<String> excludeList = excludeUrlProperties.getUrls();

        // 校验并排除url
        if (excludeList != null && !excludeList.isEmpty()) {
            for (String excludeUrl : excludeList) {
                if (antPathMatcher.matchStart(excludeUrl, url)) {
                    return chain.filter(exchange);
                }
            }
        }
        // 从header中获得用户id和token
        String userId = exchange.getRequest().getHeaders().getFirst(HEADER_USER_ID);
        String userToken = exchange.getRequest().getHeaders().getFirst(HEADER_USER_TOKEN);

        // 校验header中的token
        if (StringUtils.isNotBlank(userId) && StringUtils.isNotBlank(userToken)) {
            String redisToken = redis.get(REDIS_USER_TOKEN + ":" + userId);
            if (redisToken.equals(userToken)) {
                return chain.filter(exchange);
            }
        }

        // 默认不放行
        return renderErrorMsg(exchange, ResponseStatusEnum.UN_LOGIN);
    }

    //过滤器的顺序，数字越小优先级越大.
    @Override
    public int getOrder() {
        return 0;
    }

    /**
     * 异常信息包装
     *
     * @param exchange   交换器
     * @param statusEnum 状态枚举
     * @return 返回值
     */
    public Mono<Void> renderErrorMsg(ServerWebExchange exchange,
                                     ResponseStatusEnum statusEnum) {
        //1.获得response
        ServerHttpResponse response = exchange.getResponse();
        //2.构建jsonResult
        GraceJSONResult jsonResult = GraceJSONResult.exception(statusEnum);
        //3.设置header类型
        if (!response.getHeaders().containsKey("Content-Type")) {
            response.getHeaders().add("Content-Type",
                    MimeTypeUtils.APPLICATION_JSON_VALUE);
        }
        //4.设置状态码
        response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
        //5.转换json并向response写数据
        String resultJson = new Gson().toJson(jsonResult);
        DataBuffer buffer = response.bufferFactory().wrap(resultJson.getBytes(StandardCharsets.UTF_8));
        //6.返回
        return response.writeWith(Mono.just(buffer));
    }
}

在我这个示例中，我做的校验逻辑很简单：只是用户登录的时候会在redis里存放生成的token，然后其他接口访问的时候比对下传来的token和redis里存放的token是否一致。这里需要关注下过滤器的顺序，目前的案例中我们已经编写了两个过滤器-限流防刷和登录鉴权。所以可以把登录鉴权过滤器的执行顺序改为0，限流防抖改为1。

另外，我们需要对部分接口放行不拦截，比如登录接口。而我这里的做法则是将放行接口写在配置文件里，并声明配置类进行读取。

exclude.urls[0] = /passport/getSMSCode
exclude.urls[1] = /passport/regist
exclude.urls[2] = /passport/login

java">import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
@Data
@PropertySource("classpath:excludeUrlPath.properties")
@ConfigurationProperties(prefix = "exclude")
public class ExcludeUrlProperties {

    private List<String> urls;

}

特别说明下：这里制定好过滤器的执行顺序后，内部的验证逻辑根据自己实际情况填写，我这里没用鉴权框架只是方便讲解，要用也很简单，引入之后把相关的鉴权逻辑写进对应的过滤器就行。

小结

在本文中，我们完成了Spring Cloud Gateway微服务网关的整合，并完成了三个最基础常见的实践场景。如果你的项目有更多的业务需求，只需要加相应的过滤器并制定好过滤器的执行顺序即可，希望对大家有所帮助！