springCloudAlibaba之分布式网关组件---gateway

已于 2024-06-21 17:09:56 修改
阅读量443 收藏
点赞数 3
分类专栏： SpringCloud 文章标签： 分布式 gateway
于 2024-06-16 10:36:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43216437/article/details/139716379
版权

gateway-网关

网关

在微服务架构中一个系统会被拆分成多个微服务。那么作为客户端(前端)要如何去调用这么多的微服务？如果没有网关的存在，我们只能在客户端记录每个微服务的地址，然后分别去用。
在这里插入图片描述

这样的架构，会存在诸多的问题：

  • 每个业务都会需要鉴权、限流、权限校验、跨域等逻辑，如果每个业务都各自为站。自己造轮子实现一遍，完全没必要，完全可以抽离出来，放到一个统一的地方去做。
    上面的问题可以借助网关来解决。
    在这里插入图片描述

网关：所谓API网关，就是指系统的同一入口，它封装了应用程序的内部结构，为客户端提供统一服务，一些与业务功能本身无关的公共逻辑可以在这里实现，诸如认证、鉴权、监控、路由转发等待

添加上API网关之后,系统变成三层结构，系统的架构图如下：
在这里插入图片描述
加入网关之后的架构图
在这里插入图片描述

spring cloud gateway

  • 功能特征
  • 基于spring5.0和springboot2.0进行构建
  • 动态路由：可以匹配任何请求属性
  • 支持路径重写
  • 集成服务发现（nacos、ereka）
  • 可集成流控降级功能（sentinel、hystrix）
  • 可以对路由指定易于编写的断言和过滤器
  • 路由
    路由是网关中最基础的部分，路由信息包括一个ID、一个目的URL、一组断言工厂、一组filter组成。如果断言为真，则说明请求的RUL和配置的路由匹配；
  • 断言
    Java8中的断言函数，gateway中的断言函数类型是spring5.0框架中的servletWebExchange，断言函数允许开发者去定义匹配http request中的任何信息，比如请求头和参数等。
  • 过滤器
    gateway中的filter分为Gateway Filter和Global Filter,filter可以对请求和响应处理
  • 工作原理
    spring cloud gateway的工作原理和zuul的差不多，最大的区别就是gateway的filter只有pre和post两种。

gateway初体验

添加依赖

   <!--添加springcloud gateway依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
  • 配置文件
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order-server/**
              # http://localhost:8090/order-server/order/buyProduct 路由到↓
              # http://localhost:8081/order-server/order/buyProduct
          filters:
            - StripPrefix=1 #内置过滤器，转发之前去掉第一层路径
            # http://localhost:8081/order-server/order/buyProduct 去掉后 ↓
            # http://localhost:8081/order/buyProduct

gateway整合nacos

你这个是springcloud gateway吧，我跟你说一下为什么这么写配置，是这样的，lb代表了负载均衡，有这个标志后，gateway就知道需要进行负载均衡，转发到lb://后面跟的服务名对应的某台服务器上，至于如何实现负载均衡，是通过负载均衡组件来的，比如ribbon或者springcloud-loadbalancer组件拿到服务列表，从而进行服务的转发。所以lb://，其实跟服务注册中心没有关系，就算不是nacos，用其它的，比如eureka，也是这么写lb://。

server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: lb://order-service #需要转发的地址 lb:使用nacos中的本地负载均衡策略
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order-server/**
            # http://localhost:8090/order-server/order/buyProduct 路由到↓
            # http://localhost:8081/order-server/order/buyProduct
          filters:
            - StripPrefix=1 #内置过滤器，转发之前去掉第一层路径
            # http://localhost:8081/order-server/order/buyProduct 去掉后 ↓
            # http://localhost:8081/order/buyProduct

简写方式

当服务注册到nacos后，断言规则可以用服务名来进行匹配，此时配置可以进行简化(约定服务名和断言规则都从nacos获取)

server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
     discovery:
       locator:
         enabled: true #是否启动自动识别nacos服务（约定大于配置）
  • 测试
    此时访问：http://localhost:8090/order-service/order/buyProduct
    在这里插入图片描述

内置路由断言工厂

作用：当请求gateway的时候，使用断言对请求进行匹配，如果匹配成功就进行路由转发，如果匹配失败就返回404

内置断言工厂

在这里插入图片描述
在这里插入图片描述

  • 基于Datetime类型的断言工厂
    此类型的断言根据时间做判断，主要有三个：
  • AfterRoutePredicateFactory:接收一个日期参数，判断请求日期是否晚于指定日期
  • BeforeRoutePredicateFactory:接收一个日期参数，判断请求日期是否早于指定日期
  • BetweenRoutePredicateFactory:接收一个日期参数，判断请求日是否在指定时间段内
    类型：zoneDateTime.now():System.out.println(ZonedDateTime.now());

-After=2024-12-31T23:59:59.789+08:00[Asia/Shanghai]

#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2024-12-31T23:59:59.789+08:00[Asia/Shanghai]
  • 基于请求头Headder的断言工厂
  • HeaderRoutePredicateFactory:接收两个参数，标题名称和正则表达式，判断请求Header是否具有给定名称且值与正则表达式匹配。
  • Header=X-Request-Id,\d+
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+

测试
在这里插入图片描述
在这里插入图片描述

  • 基于Method请求方法的断言工厂
  • MethodRoutePredicateFactory:接收一个参数，判断请求类型是否跟指定的类型匹配
  • Method=GET
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
  • 基于Query请求参数的断言工厂
  • QueryRoutePredicateFactory:接收两个参数，请求param和正则表达式，判断请求参数是否具有给定名称且值与正则表达式匹配。
  • Query=id,\d+
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
            - Query=id,\d+

测试
在这里插入图片描述

自定义路由断言工厂

自定义路由断言工厂需要继承AbstractRoutePredicateFactory类，重写apply方法的逻辑。在apply方法中可以通过exchange.getRequest()拿到serverletRequest对象，从而可以获取到请求的参数、请求方式、请求头等信息。

1、必须是bean组件
2、由于约定大于配置：类名必须加上RoutePredicateFactory作为结尾
3、必须继承AbstractRoutePredicateFactory类
4、必须声明一个静态内部类，声明属性来接收配置文件中对应的信息
5、需要结合shortcutFieldOrder来进行绑定
6、通过apply进行逻辑判断，true就是匹配成功，false匹配失败

自定义路由工厂

-checkAuth=zzq，如果配置文件中checkAuth=zzq，则匹配通过，否则匹配失败

  • 配置文件
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
            - Query=id,\d+
            - CheckAuth=zzq
  • 自定义代码
@Component
public class CheckAuthRoutePredicateFactory extends AbstractRoutePredicateFactory<CheckAuthRoutePredicateFactory.Config> {


    public CheckAuthRoutePredicateFactory() {
        super(CheckAuthRoutePredicateFactory.Config.class);
    }

    /**
     * 绑定配置信息
     * @return
     */
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("name");
    }

    public Predicate<ServerWebExchange> apply(Config config) {
        return new GatewayPredicate() {
            @Override
            public boolean test(ServerWebExchange exchange) {
                if (config.getName().equals("zzq")){
                    return true;
                }
                return false;
            }
        };
    }

    /**
     * 用于接收配置文件中 断言的信息
     */
    @Validated
    @Data
    public static class Config {
        private String name;
    }
}
  • 测试
    在这里插入图片描述
  • 修改配置后
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
            - Query=id,\d+
            - CheckAuth=qwee
  • 测试
    在这里插入图片描述

内置/自定义过滤器

gateway内置了很多的过滤器工厂，我们通过一些过滤器工厂可以进行一些业务逻辑处理器，添加去除参数等。
在这里插入图片描述

典型内置过滤器

  • 添加请求头
  • AddRequestHeader=X-Request-color,red #添加请求头
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
            - Query=id,\d+
            - CheckAuth=zzq
          filters:
            - AddRequestHeader=X-Request-color,red #添加请求头
  • 为匹配的路由添加统一前缀
    在这里插入图片描述
  • PrefixPath=/shanghaiserver #添加前缀 对应微服务需要配置context-path
  • order.yml配置context-path
server:
  port: 8081
  servlet:
    context-path: /shanghaiserver
  • gateway为了适配添加前缀
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
            - Query=id,\d+
            - CheckAuth=zzq
          filters:
            - AddRequestHeader=X-Request-color,red #添加请求头
            - PrefixPath=/shanghaiserver  #添加前缀  对应微服务需要配置context-path

自定义过滤器

继承AbstractGatewayFilterFactory且自定义类的名称必须以GatewayFilterFactory结尾，且必须交给spring进行管理

  • 自定义过滤器
package com.springcloudalibaba.gateway.config;

import com.alibaba.nacos.api.utils.StringUtils;
import lombok.Data;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.Arrays;
import java.util.List;

/**
 * @author : zhouzhiqiang
 * @date : 2024/6/19 12:51
 * @description :
 */
@Component
public class CheckParamGatewayFilterFactory extends AbstractGatewayFilterFactory<CheckParamGatewayFilterFactory.Config> {

    public CheckParamGatewayFilterFactory() {
        super(CheckParamGatewayFilterFactory.Config.class);
    }

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("name");
    }

    @Override
    public GatewayFilter apply(Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                String name = exchange.getRequest().getQueryParams().getFirst("name");
                if (!StringUtils.isBlank(name)) {
                    //如果相等请求被放过
                    if (config.getName().equals(name)) {
                        return chain.filter(exchange);
                    } else {
                        //如果不相等返回404
                        exchange.getResponse().setStatusCode(HttpStatus.NOT_FOUND);
                        return exchange.getResponse().setComplete();
                    }
                }
                return chain.filter(exchange);
            }
        };
    }

    /**
     * 用于接收配置文件中 过滤器的信息
     */
    @Validated
    @Data
    public static class Config {
        private String name;
    }
}
  • 配置自定义的过滤器工厂
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
            - Query=id,\d+
            - CheckAuth=zzq
          filters:
            - AddRequestHeader=X-Request-color,red #添加请求头
            - PrefixPath=/shanghaiserver  #添加前缀  对应微服务需要配置context-path
            - CheckParam=zzq
  • 测试
  • 成功
    在这里插入图片描述
  • 失败
    在这里插入图片描述

全局过滤器

对比局部过滤器，全局过滤器会对所有的路由请求进行过滤
局部：局部针对某个路由，需要在路由中进行配置
全局：针对所有路由，一旦定义了就会投入使用
在这里插入图片描述

自定义全局过滤器

@Component
public class LogFilter implements GlobalFilter {
    Logger log = LoggerFactory.getLogger(this.getClass());

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("请求地址：{}", exchange.getRequest().getPath().value());
        return chain.filter(exchange);
    }
}

此时gateway会拦截所有的请求并打印出请求地址

请求日志记录&跨域处理

要启用Reactor Netty访问日志，请设置-Dreactor.netty.http.server.accessLogEnabled=true
它必须是Java系统属性，而不是Spring Boot属性
在这里插入图片描述

  • 配置文件
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
            - Query=id,\d+
            - CheckAuth=zzq
          filters:
            - AddRequestHeader=X-Request-color,red #添加请求头
            - PrefixPath=/shanghaiserver  #添加前缀  对应微服务需要配置context-path
            - CheckParam=zzq
logging:
  file:
    name: D:/logs/service.log
    max-size: 500MB
  • 测试
    此时日志会被记录到：D:\logs\service.log
    在这里插入图片描述

Gateway跨域配置（CORS Configration）

  • 配置文件
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Header=X-Request-Id,\d+
            - Method=GET
            - Query=id,\d+
            - CheckAuth=zzq
          filters:
            - AddRequestHeader=X-Request-color,red #添加请求头
            - PrefixPath=/shanghaiserver  #添加前缀  对应微服务需要配置context-path
            - CheckParam=zzq
      globalcors:
        cors-configurations:
          '[/**]': #允许跨域访问的资源
          allowedOrigins: "*" #跨域允许的来源
          allowedMethods:
            - GET
            - POST
logging:
  file:
    name: D:/logs/service.log
    max-size: 500MB
  • 在springboot中还可以通过配置类的方式进行配置
@Configuration
public class CorsFilter {

    @Bean
    public CorsWebFilter corsWebFilter(){
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOrigin("*"); //允许的来源
        config.addAllowedHeader("*"); //允许的请求头
        config.addAllowedMethod("*"); //允许的请求方法

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**",config);

        return new CorsWebFilter(source);
    }
}

gateway整合sentinel流控降级

网关作为内部系统外的一层屏障，对内起到一定的保护作用，限流就是其中之一。网关层的限流可以简单地针对不同路由进行限流，也可针对业务的接口进行限流，或者根据接口的特征分组限流。

  • 添加依赖
        <!--gateway整合sentinel进行限流-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
        </dependency>
  • 添加配置
#第一版
server:
  port: 8090
# gateway配置
spring:
  application:
    name: api-gateway
  cloud:
    #nacos配置
    nacos:
      discovery:
        server-addr: 192.168.184.15:8848
        username: nacos
        password: nacos
    #gateway配置
    gateway:
      #路由规则
      routes:
        - id: order_router #路由的唯一标识,路由到order
          uri: http://localhost:8081 #需要转发的地址
          #断言规则 用于路由规则的匹配
          predicates:
            - Path=/order/**
            - After=2023-12-31T23:59:59.789+08:00[Asia/Shanghai]
            - Method=GET
          filters:
            - PrefixPath=/shanghaiserver  #添加前缀  对应微服务需要配置context-path
    # 整合sentinel
    sentinel:
      transport:
        dashboard: 192.168.184.15:8080
logging:
  file:
    name: D:/logs/service.log
    max-size: 500MB
  • 测试代码
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private IStockService stockService;

    @RequestMapping("/buyProduct")
    public String buyProduct(@RequestHeader("X-Request-color") String color){
        System.out.println("开始下单");
        System.out.println(color);
        //开始扣减库存
        stockService.detectStock();
        return "下单并扣除库存成功";
    }

    /**
     * QPS流控规则测试
     * @return
     */
    @RequestMapping("/flow")
    public String flow(){
        return "正常访问";
    }

    /**
     * 并发线程数流控规则测试
     * @return
     */
    @RequestMapping("/flowThread")
    public String flowThread(){
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return "正常访问";
    }

}
  • 启动dashboard
    请求接口进行测试：
    在这里插入图片描述

设置dashboard流控规则进行测试

  • QPS测试
  • dashboard配置
    在这里插入图片描述
  • 测试结果
    在这里插入图片描述

gateway整合sentinel流控降级详细配置

通过请求属性就和之前配置的断言一样
在这里插入图片描述

  • 案例测试–比如URL参数设置为name=zzq
    在这里插入图片描述
  • 测试
    此时限流
    在这里插入图片描述
  • 案例测试–比如把Header设置为X-Request-Id=zzq
    在这里插入图片描述
  • 测试结果
    此时限流
    在这里插入图片描述

还可以根据api分组对不同的api接口进行流控

  • 添加api分组
    在这里插入图片描述
  • 配置api流控
    在这里插入图片描述
  • 测试
    在这里插入图片描述

自定义流控异常

@Configuration
public class GateWayExceptionConfig {

    @PostConstruct
    public void sentinelResponse(){
        BlockRequestHandler requestHandler = new BlockRequestHandler() {
            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
                //自定义异常
                Map<String,String> exMap=new HashMap<>();
                exMap.put("code", HttpStatus.TOO_MANY_REQUESTS.toString());
                exMap.put("msg","限流了");

                return ServerResponse.status(HttpStatus.OK)
                        .contentType(MediaType.APPLICATION_JSON)
                        .body(BodyInserters.fromValue(exMap));
            }
        };
        GatewayCallbackManager.setBlockHandler(requestHandler);
    }
}
  • 测试
    在这里插入图片描述
极乐码农
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud Alibaba【微服务分布式组件---Gateway】
Vinjcent
06-01 1005
当设计多个微服务之后，会出现诸多的问题：上面的这些问题我们可以通过 网关来解决所谓的 API 网关，就是指系统的统一入口，它封装了应用程序的内部结构，为客户端提供统一服务，一些与业务本身功能无关的公共逻辑可以在这里实现，诸如认证、授权、监控、路由转发等等网关作为流量入口，常用的功能包括路由转发、权限校验、限流等SpringCloud Gateway 是 SpringCloud 官方推出的第二代网关框架，定位于取代 Neflix Zuul。相比 Zuul 来说，SpringCloud Gateway 提供更
SpringCloudAlibaba-Gateway
qq_47815451的博客
08-12 1577
Gateway Gateway简介 底层使用Netty框架，性能大于Zuul 配置gateway模块，一般使用yaml格式： server: port: 80 #spring boot actuator服务监控端点 management: endpoint: health: show-details: always endpoints: jmx: exposure: include: '*' web: expos
SpringCloudAlibaba - 新一代服务网关Gateway
AkiraNicky的博客
01-24 9812
什么是微服务网关 微服务网关是整个微服务API请求的入口，可以实现日志拦截、权限控制、解决跨域问题、限流、熔断、负载均衡、黑名单与白名单拦截、授权等。 过滤器与网关的区别 过滤器用于拦截单个服务 网关拦截整个的微服务 Zuul与Gateway有哪些区别 Zuul网关属于netfix公司开源的产品属于第一代微服务网关 Gateway属于SpringCloud自研发的第二代微服务网关 ...
分布式微服务 SpringCloud Alibaba 中 Gateway 网关 组件搭建
First_llh的博客
03-01 1009
子项目结构图 导入Gateway所需要的jar包 编写Application.yaml配置文件 断言 路由 过滤器 编写Application.yaml配置文件
SpringCloud Alibaba微服务分布式架构组件演变
Zyw907155124的博客
07-12 1756
SpringCloud Alibaba：1、服务注册中心：Eureka、Zookeeper、Consul、Nacos；2、服务调用：Ribbon、LoadBalancer、Feign、OpenFeign；3、服务降级：Hystrix、Resilience4j、Sentinel；4、服务网关：Zuul、Gateway；5、服务配置：Config、Nacos；6、服务总线：Bus、Nacos；6、分布式事务解决方案：seata
SpringCloudAlibaba集成Gateway动态路由Nacos服务
weixin_45678031的博客
06-20 875
官方git：https://github.com/spring-cloud/spring-cloud-gateway Spring Cloud Gateway网关是用来代替zuul1.x作为微服务架构中的网关组件，zuul1.x是最早的网关组件，由于使用单线程阻塞式链接，所以性能有问题，gateway是搭建在webflux框架之上的响应式网关服务，底层使用Netty框架作为通讯框架。zuul2.x也使用了Netty。性能上gateway是zuul1.x的1.5~2倍，与zuul2.x相当。 我们使用的是sp
SpringCloudAlibaba常用组件
xiao-啸
09-01 7052
nacos ribbon feign sentinel gateway sleuth&zpkin 等相关组件的操作以及使用
SpringCloudAlibaba分布式组件
Java基础代码
08-24 748
分布式组件-SpringCloud Alibaba 文章目录分布式组件-SpringCloud Alibaba20.简介21.Nacos注册中心22.OpenFeign远程调用23.配置中心-简单实例24.配置中心-命名空间25.配置中心-加载多配置集26.Gateway网关核心27.Gateway创建测试网关 20.简介 SpringCloudAlibaba的优势： 阿里使用过的组件经历了考验，性能强悍，设计合理，现在开源出来大家用成套的产品搭配完善的可视化界面给开发运维带来了极大的便利，搭建简单，学
读书笔记-SpringCloudAlibaba微服务原理与实战-谭锋-【未完待续】
u011225581的专栏
03-19 1481
SpringCloudAlibaba微服务原理与实战 谭锋 电子工业出版社 ISBN-9787121388248 仅供参考, 自建索引, 以备后查 一、应用架构演进、微服务发展史 二、SpringCloud简介 三、SpringBoot、自动装配、自定义Starter 四、ZooKeeper、Dubbo （Dubbo、Apache Dubbo、Dubbo S...
Plumelog分布式日志组件-其他
06-11
Plumelog一个简单易用的java分布式日志组件。支持百亿级别，日志从搜集到查询，不用去文件中翻阅日志方便快捷，支持查询一个调用链的日志，支持链路追踪，查看调用链耗时情况，在分布式系统中也可以查询关联日志，...
springcloudalibaba-seata-nacos-sentinel.zip
01-29
SpringCloud Alibaba Seata、Nacos和Sentinel这三大组件，恰好为这些问题提供了强大的解决方案。本文将深入探讨它们的功能、原理以及如何在实际项目中进行深度整合。 Seata（Simple Extensible Autonomous ...
SpringCloudAlibaba分布式流量控制组件Sentinel实战与源码分析-中.doc
07-08
SpringCloudAlibaba 分布式流量控制组件 Sentinel 实战与源码分析 Sentinel 是一个轻量级的流量控制组件，用于保护微服务架构中的各个组件免受瞬时流量洪峰的攻击。 Sentinel 的主要功能包括流量控制、熔断降级、...
分布式消息中间件-Rocketmq
02-24
本文来自于csdn，文章分享了分布式消息中间件，主要基于JMS规范、Rocketmq的介绍、部署方式、特性的一些使用几大模块阐述。今天要给大家分享的是分布式消息中间件。消息中间件主要是实现分布式系统中解耦、异步消息...
Downloads_分布式_WebCollect-Hadoop_
09-29
支持hadoop分布式爬虫，mapreduce编程模式
hadoop 3.X 分布式HA集成Kerbos(保姆级教程）
最新发布
guofei_ok的博客
06-30 802
前提：先安装Kerbos。
SpringCloud分布式微服务链路追踪方案：Skywalking
lucky_fd的博客
06-27 1062
SkyWalking架构设计整个架构，分成上、下、左、右四部分：考虑到让描述更简单，我们舍弃掉 Metric 指标相关，而着重在 Tracing 链路相关功能。上部分 Agent ：负责从应用中，收集链路信息，发送给 SkyWalking OAP 服务器。目前支持 SkyWalking、Zikpin、Jaeger 等提供的 Tracing 数据信息。而我们目前采用的是，SkyWalking Agent 收集 SkyWalking Tracing 数据，传递给服务器。
gbase 8c分布式升级步骤
style_boy的博客
06-27 330
gbase 8c 300升级
使用容器配置文件构建任意应用镜像_并将应用镜像推送到公共仓库共享_应用分享与启动---分布式云原生部署架构搭建012
添柴程序猿的专栏
06-27 209
ENTRYPOINT ["java","-jar","java-demo-0.0.1-SHAPSHOT.jar"] 这个是入口,就是执行java -jar 后面加上jar包的名称,当然,因为我们这里。COPY target/*.jar /app.jar 将target目录下的所有jar包,都复制,成app.jar名字,然后。ENTRYPOINT ["java","-jar","app.jar"] 就可以了。以前是这样做的,不方便,因为需要在服务器上,安装jdk什么的,现在有了。
机器学习分布式线K-Mean算法
05-12
K-Means算法是一种聚类算法，它的目的是将一组数据划分成k个簇，每个簇包含距离最近的k个点。分布式K-Means算法是将K-Means算法应用于分布式环境中，以提高计算效率和处理大规模数据集的能力。 分布式K-Means算法基于MapReduce框架实现，它将数据集分成多个部分，每个部分由不同的机器处理，最终结果由一个中央节点进行汇总。在分布式K-Means算法中，每个机器都维护一个簇的中心点，然后计算每个数据点与中心点的距离，并将数据点分配给最近的簇。接着，每个机器都将分配给它的数据点的平均值计算出来，更新簇的中心点。这个过程迭代进行，直到簇的中心点不再发生变化或达到预定的迭代次数。 分布式K-Means算法可以处理大规模数据集，而且可以在多个计算节点上并行执行，从而提高计算效率。但是，它也存在一些问题，如处理不平衡的数据集时可能会导致计算负载不均衡，从而影响算法的性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值