SpringCloud学习笔记

文章6 |   阅读 2671 |   点赞0

来源：https://blog.csdn.net/blu_111/category_9903821.html

Spring Cloud Alibaba 05_使用微服务网关 Gateway 实现路由映射和API限流

转x33g5p2x  于2021-12-18 转载在 其他  
字(10.0k)|赞(0)|评价(0)|浏览(520)

Spring Cloud Alibaba 05_使用微服务网关 Gateway 实现路由映射和API限流

注：Gateway 是 SpringCloud 官方提供的新一代网关组件，是基于Netty 的，与 Servlet 不兼容

所以在 gateway 中不能出现 Servlet 相关的组件，不能使用 spring web 依赖！

手动配置路由映射：

  • 删除父工程中的 spring web 依赖，然后在 Provider 和 Comsumer 中重新添加：
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>
  • 创建 getway 子模块，将子模块 provider 的 parent 标签修改为父工程信息，并添加 gateway 的依赖：
<parent>
	<groupId>com.blu</groupId>
	<artifactId>springcloudalibabademo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
</parent>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-gateway</artifactId>
	<version>2.2.5.RELEASE</version>
</dependency>
  • gateway 的 application.yml 配置文件：
server:
  port: 8010

spring:
  application:
    name: gateway
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # 开启通过网关映射微服务
      routes:
        - id: provider_route  # 映射路由id
          uri: http://localhost:8081 # 真实的微服务uri
          # 映射的服务路径，此时 localhost:8010/provider/index 将映射成 localhost:8081/provider/list
          predicates:
            - Path=/provider/**
          # 地址映射时去除第一个前缀(provider)，即: localhost:8081/list
          filters:
            - StripPrefix=1

启动 provider 和 gateway

直接访问 provider ：http://localhost:8081/index

通过网关访问 provider ：http://localhost:8010/provider/index

通过 nacos 实现自动配置的路由映射：

gateway 中添加 nacos 依赖：

<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
	<version>2.2.1.RELEASE</version>
</dependency>

去掉 application.yml 中手动配置的路由映射：

server:
  port: 8010

spring:
  application:
    name: gateway
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # 开启通过网关映射微服务

重启 gateway，依然能够通过路由访问：http://localhost:8010/provider/index

基于路由限流

gateway 中去掉 nacos 依赖，重新手动配置 routes，添加 sentinel 与 gateway 整合的依赖：

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

限流配置类：

package com.blu.configuration;

import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.util.*;

@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 SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    }

    //配置初始化的限流参数
    @PostConstruct
    public void initGatewayRules(){
        Set<GatewayFlowRule> rules = new HashSet<>();
        rules.add(
                //provider_route是配置文件中配置的路由route的id
                new GatewayFlowRule("provider_route")
                        //表示1s允许1个访问，QPS=1
                        .setCount(1)
                        .setIntervalSec(1)
        );
        GatewayRuleManager.loadRules(rules);
    }

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

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

}

启动，直接访问 Provider 微服务（无限流）：http://localhost:8081/index

通过 gateway 访问 Provider （限流 1QPS）：http://localhost:8010/provider/index

基于API分组限流

  • 在 ProviderController 中添加以下四个方法：
@GetMapping("api1/demo1")
public String demo1(){
	return "demo1";
}

@GetMapping("api1/demo2")
public String demo2(){
	return "demo2";
}

@GetMapping("api2/demo3")
public String demo3(){
	return "demo3";
}

@GetMapping("api2/demo4")
public String demo4(){
	return "demo4";
}
  • 修改 GatewayConfiguration 配置类：
package com.blu.configuration;

import com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.util.*;

@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 SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    }

    //配置初始化的限流参数
    @PostConstruct
    public void initGatewayRules(){
        Set<GatewayFlowRule> rules = new HashSet<>();
        //配置分组名称和QPS
        rules.add(new GatewayFlowRule("provider-api1").setCount(1).setIntervalSec(1));
        rules.add(new GatewayFlowRule("provider-api2").setCount(2).setIntervalSec(1));
        GatewayRuleManager.loadRules(rules);
    }

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

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

    //自定义API分组
    @PostConstruct
    private void initCustomizedApis(){
        Set<ApiDefinition> definitions = new HashSet<>();
        ApiDefinition api1 = new ApiDefinition("provider-api1")
                .setPredicateItems(new HashSet<ApiPredicateItem>(){{
                    add(new ApiPathPredicateItem().setPattern("/provider/api1/**")
                            .setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
                }});
        ApiDefinition api2 = new ApiDefinition("provider-api2")
                .setPredicateItems(new HashSet<ApiPredicateItem>(){{
                    add(new ApiPathPredicateItem().setPattern("/provider/api2/demo3"));
                }});
        definitions.add(api1);
        definitions.add(api2);
        GatewayApiDefinitionManager.loadApiDefinitions(definitions);
    }

}

启动访问：

http://localhost:8010/provider/api1/demo1 （限流1QPS）

http://localhost:8010/provider/api1/demo2 （限流1QPS）

http://localhost:8010/provider/api2/demo3 （限流2QPS）

http://localhost:8010/provider/api2/demo4 （不限流）

基于 nacos 服务发现组件进行限流

  • 在 gateway 中重新添加 nacos 依赖，application.yml 中去除手动配置的路由映射
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <version>2.2.1.RELEASE</version>
</dependency>

重启访问，效果一致：

http://localhost:8010/provider/api1/demo1 （限流1QPS）

http://localhost:8010/provider/api1/demo2 （限流1QPS）

http://localhost:8010/provider/api2/demo3 （限流2QPS）

http://localhost:8010/provider/api2/demo4 （不限流）

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blucoding.blog.csdn.net/article/details/109383988

内容来源于网络，如有侵权，请联系作者删除！

Gateway

相关文章

    查看更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com