服务网关 #

@Order(100)
@Component
public class TestFilter implements GlobalFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //先获取ServerHttpRequest对象，注意不是HttpServletRequest
        ServerHttpRequest request = exchange.getRequest();
        //打印一下所有的请求参数
        System.out.println(request.getQueryParams());
        //判断是否包含test参数，且参数值为1
        List<String> value = request.getQueryParams().get("test");
        if (value != null && value.contains("1")) {
            //将ServerWebExchange向过滤链的下一级传递（跟JavaWeb中介绍的过滤器其实是差不多的）
            return chain.filter(exchange);
        } else {
            //直接在这里不再向下传递，然后返回响应
            return exchange.getResponse().setComplete();
        }
    }
}

public class Route implements Ordered {

    private final String id; //标识符，区别于其他 Route。

    private final URI uri; // 路由指向的目的地 uri，即客户端请求最终被转发的目的地。

    private final int order; // 用于多个 Route 之间的排序，数值越小排序越靠前，匹配优先级越高。

    private final AsyncPredicate<ServerWebExchange> predicate; // 谓语，表示匹配该 Route 的前置条件，即满足相应的条件才会被路由到目的地 uri。

    private final List<GatewayFilter> gatewayFilters; // 过滤器用于处理切面逻辑，如路由转发前修改请求头等。
}

public interface GatewayFilter extends ShortcutConfigurable {

    String NAME_KEY = "name";
    String VALUE_KEY = "value";

    /**
     * Process the Web request and (optionally) delegate to the next
     * {@code WebFilter} through the given {@link GatewayFilterChain}.
     * @param exchange the current server exchange
     * @param chain provides a way to delegate to the next filter
     * @return {@code Mono<Void>} to indicate when request processing is complete
     */
    Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}

public interface GatewayFilterChain {

    /**
     * Delegate to the next {@code WebFilter} in the chain.
     * @param exchange the current server exchange
     * @return {@code Mono<Void>} to indicate when request handling is complete
     */
    Mono<Void> filter(ServerWebExchange exchange);

}

@ConfigurationProperties("spring.cloud.gateway") // 表明以 "spring.cloud.gateway" 前缀的 properties 会绑定 GatewayProperties。
@Validated
public class GatewayProperties {

    /**
     * List of Routes
     */
    @NotNull
    @Valid
    private List<RouteDefinition> routes = new ArrayList<>(); //  用来对 Route 进行定义。

    /**
     * List of filter definitions that are applied to every route.
     */
    private List<FilterDefinition> defaultFilters = new ArrayList<>(); // 用于定义默认的 Filter 列表，默认的 Filter 会应用到每一个 Route 上，gateway 处理时会将其与 Route 中指定的 Filter 进行合并后并逐个执行。
}

public class RouteDefinition {
    @NotEmpty
    private String id = UUID.randomUUID().toString(); // 定义 Route 的 id，默认使用 UUID。

    @NotEmpty
    @Valid
    private List<PredicateDefinition> predicates = new ArrayList<>();  // 定义 Predicate。

    @Valid
    private List<FilterDefinition> filters = new ArrayList<>();  // 定义 Filter。

    @NotNull
    private URI uri;  // 定义目的地 URI。

    private int order = 0; // 定义 Route 的序号。
}

public class LoadBalancerClientFilter implements GlobalFilter, Ordered {

    private static final Log log = LogFactory.getLog(LoadBalancerClientFilter.class);
    public static final int LOAD_BALANCER_CLIENT_FILTER_ORDER = 10100;

    private final LoadBalancerClient loadBalancer;

    public LoadBalancerClientFilter(LoadBalancerClient loadBalancer) {
        this.loadBalancer = loadBalancer;
    }

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

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获得 URL 
        URI url = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
        if (url == null || !url.getScheme().equals("lb")) {
            return chain.filter(exchange);
        }
        // 添加 原始请求URI 到 GATEWAY_ORIGINAL_REQUEST_URL_ATTR
        //preserve the original url
        addOriginalRequestUrl(exchange, url);

        log.trace("LoadBalancerClientFilter url before: " + url);

        // 获取 服务实例
        final ServiceInstance instance = loadBalancer.choose(url.getHost());
        if (instance == null) {
            throw new NotFoundException("Unable to find instance for " + url.getHost());
        }
     
     	/*URI uri = exchange.getRequest().getURI();
 		URI requestUrl = loadBalancer.reconstructURI(instance, uri);*/
        //
        URI requestUrl = UriComponentsBuilder.fromUri(url)
                .scheme(instance.isSecure() ? "https" : "http") //TODO: support websockets
                .host(instance.getHost())
                .port(instance.getPort())
                .build(true)
                .toUri();
        log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);

        // 添加 请求URI 到 GATEWAY_REQUEST_URL_ATTR
        exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, requestUrl);

        // 提交过滤器链继续过滤
        return chain.filter(exchange);
    }

}

URI url=exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
if(url==null||!url.getScheme().equals("lb")){
    return chain.filter(exchange);
}

final ServiceInstance instance = loadBalancer.choose(url.getHost());

URI requestUrl = UriComponentsBuilder.fromUri(url)
        .scheme(instance.isSecure() ? "https" : "http") //TODO: support websockets
        .host(instance.getHost())
        .port(instance.getPort())
        .build(true)
        .toUri();
log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);