GateWay编程式自定义过滤器

续接上文：https://blog.csdn.net/weixin_52449016/article/details/140349851

1.配置文件不再需要配置路由信息：

server:
  port: 9999
spring:
  application:
    name: gateway-service
  cloud: #配置spring cloud相关属性
    gateway: #配置gateway相关属性
#      routes: # 网关路由配置
#        - id: gateway_service # 路由id，自定义，只要唯一即可
#        # uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
#          uri: https://localhost:8081 # 路由的目标地址 
#          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
#          - Path=/order/** # 按照路径匹配
#

2.编写全局过滤器，继承于GlobalFilter和Ordered

package com.dsxs.filters;

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.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.Map;

/**
 * @author pcs
 * 全局过滤器,所有请求都会走这个过滤器，优先级由order决定
 */
@Component
@Slf4j
public class CustomGlobalFilter implements GlobalFilter, Ordered {

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

        log.info("我是全局过滤器");
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -1;
    }
}

3.编写针对于order路径请求的过滤器，继承于GateWayFilter和Ordered

区别很显然：

GatewayFilter是针对单个路由规则定义的过滤器,只会对匹配该路由规则的请求进行过滤。

GlobalFilter是全局过滤器,会对进入gateway的所有请求进行过滤。

package com.dsxs.filters;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * @author pcs
 */
@Component
@Slf4j
public class OrderFilter implements GatewayFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("order已通过过滤");
        return chain.filter(exchange);
    }

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

4.编写针对product路径请求的过滤器，继承同order

package com.dsxs.filters;

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

/**
 * @author pcs
 */
@Component
@Slf4j
public class ProductFilter implements GatewayFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("product已通过过滤");
        return chain.filter(exchange);
    }
    @Override
    public int getOrder() {
        return 0;
    }
}

5.编写路由匹配规则

package com.dsxs.route;

import com.dsxs.filters.CustomGlobalFilter;
import com.dsxs.filters.OrderFilter;
import com.dsxs.filters.ProductFilter;
import org.springframework.cloud.gateway.handler.predicate.RoutePredicateFactory;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * @author pcs
 * 路由配匹配规则,可配置多个，匹配不同的过滤器
 */
@Component
public class RouteMatchRules {
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return  builder.routes()
                // /order请求需要OrderFilter过滤器
                .route(p -> p.path("/order/**")
                        .filters(f -> f.filter(new OrderFilter()))
                        .uri("http://localhost:8010"))
                 // /product请求需要ProductFilter过滤器
                .route(p -> p.path("/product/**")
                        .filters(f -> f.filter(new ProductFilter()))
                        .uri("http://localhost:8010")).build();
    }}

6.以上准备工作完成后，在其他服务模块编写简易接口，为什么在其他服务？启动不同端口，检验转发

这里我建在了普罗米修斯模块下

package com.dsxs.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author pcs
 */
@RestController
@RequestMapping("/order")
public class OrderTestController {
@GetMapping("/sucess")
    public String success(String a,String b){
    return "请求成功";
}
}
product请求类似，不做赘述

7.接口调用测试，说明走了全局过滤器和order过滤器，product类似，不做赘述。

喜欢作者的动动小手点点关注点点赞，更多可在公众号查看。