当前位置:   article > 正文

Gateway自定义全局过滤器_gateway自定义过滤器

gateway自定义过滤器

一、Gateway全局过滤器

1、全局过滤器(Global Filters)简介

Gateway过滤器在实现方式上,有两种过滤器:

  • GatewayFilter(局部过滤器/网关过滤器): 需要通过 spring.cloud.routes.filters配置在具体的路由下,只作用在当前特定路由上,也可以通过配置 spring.cloud.default-filters让它作用于全局路由上。 spring.cloud.gateway.default-filters 上会对所有路由生效也算是全局的过滤器;但是这些过滤器的实现上都是要实现GatewayFilterFactory接口。
  • GlobalFilter(全局过滤器): 不需要再配置文件中配置,作用在所有的路由上,最终通过 GatewayFilterAdapter包装成 GatewayFilterChain能够识别的过滤器。

全局过滤器的作用也是处理一切进入网关的请求和微服务响应,与GatewayFilter的作用一样。Spring Cloud Gateway y也提供了几种全局过滤器,同时我们也可以自定义全局过滤器。

官方文档:https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#global-filters
在这里插入图片描述

2、ForwardRoutingFilter

ForwardRoutingFilter全局转发过滤器。

ForwardRoutingFilter会查看 exchange的属性 ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR的值(一个URI)。如果 URL有转发 scheme(例如forward:///localendpoint),Gateway使用 Spring DispatcherHandler来处理请求。请求 URL的路径部分被转发URL中的路径覆盖。未修改的原始URL将附加到ServerWebExchangeUtils中的列表中。

源码如下:

在这里插入图片描述

3、ReactiveLoadBalancerClientFilter

ReactiveLoadBalancerClientFilter全局负载均衡过滤器。

LoadBalancerClientFilter 会查看exchange的属性 ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR 的值(一个URI)。如果该值的 scheme是 lb,比如:lb://app-order ,它将会使用 Spring Cloud的 LoadBalancerClient 来将 微服务名(本例中为app-order)解析成实际的 host和 port,并替换掉 ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR 的内容。未修改的原始URL将附加到ServerWebExchangeUtils中的列表中。

    #配置 gateway网关
    gateway:
      #设置路由:路由id、路由到微服务的uri、断言
      routes:
        # app-order服务路由配置
        - id: app-order  #路由ID,全局唯一,建议配置服务名。
          uri: lb://app-order  #lb 整合负载均衡器ribbon,loadbalancer
          predicates:
            - Path=/order/**   # 断言,路径相匹配的进行路由
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

源码如下:

public class ReactiveLoadBalancerClientFilter implements GlobalFilter, Ordered {
    private static final Log log = LogFactory.getLog(ReactiveLoadBalancerClientFilter.class);
    private static final int LOAD_BALANCER_CLIENT_FILTER_ORDER = 10150;
    private final LoadBalancerClientFactory clientFactory;
    private LoadBalancerProperties properties;

    public ReactiveLoadBalancerClientFilter(LoadBalancerClientFactory clientFactory, LoadBalancerProperties properties) {
        this.clientFactory = clientFactory;
        this.properties = properties;
    }

    public int getOrder() {
        return 10150;
    }

    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        URI url = (URI)exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        String schemePrefix = (String)exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_SCHEME_PREFIX_ATTR);
        if (url != null && ("lb".equals(url.getScheme()) || "lb".equals(schemePrefix))) {
            ServerWebExchangeUtils.addOriginalRequestUrl(exchange, url);
            if (log.isTraceEnabled()) {
                log.trace(ReactiveLoadBalancerClientFilter.class.getSimpleName() + " url before: " + url);
            }

            return this.choose(exchange).doOnNext((response) -> {
                if (!response.hasServer()) {
                    throw NotFoundException.create(this.properties.isUse404(), "Unable to find instance for " + url.getHost());
                } else {
                    ServiceInstance retrievedInstance = (ServiceInstance)response.getServer();
                    URI uri = exchange.getRequest().getURI();
                    String overrideScheme = retrievedInstance.isSecure() ? "https" : "http";
                    if (schemePrefix != null) {
                        overrideScheme = url.getScheme();
                    }

                    DelegatingServiceInstance serviceInstance = new DelegatingServiceInstance(retrievedInstance, overrideScheme);
                    URI requestUrl = this.reconstructURI(serviceInstance, uri);
                    if (log.isTraceEnabled()) {
                        log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);
                    }

                    exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, requestUrl);
                }
            }).then(chain.filter(exchange));
        } else {
            return chain.filter(exchange);
        }
    }

    protected URI reconstructURI(ServiceInstance serviceInstance, URI original) {
        return LoadBalancerUriTools.reconstructURI(serviceInstance, original);
    }

    private Mono<Response<ServiceInstance>> choose(ServerWebExchange exchange) {
        URI uri = (URI)exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        ReactorLoadBalancer<ServiceInstance> loadBalancer = (ReactorLoadBalancer)this.clientFactory.getInstance(uri.getHost(), ReactorServiceInstanceLoadBalancer.class);
        if (loadBalancer == null) {
            throw new NotFoundException("No loadbalancer available for " + uri.getHost());
        } else {
            return loadBalancer.choose(this.createRequest());
        }
    }

    private Request createRequest() {
        return ReactiveLoadBalancer.REQUEST;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67

更多全局过滤器查看官方文档。下面我们自定义一个全局过滤器。

二、自定义全局过滤器

1、创建自定义全局过滤器类

在 Gateway服务中,创建自定义全局过滤器类必须实现 GlobalFilter接口。每一个过滤器都必须指定一个int类型的 order值,order值越小,过滤器优先级越高,执行顺序越靠前。GlobalFilter通过实现 Ordered接口来指定 order值。

模拟一个登录的校验。基本逻辑:如果请求中有 token参数,则认为请求有效,放行。

@Component
@Slf4j
public class AppCheckAuthGatewayFilter implements GlobalFilter, Ordered {

	/**
	 * 参考 GlobalFilter接口的实现类
	 * 
	 * @param exchange
	 * @param chain
	 * @return
	 */
	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		log.info("---------执行全局过滤器-----------");
		// 请求头或者请求参数中获取token
		String token = exchange.getRequest().getHeaders().getFirst("token");
		//String token = exchange.getRequest().getQueryParams().getFirst("token");
		if (StringUtils.isBlank(token)) {
			log.info("token is null");
			ServerHttpResponse response = exchange.getResponse();
			response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
			// 401 用户没有访问权限
			response.setStatusCode(HttpStatus.UNAUTHORIZED);
			byte[] bytes = HttpStatus.UNAUTHORIZED.getReasonPhrase().getBytes();
			DataBuffer buffer = response.bufferFactory().wrap(bytes);
			// 请求结束,不继续向下请求
			return response.writeWith(Mono.just(buffer));
		}
		// TODO 校验token进行身份认证
		log.info("开始校验token,token={}", token);

		return chain.filter(exchange);
	}

	/**
	 * 当有多个过滤器时, order值越小,越优先先执行
	 * 
	 * @return
	 */
	@Override
	public int getOrder() {
		return 100;
	}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

在这里插入图片描述

– 求知若饥,虚心若愚。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/667807
推荐阅读
相关标签
  

闽ICP备14008679号