spring cloud gateway自定义过滤器

2022-01-27 01:40:26

在API网关spring cloud gateway和负载均衡框架ribbon实战文章中，主要实现网关与负载均衡等基本功能，详见代码。本节内容将继续围绕此代码展开，主要讲解spring cloud gateway自定义过滤器的功能。本节内容的代码也会提交到GitHub上，注意提交的内容。

本节主要讲解全局过滤器和局部过滤器。注意下面的示例不能作为生产环境的代码，只是简单的演示自定义过滤器的使用方式，无需纠结实现的功能是否完善。下面主要针对不同的过滤器选择几种场景进行代码演示，不代表某个场景就必须使用全局或者局部的过滤器。

全局过滤器：

1、限流：每分钟只能访问5次服务

2、接口用时统计

局部过滤器：

1、简单的权限检查

2、指定IP访问

1、全局过滤器-限流

本节主要演示全局过滤器的用法：实现 GlobalFilter 和 Ordered，重写相关方法，加入到spring容器管理即可，无需配置，全局过滤器对所有的路由都有效。

package com.yefengyu.gateway.globalFilter;

import io.github.bucket4j.Bandwidth;

import io.github.bucket4j.Bucket;

import io.github.bucket4j.Bucket4j;

import io.github.bucket4j.Refill;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;

import org.springframework.cloud.gateway.filter.GlobalFilter;

import org.springframework.core.Ordered;

import org.springframework.http.HttpStatus;

import org.springframework.stereotype.Component;

import org.springframework.web.server.ServerWebExchange;

import reactor.core.publisher.Mono;

import java.time.Duration;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

//全局过滤器，实现GlobalFilter接口，和Ordered接口即可。

@Component

public class FluidControlGlobalGatewayFilter implements GlobalFilter, Ordered

{

    int capacity = 5;//桶的最大容量，即能装载 Token 的最大数量

    int refillTokens = 1; //每次 Token 补充量

    Duration duration = Duration.ofSeconds(1); //补充 Token 的时间间隔

    private static final Map<String, Bucket> BUCKET_CACHE = new ConcurrentHashMap<>();

    private Bucket createNewBucket()

    {

        Refill refill = Refill.greedy(refillTokens, duration);

        Bandwidth limit = Bandwidth.classic(capacity, refill);

        return Bucket4j.builder().addLimit(limit).build();

    }

    @Override

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

    {

        String ip = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();

        Bucket bucket = BUCKET_CACHE.computeIfAbsent(ip, k -> createNewBucket());

        System.out.println("IP: " + ip + "，has Tokens: " + bucket.getAvailableTokens());

        if (bucket.tryConsume(1))

        {

            return chain.filter(exchange);

        }

        else

        {

            exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);

            return exchange.getResponse().setComplete();

        }

    }

    @Override

    public int getOrder()

    {

        return -1000;

    }

}

注意在pom.xml文件中加入依赖

<dependency>

    <groupId>com.github.vladimir-bukhtoyarov</groupId>

    <artifactId>bucket4j-core</artifactId>

    <version>4.4.1</version>

</dependency>

2、全局过滤器-统计请求耗时

只需要在亲请求处理之前和之后标记时间即可。注意此处演示的是使用配置类的形式：

package com.yefengyu.gateway.globalFilter;

import org.springframework.cloud.gateway.filter.GlobalFilter;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.annotation.Order;

import reactor.core.publisher.Mono;

//全局过滤器，使用配置类形式，直接构造bean，使用注解完成Ordered接口功能,统计接口调用时间

@Configuration

public class GlobalGatewayFilterConfig

{

    @Bean

    @Order(-100)

    public GlobalFilter elapsedGlobalFilter()

    {

        return (exchange, chain) -> {

            //调用请求之前统计时间

            Long startTime = System.currentTimeMillis();

            return chain.filter(exchange).then().then(Mono.fromRunnable(() -> {

                //调用请求之后统计时间

                Long endTime = System.currentTimeMillis();

                System.out.println(

                    exchange.getRequest().getURI().getRawPath() + ", cost time : " + (endTime - startTime) + "ms");

            }));

        };

    }

}

3、局部过滤器-简单的权限检查

权限检查一般把信息存储在某处，请求到来之后进行核对，有权限的请求将真正执行。

1、首先编写一个工具类，对权限做管理。

package com.yefengyu.gateway.utitls;

import java.util.HashMap;

import java.util.Map;

public final class AuthUtil

{

    private static Map<String, String> map = new HashMap<>();

    private AuthUtil()

    {

    }

    //程序启动的时候加载权限的信息，比如从文件、数据库中加载

    public static void init()

    {

        map.put("tom", "123456");

    }

    //简单判断

    public static boolean isPermitted(String name, String password)

    {

        return map.containsKey(name) && map.get(name).equals(password);

    }

}

我们简单的将权限信息放到map中保管，init方法是初始化方法，isPermitted是对外提供一个判断是否有权限的方法。

2、服务启动的时候，需要初始化权限map,因此主启动类进行了修改：

package com.yefengyu.gateway;

import com.yefengyu.gateway.utitls.AuthUtil;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.context.event.ApplicationStartedEvent;

import org.springframework.context.ApplicationListener;

@SpringBootApplication

public class GatewayApplication

{

    public static void main(String[] args)

    {

        SpringApplication springApplication = new SpringApplication(GatewayApplication.class);

        springApplication.addListeners(new ApplicationListenerStarted());//增加监听器

        springApplication.run(args);

    }

    private static class ApplicationListenerStarted

        implements ApplicationListener<ApplicationStartedEvent>

    {

        @Override

        public void onApplicationEvent(ApplicationStartedEvent applicationStartedEvent)

        {

            //权限初始化数据

            AuthUtil.init();

        }

    }

}

3、编写一个局部过滤器，需要实现GatewayFilter, Ordered，实现相关的方法

package com.yefengyu.gateway.localFilter;

import com.yefengyu.gateway.utitls.AuthUtil;

import org.springframework.cloud.gateway.filter.GatewayFilter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;

import org.springframework.core.Ordered;

import org.springframework.http.HttpStatus;

import org.springframework.web.server.ServerWebExchange;

import reactor.core.publisher.Mono;

public class AuthGatewayFilter implements GatewayFilter, Ordered

{

    @Override

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

    {

        //获取header的参数

        String name = exchange.getRequest().getHeaders().getFirst("name");

        String password = exchange.getRequest().getHeaders().getFirst("password");

        boolean permitted = AuthUtil.isPermitted(name, password);//权限比较

        if (permitted)

        {

            return chain.filter(exchange);

        }

        else

        {

            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);

            return exchange.getResponse().setComplete();

        }

    }

    @Override

    public int getOrder()

    {

        return 10;

    }

}

4、接着需要把上面自定义的局部过滤器加入到过滤器工厂，并且注册到spring容器中。

package com.yefengyu.gateway.localFilter;

import org.springframework.cloud.gateway.filter.GatewayFilter;

import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;

import org.springframework.stereotype.Component;

@Component

public class AuthGatewayFilterFactory extends AbstractGatewayFilterFactory<Object>

{

    @Override

    public GatewayFilter apply(Object config)

    {

        return new AuthGatewayFilter();

    }

}

5、在配置文件中进行配置，如果不配置则不启用此过滤器规则。

4、局部过滤器-指定IP访问

我们的需求是如果在配置文件配置了一个IP，那么该ip就可以访问，其它IP通通不能访问。如果不使用该过滤器，那么所有IP都可以访问服务。

这里我们看到上面的AuthGatewayFilter和AuthGatewayFilterFactory代码本来就是为了同一个过滤器规则编写的两个类，如果过滤器规则很多，那么类文件就很多，其实这两个类可以合并，并且还会提供其它的功能：

package com.yefengyu.gateway.localFilter;

import org.springframework.cloud.gateway.filter.GatewayFilter;

import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;

import org.springframework.core.annotation.Order;

import org.springframework.http.HttpStatus;

import org.springframework.stereotype.Component;

import java.util.Arrays;

import java.util.List;

@Component

@Order(99)

public class IPForbidGatewayFilterFactory

    extends AbstractGatewayFilterFactory<IPForbidGatewayFilterFactory.Config>

{

    public IPForbidGatewayFilterFactory()

    {

        super(Config.class);

    }

    @Override

    public List<String> shortcutFieldOrder()

    {

        return Arrays.asList("forbidIp");

    }

    @Override

    public GatewayFilter apply(Config config)

    {

        return (exchange, chain) -> {

            String ip = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();

            if (config.getForbidIp().equals(ip))

            {

                return chain.filter(exchange);

            }

            exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);

            return exchange.getResponse().setComplete();

        };

    }

    static public class Config

    {

        private String forbidIp;

        public String getForbidIp()

        {

            return forbidIp;

        }

        public void setForbidIp(String forbidIp)

        {

            this.forbidIp = forbidIp;

        }

    }

}

Config类定义了一个属性，要重写List<String> shortcutFieldOrder()这个方法指定属性名称。规则逻辑很简单，判断配置文件中的ip是和请求来的ip是否相同，相同则可以访问服务。

配置文件：

正常测试

5、总结

全局过滤器，对所有的路由都有效，所有不用在配置文件中配置，主要实现了GlobalFilter 和 Ordered接口，并将过滤器注册到spring 容器。由于使用java配置类的方式也可以注册bean，所有也可以使用配置类的方式，Ordered接口使用Order注解代替，GlobalFilter 只是个接口，可以使用Lambda表达式替换。

局部过滤器，需要在配置文件中配置，如果配置，则该过滤器才会生效。主要实现GatewayFilter, Ordered接口，并通过AbstractGatewayFilterFactory的子类注册到spring容器中，当然也可以直接继承AbstractGatewayFilterFactory，在里面写过滤器逻辑，还可以从配置文件中读取外部数据。

本节代码已提交：github本次提交代码内容

码农公寓

1、全局过滤器-限流

2、全局过滤器-统计请求耗时

3、局部过滤器-简单的权限检查

4、局部过滤器-指定IP访问

5、总结

相关文章