微服务的Gateway网关简介

最新推荐文章于 2024-05-17 10:19:13 发布

学编程的火山小同学

最新推荐文章于 2024-05-17 10:19:13 发布

阅读量157

点赞数

分类专栏： Java框架文章标签：微服务 gateway java

本文链接：https://blog.csdn.net/Ahjbvj/article/details/131677631

版权

Java框架专栏收录该内容

11 篇文章 0 订阅

订阅专栏

在微服务架构中，一个系统会被拆分为很多个微服务。客户端如果要去调用这么多的微服务，如果没有网关的存在，我们只能在客户端记录每个微服务的地址，然后分别去调用。这样会显得代码较为冗余，并且也会十分复杂，对于认证或者一些其他的统一的功能在每个服务都需要编写一次，较为麻烦。

但是如果加入API网关，使得系统有统一的入口，他就可以为客户端提供统一的服务，一些诸如认证、鉴权、监控、路由转发等也可以在这里实现。

1. SpringBoot项目集成Gateway网关

首先我们在pom.xml文件中引入SpringCloudGateway网关的依赖：

<dependencies>
    <!--gateway网关-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
</dependencies>

然后我们在配置文件中配置Gateway的配置信息。其中id标识路由标识符，区别于其他路由。URL代表路由指向的目的地uri，即客户端请求最终被转发到的微服务。order用户route之间的排序，数值越小排序越靠前，匹配优先级越高。predicate断言的作用是进行条件判断，只有断言都返回真，才会执行路由。filter过滤器用户修改请求和相应信息。

server:
    port: 7000
spring:
    application:
        name: api-gateway
    cloud:
        gateway:
            routes: # 路由数组[路由 就是指定当请求满足什么条件的时候转到哪个微服务]
                - id: product_route # 当前路由的标识, 要求唯一
                    uri: http://localhost:8081 # 请求要转发到的地址
                    order: 1 # 路由的优先级,数字越小级别越高
                    predicates: # 断言(就是路由转发要满足的条件)
                        - Path=/product-serv/** # 当请求路径满足Path指定的规则时,才进行路由转发
                    filters: # 过滤器,请求在传递过程中可以通过过滤器对其进行一定的修改
                        - StripPrefix=1 # 转发之前去掉1层路径

2. 网关中的断言配置

SpringCloud Gateway包括许多内置的断言工厂，所有这些断言都与HTTP请求的不同属性匹配。具体如下：

基于Datetime类型的断言工厂，此类型的断言根据时间做判断，主要有三个。AfterRoutePredicateFactory：接收一个日期参数，判断请求日期是否晚于指定日期BeforeRoutePredicateFactory：接收一个日期参数，判断请求日期是否早于指定日期 BetweenRoutePredicateFactory：接收两个日期参数，判断请求日期是否在指定时间段内,断言语句的格式如 -After=2019-12-31T23:59:59.789+08:00[Asia/Shanghai]所示。

基于Cookie的断言工厂 CookieRoutePredicateFactory：接收两个参数，cookie 名字和一个正则表达式。判断请求 cookie是否具有给定名称且值与正则表达式匹配。断言语句格式为：-Cookie=chocolate, ch.

基于Host的断言工厂 HostRoutePredicateFactory：接收一个参数，主机名模式。判断请求的Host是否满足匹配规则。断言语句格式为：-Host=**.testhost.org

上述Gateway自带的断言功能，我们还可以自定义一个断言工厂，实现断言方法。断言工厂的代码如下所示：

//泛型 用于接收一个配置类,配置类用于接收中配置文件中的配置
@Component
public class AgeRoutePredicateFactory extends             
    AbstractRoutePredicateFactory<AgeRoutePredicateFactory.Config> {
    public AgeRoutePredicateFactory() {
        super(AgeRoutePredicateFactory.Config.class);
    }
    //用于从配置文件中获取参数值赋值到配置类中的属性上
    @Override
    public List<String> shortcutFieldOrder() {
        //这里的顺序要跟配置文件中的参数顺序一致
        return Arrays.asList("minAge", "maxAge");
    }

    //断言
    @Override
    public Predicate<ServerWebExchange> apply(AgeRoutePredicateFactory.Config config) {
        return new Predicate<ServerWebExchange>() {
            @Override
            public boolean test(ServerWebExchange serverWebExchange) {
                //从serverWebExchange获取传入的参数
                String ageStr =
serverWebExchange.getRequest().getQueryParams().getFirst("age");
                if (StringUtils.isNotEmpty(ageStr)) {
                    int age = Integer.parseInt(ageStr);
                    return age > config.getMinAge() && age < config.getMaxAge();
                }
                return true;
            }
        };
    }
}
//自定义一个配置类, 用于接收配置文件中的参数
@Data
class Config {
    private int minAge;
    private int maxAge;
}

3. 网关中的过滤器配置

在SpringCloudGateway中也内置了很多不同类型的网关路由过滤器，比如AddRequestHeader可以为原始请求添加Header，参数是Header的名称及值。AddRequestParameter可以为原始请求添加请求参数，参数是参数名称及值。AddResponseHeader可以为原始响应添加Header，参数是Header的名称和值。

上述是自带的过滤器，我们也可以自定义局部过滤器，自定义局部过滤器的步骤如下所示：

首先我们在配置文件中，添加一个Log的过滤器配置。

filters:
    - StripPrefix=1
    - Log=true,false # 控制日志是否开启

然后我们自定义一个过滤器工厂，实现方法，具体的实现代码如下所示：

//自定义局部过滤器
@Component
public class LogGatewayFilterFactory extends             AbstractGatewayFilterFactory<LogGatewayFilterFactory.Config> {
    //构造函数
    public LogGatewayFilterFactory() {
        super(LogGatewayFilterFactory.Config.class);
    }

    //读取配置文件中的参数 赋值到 配置类中
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("consoleLog", "cacheLog");
    }

    //过滤器逻辑
    @Override
    public GatewayFilter apply(LogGatewayFilterFactory.Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange,GatewayFilterChain chain){
                if (config.isCacheLog()) {

                    System.out.println("cacheLog已经开启了....");
                }
                if (config.isConsoleLog()) {
                    System.out.println("consoleLog已经开启了....");
                }
                return chain.filter(exchange);
            }
        };
    }
    //配置类 接收配置参数
    @Data
    @NoArgsConstructor
    public static class Config {
        private boolean consoleLog;
        private boolean cacheLog;
    }
}

局部过滤器的使用需要在配置文件中进行配置，而对于全局过滤器的使用无需配置，将直接作用于所有路由，通过全局过滤器可以实现对权限的统一检验，安全验证等功能。全局过滤器包括负载均衡相关过滤器，http客户端相关过滤器，Websocket相关过滤器等。

我们还可以实现自定义的全局过滤器，自定义的全局过滤器可以用来做鉴权等。具体的代码样例如下所示：

//自定义全局过滤器需要实现GlobalFilter和Ordered接口
@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {
    //完成判断逻辑
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getQueryParams().getFirst("token");
        if (StringUtils.isBlank(token)) {
            System.out.println("鉴权失败");
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        //调用chain.filter继续向下游执行
        return chain.filter(exchange);
    }

    //顺序,数值越小,优先级越高
    @Override
    public int getOrder() {
        return 0;
    }
}

4. 网关的限流操作

网关是所有请求的公共入口，所以可以在网关进行限流，限流的方式也有很多。

首先我们要导入Gateway的SpringCloud依赖

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
</dependency>

然后我们编写配置类，在使用时只需注入对应的SentinelGatewayFilter实例以及SentinelGatewayBlockExceptionHandler 实例即可。

@Configuration
public class GatewayConfiguration {
    private final List<ViewResolver> viewResolvers;
    private final ServerCodecConfigurer serverCodecConfigurer;
    public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider, ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers =viewResolversProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    }

    // 初始化一个限流的过滤器
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public GlobalFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }

    // 配置初始化的限流参数
    @PostConstruct
    public void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();
        rules.add(new GatewayFlowRule("product_route") //资源名称,对应路由id
            .setCount(1) // 限流阈值
            .setIntervalSec(1) // 统计时间窗口，单位是秒，默认是 1 秒
        );
        GatewayRuleManager.loadRules(rules);
    }

    // 配置限流的异常处理器
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        return new SentinelGatewayBlockExceptionHandler(viewResolvers,serverCodecConfigurer);
    }

    // 自定义限流异常页面
    @PostConstruct
    public void initBlockHandlers() {
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
                Map map = new HashMap<>();
                map.put("code", 0);
                map.put("message", "接口被限流了");
                return ServerResponse.status(HttpStatus.OK).
                    contentType(MediaType.APPLICATION_JSON_UTF8).
                    body(BodyInserters.fromObject(map));
            }
        };
        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }
}

我们还可以通过自定义API分组的方式实现更细粒度的限流规则定义。

/**
* 配置初始化的限流参数
*/
@PostConstruct
public void initGatewayRules() {
    Set<GatewayFlowRule> rules = new HashSet<>();
    rules.add(new GatewayFlowRule("product_api1").setCount(1).setIntervalSec(1));
    rules.add(new GatewayFlowRule("product_api2").setCount(1).setIntervalSec(1));
    GatewayRuleManager.loadRules(rules);
}

//自定义API分组
@PostConstruct
private void initCustomizedApis() {
    Set<ApiDefinition> definitions = new HashSet<>();
    ApiDefinition api1 = new ApiDefinition("product_api1")
        .setPredicateItems(new HashSet<ApiPredicateItem>() {{
            // 以/product-serv/product/api1 开头的请求
            add(new ApiPathPredicateItem().setPattern("/productserv/product/api1/**").
    setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
        }});
    ApiDefinition api2 = new ApiDefinition("product_api2")
        .setPredicateItems(new HashSet<ApiPredicateItem>() {{
        // 以/product-serv/product/api2/demo1 完成的url路径匹配
            add(new ApiPathPredicateItem().setPattern("/productserv/product/api2/demo1"));
        }});
    definitions.add(api1);
    definitions.add(api2);
    GatewayApiDefinitionManager.loadApiDefinitions(definitions);
}

学编程的火山小同学

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
微服务的Gateway网关简介

在微服务架构中，一个系统会被拆分为很多个微服务。客户端如果要去调用这么多的微服务，如果没有网关的存在，我们只能在客户端记录每个微服务的地址，然后分别去调用。这样会显得代码较为冗余，并且也会十分复杂，对于认证或者一些其他的统一的功能在每个服务都需要编写一次，较为麻烦。但是如果加入API网关，使得系统有统一的入口，他就可以为客户端提供统一的服务，一些诸如认证、鉴权、监控、路由转发等也可以在这里实现。
复制链接

扫一扫