使用网关过滤器，根据业务规则实现微服务动态路由

文章目录

- 业务场景
- 拦截器实现
- [Spring Cloud Gateway介绍](#Spring Cloud Gateway介绍)

业务场景

我们服务使用Spring Cloud微服务架构，使用Spring Cloud Gateway 作为网关，使用 Spring Cloud OpenFeign 作为服务间通信方式
作为网关，主要作用是鉴权与路由转发。大多数应用场景，网关主要是针对前端的请求，前端调用接口，网关鉴权和转发。对于微服务间的调用，一般都不经过网关，直接根据注册服务列表路由到对应服务
对于一般的微服务路由转发，一般按照默认设置，根据服务名转发到对应服务即可
对于一些有转发规则的请求，也可以根据规则（如url前缀、某个参数的值、请求header里某个属性的）匹配转发到对应服务
简单的直接在配置文件里编写，例如某个值到某个服务是已知的，这些值是确定的和少量的，可以根据不通值到对应的服务，也可以自定义过滤器实现
现在有一个需求，需要根据参数的值路由到对应的服务，但是参数的值不是枚举值，数量不确定，可能有很多，值也不确定
但是这个值对应哪个服务（ip 端口）是已知的，需要实现根据这个业务规则动态路由到对应服务

拦截器实现

Spring Cloud Gateway的默认配置写法，将服务名转化为小写，根据名字匹配

yml 复制代码

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
          lower-case-service-id: true
          predicates:
            - name: Path
              args:
                pattern: "'/services/'+serviceId.toLowerCase()+'/**'"
          filters:
            - name: RewritePath
              args:
                regexp: "'/services/' + serviceId.toLowerCase() + '/(?<remaining>.*)'"
                replacement: "'/${remaining}'"

默认写法，只根据服务名字匹配进行路由转发，同服务名的多个微服务，轮询转发
一开始试着重写RouteToRequestUrlFilter，发现没有作用，根本走不到这个类
后面在@Component注解里指定了名称value = "org.springframework.cloud.gateway.filter.RouteToRequestUrlFilter"，完全覆盖，生效了
具体代码如下，核心是路由转发重新指定exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, mergedUrl)

java 复制代码

package com.newatc.com.authorization;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.newatc.com.SpringContextHolderUtil;
import com.newatc.com.authorization.util.HttpClientUtil;
import com.newatc.com.authorization.vo.SignalVO;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.core.Ordered;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;

/**
 * 重写Spring的RouteToRequestUrlFilter，自定义unit服务路由
 *
 * @author yanyulin
 * @date 2023-12-6 19:44:52
 */
@Component(value = "org.springframework.cloud.gateway.filter.RouteToRequestUrlFilter")
@Lazy
public class RouteToRequestUrlFilter implements GlobalFilter, Ordered {

    public static final int ROUTE_TO_URL_FILTER_ORDER = 10000;
    private static final Log log = LogFactory.getLog(RouteToRequestUrlFilter.class);
    private static final String SCHEME_REGEX = "[a-zA-Z]([a-zA-Z]|\\d|\\+|\\.|-)*:.*";
    static final Pattern schemePattern = Pattern.compile(SCHEME_REGEX);
    private static final String UNIT_API_PREFIX = "unit";
    private static final String UNIT_ADAPTER = "UNIT_ADAPTER";
    public static final String GET_UNIT_URL = "/services/core/api/signalcontrol/getSignalList";
    public static final String GET_UNIT_HOSTS = "/services/core/api/signalcontrol/getUnitHostList";
    private static final RedisTemplate<String, String> redisTemplate = SpringContextHolderUtil.getBean(StringRedisTemplate.class);

    @Value("${server.port}")
    private Integer SERVER_PORT;

    public RouteToRequestUrlFilter() {}

    static boolean hasAnotherScheme(URI uri) {
        return schemePattern.matcher(uri.getSchemeSpecificPart()).matches() && uri.getHost() == null && uri.getRawPath() == null;
    }

    public int getOrder() {
        return ROUTE_TO_URL_FILTER_ORDER;
    }

    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        Route route = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
        if (route == null) {
            return chain.filter(exchange);
        } else {
            log.trace("RouteToRequestUrlFilter start");
            URI uri = exchange.getRequest().getURI();
            boolean encoded = ServerWebExchangeUtils.containsEncodedParts(uri);
            URI routeUri = route.getUri();
            if (hasAnotherScheme(routeUri)) {
                exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_SCHEME_PREFIX_ATTR, routeUri.getScheme());
                routeUri = URI.create(routeUri.getSchemeSpecificPart());
            }
            log.debug("routeUri: " + JSON.toJSONString(routeUri));

            if ("lb".equalsIgnoreCase(routeUri.getScheme()) && routeUri.getHost() == null) {
                throw new IllegalStateException("Invalid host: " + routeUri);
            } else {
                // 原先的Uri
                URI mergedUrl = UriComponentsBuilder
                    .fromUri(uri)
                    .scheme(routeUri.getScheme())
                    .host(routeUri.getHost())
                    .port(routeUri.getPort())
                    .build(encoded)
                    .toUri();

                // 如果是需要自定义指定路由的服务，根据业务重写
                if (UNIT_API_PREFIX.equalsIgnoreCase(routeUri.getHost())) {
                    try {
                        log.info("mergedUrl前: " + JSON.toJSONString(mergedUrl));
                        String[] pathArr = uri.getPath().split("/");
                        String unitId = pathArr[pathArr.length - 1];
                        String host = "";
                        if (StringUtils.hasText(unitId)) {
                            host = getUnitHost(unitId);
                        }

                        if (StringUtils.hasText(host)) {
                            String newurl = host + mergedUrl.getPath();
                            if (StringUtils.hasText(exchange.getRequest().getURI().getQuery())) {
                                newurl = newurl + "?" + exchange.getRequest().getURI().getQuery();
                            }
                            URI newURI = new URI(newurl);
                            mergedUrl =
                                UriComponentsBuilder
                                    .fromUri(uri)
                                    .scheme(newURI.getScheme())
                                    .host(newURI.getHost())
                                    .port(newURI.getPort())
                                    .build(encoded)
                                    .toUri();
                            log.debug("mergedUrl后: " + JSON.toJSONString(mergedUrl));
                        }
                    } catch (Exception e) {
                        log.error("uri error", e);
                    }
                }
                exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, mergedUrl);
                return chain.filter(exchange);
            }
        }
    }

    /**
     * 根据信号机编号获取对应的服务适配器
     *
     * @param unitId
     * @return
     */
    private String getUnitHost(String unitId) {
        Map<String, String> unitIdHostMap = new HashMap<>();
        List<SignalVO> signalList;
        if (Boolean.TRUE.equals(redisTemplate.hasKey(UNIT_ADAPTER))) {
            signalList = JSONArray.parseArray(redisTemplate.opsForValue().get(UNIT_ADAPTER), SignalVO.class);
        } else {
            String url = "http://localhost:" + SERVER_PORT + GET_UNIT_URL;
            String info = HttpClientUtil.doGet(url, null);
            signalList = JSONArray.parseArray(info, SignalVO.class);
            if (null != signalList && !signalList.isEmpty()) {
                redisTemplate.opsForValue().set(UNIT_ADAPTER, JSON.toJSONString(signalList), 1, TimeUnit.MINUTES);
            }
        }
        if (null != signalList && !signalList.isEmpty()) {
            signalList.forEach(e -> unitIdHostMap.put(e.getUnitId(), "http://" + e.getServerIp() + ":" + e.getServerPort()));
        }

        return unitIdHostMap.get(unitId);
    }
}

核心就是重新指定uri，再设置进请求里

java 复制代码

String newurl = host + mergedUrl.getPath();
if (StringUtils.hasText(exchange.getRequest().getURI().getQuery())) {
    newurl = newurl + "?" + exchange.getRequest().getURI().getQuery();
}
URI newURI = new URI(newurl);
mergedUrl =
    UriComponentsBuilder
        .fromUri(uri)
        .scheme(newURI.getScheme())
        .host(newURI.getHost())
        .port(newURI.getPort())
        .build(encoded)
        .toUri();
exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, mergedUrl);

这个是前期的做法，后面考虑到服务间调用，不需要走网关Gateway服务，又废弃掉了，改为在服务调用的地方，使用拦截器过滤，详情参考：拦截器配置，FeignClient根据业务规则实现微服务动态路由

Spring Cloud Gateway介绍

Spring Cloud Gateway是Spring Cloud生态系统中的一个组件，用于构建基于Spring Boot的API网关服务。Spring Cloud Gateway基于Reactive编程模型，使用WebFlux框架实现，可以快速、可靠地构建和部署高性能的微服务应用程序。

Spring Cloud Gateway具有以下特点：

基于WebFlux：Spring Cloud Gateway基于Reactive编程模型，利用WebFlux框架实现非阻塞、事件驱动的异步处理，可以提供更好的性能和并发处理能力。
灵活的路由规则：Spring Cloud Gateway支持基于URI、请求方法、请求头等多种维度的路由规则配置，使得对请求进行灵活的路由转发变得简单易用。
过滤器：Spring Cloud Gateway的过滤器功能可以实现对请求和响应的预处理和后处理，包括请求日志记录、鉴权、路由转发、重定向等功能，可以满足各种需求的定制化处理。
集成性：Spring Cloud Gateway可以与其他Spring Cloud组件和微服务框架无缝集成，例如Eureka、Consul、Ribbon等，能够灵活地进行微服务的注册、发现和负载均衡。

总之，Spring Cloud Gateway是一个灵活、高性能的API网关服务，能够帮助开发者快速构建和部署微服务应用，实现请求路由、负载均衡、安全验证等功能。