gateway

已于 2023-03-15 09:46:17 修改
阅读量63 收藏
点赞数
分类专栏： Java 文章标签： gateway java 开发语言
于 2022-10-13 16:28:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48829840/article/details/127303906
版权

1：实现gateway动态路由

配置文件

server:
  port: 9001
  servlet:
    context-path: /imooc

spring:
  application:
    name: e-commerce-gateway
  cloud:
    nacos:
      discovery:
        enabled: true # 如果不想使用 Nacos 进行服务注册和发现, 设置为 false 即可
        server-addr: 192.168.5.253:8848 # Nacos 服务器地址
        namespace: d8fa475f-a1df-4cd3-acbf-e9d6df0ca59f
        metadata:
          management:
            context-path: ${server.servlet.context-path}/actuator
    # 静态路由，本项目使用的是动态路由
  #    gateway:
  #      routes:
  #        - id: path_route # 路由的ID
  #          uri: 127.0.0.1:8080/user/{id} # 匹配后路由地址
  #          predicates: # 断言, 路径相匹配的进行路由
  #            - Path=/user/{id}
    kafka:
      bootstrap-servers: 192.168.5.253:9092
      producer:
        retries: 3
      consumer:
        auto-offset-reset: latest
  #  zipkin:
  #    sender:
  #      type: kafka # 默认是 web
  #    base-url: http://localhost:9411/
  main:
    allow-bean-definition-overriding: true  # 因为将来会引入很多依赖, 难免有重名的 bean

# 这个地方独立配置, 是网关的数据, 代码 GatewayConfig.java 中读取被监听
nacos:
  gateway:
    route:
      config:
        data-id: e-commerce-gateway-router
        group: e-commerce

# 暴露端点
management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always

gateway配置类

/**
 * ProjectName xyc-commerce-springcloud
 * 读取nacos相关的配置项，用户配置监听器
 * @author xieyucan
 * <br>CreateDate 2022/9/5 13:50
 */
@Configuration
public class GatewayConfig {


    /**
     * 获取读取超时时间
     */
    public static final long DEFAULT_TIMEOUT=30000;

    /**
     * 服务器地址
     */
    public static String NACOS_SERVER_ADDR;

    /**
     * 命名空间
     */
    public static String NACOS_NAMESPACE;

    /**
     * data_id
     */
    public static String NACOS_ROUTE_DATA_ID;

    /**
     * nacos分组id
     */
    public static String NACOS_GROUP_ID;


    /**
     * 这里的意思是，将@Value("${spring.cloud.nacos.discovery.server-addr}") 赋值给nacosServerAddr
     * 然后 NACOS_SERVER_ADDR=nacosServerAddr;
     * @param nacosServerAddr
     */
    @Value("${spring.cloud.nacos.discovery.server-addr}")
    public void setNacosServerAddr(String nacosServerAddr)
    {
        NACOS_SERVER_ADDR=nacosServerAddr;
    }


    @Value("${spring.cloud.nacos.discovery.namespace}")
    public void setNacosNamespace(String nacosNamespace)
    {
        NACOS_NAMESPACE=nacosNamespace;
    }


    @Value("${nacos.gateway.route.config.group}")
    public void setNacosGroupId(String groupId)
    {
        NACOS_GROUP_ID=groupId;
    }


    @Value("${nacos.gateway.route.config.data-id}")
    public void setNacosRouteDataId(String dataId)
    {
        NACOS_ROUTE_DATA_ID=dataId;
    }
}

实现事件推送aware：动态更新路由网关 Service

/**
 * ProjectName xyc-commerce-springcloud
 * 实现事件推送aware：动态更新路由网关 Service
 * @author xieyucan
 * <br>CreateDate 2022/9/5 14:05
 */
@Slf4j
@Service
@SuppressWarnings("all")
public class DynamicRouteServiceImpl implements ApplicationEventPublisherAware {

    /**
     * 写路由定义 （gateway提供的bean）
     */
    private final RouteDefinitionWriter routeDefinitionWriter;

    /**
     * 获取路由定义 （gateway提供的bean）
     */
    private final RouteDefinitionLocator routeDefinitionLocator;

    /**
     * 事件发布对象
     */
    private ApplicationEventPublisher publisher;

    public DynamicRouteServiceImpl(RouteDefinitionWriter routeDefinitionWriter, 
    RouteDefinitionLocator routeDefinitionLocator) {
        this.routeDefinitionWriter = routeDefinitionWriter;
        this.routeDefinitionLocator = routeDefinitionLocator;
    }

    @Override
    public void setApplicationEventPublisher(
    ApplicationEventPublisher applicationEventPublisher) {
        //完成事件推送句柄初始化
        this.publisher=applicationEventPublisher;
    }


    /**
     * 增加路由定义
     * @param routeDefinition
     * @return
     */
    public String addRouteDefinition(RouteDefinition routeDefinition)
    {
        log.info("gateway add route:[{}]",routeDefinition);
        //保存路由配置并且发布出去
        routeDefinitionWriter.save(Mono.just(routeDefinition)).subscribe();
        //发布事件通知给gateway，同步新增的路由定义
        this.publisher.publishEvent(new RefreshRoutesEvent(this));

        return "success";
    }

    /**
     * 更新多个路由配置
     * @param definitionList
     * @return
     */
    public String updateList(List<RouteDefinition> definitionList)
    {
        log.info("gateway update route:[{}]",definitionList);
        //拿到当前gateway中存储的定义
        List<RouteDefinition> routeDefinitionsExits =
                routeDefinitionLocator.getRouteDefinitions().buffer().blockFirst();
        if(!CollectionUtil.isEmpty(routeDefinitionsExits))
        {
            //清除掉之前所有旧的路由定义
            routeDefinitionsExits.forEach(rd->{
                log.info("delete route definition:[{}]",rd);
                deleteById(rd.getId());
            });
        }
        //把更新的路由定义同步到gateway中
        definitionList.forEach(definition->updateByRouteDefinition(definition));
        return "success";
    }

    /**
     * 根据路由id去删除路由配置
     * @param id
     * @return
     */
    private String deleteById(String id)
    {
        try {
            log.info("gateway delete route id:[{}]",id);
            this.routeDefinitionWriter.delete(Mono.just(id)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));

            return "delete success";
        }catch (Exception ex){
            log.error("gateway delete route fail:[{}]",ex.getMessage(),ex);
            return "delete fail";
        }
    }


    /**
     * 更新路由
     * @param routeDefinition
     * 更新的实现策略：删除+新增=更新
     * @return
     */
    private String updateByRouteDefinition(RouteDefinition routeDefinition)
    {
        try {
            log.info("gateway update route:[{}]",routeDefinition);
            this.routeDefinitionWriter.delete(Mono.just(routeDefinition.getId()));
        }catch (Exception ex){
            return "update fail,not find routed"+routeDefinition.getId();
        }

        try {
            this.routeDefinitionWriter.save(Mono.just(routeDefinition)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));

            return "success";
        }catch (Exception ex){
            return "update route fail";
        }
    }
}

通过nacos下发动态路由配置，监听nacos中路由配置变更

/**
 * ProjectName xyc-commerce-springcloud
 * 通过nacos下发动态路由配置，监听nacos中路由配置变更
 * @author xieyucan
 * <br>CreateDate 2022/9/5 15:02
 */

@Slf4j
@Component
@DependsOn({"gatewayConfig"})
public class DynamicRouteServiceImplByNacos {

    /**
     * nacos 配置服务
     */
    private ConfigService configService;

    private final DynamicRouteServiceImpl dynamicRouteService;

    public DynamicRouteServiceImplByNacos(DynamicRouteServiceImpl dynamicRouteService) {
        this.dynamicRouteService = dynamicRouteService;
    }


    /**
     * bean 在容器中构造完成之后会执行init方法
     */
    @PostConstruct
    public void init()
    {
        log.info("gateway route init");

        try {
            //初始化nacos配置客户端
            configService=initConfigService();
            if(configService==null)
            {
                log.error("init config service fail");
                return;
            }
            //通过nacos config并且知道路由配置路径去获取路由配置
            String configInfo=configService.getConfig(GatewayConfig.NACOS_ROUTE_DATA_ID,
                    GatewayConfig.NACOS_GROUP_ID,
                    GatewayConfig.DEFAULT_TIMEOUT);
            log.info("get current gateway config:[{}]",configInfo);
            List<RouteDefinition> routeDefinitions = 
            JSON.parseArray(configInfo, RouteDefinition.class);
            if(CollectionUtil.isNotEmpty(routeDefinitions))
            {
                for(RouteDefinition routeDefinition:routeDefinitions)
                {
                    log.info("init gateway config:[{}]",routeDefinition.toString());
                    dynamicRouteService.addRouteDefinition(routeDefinition);
                }
            }
        }catch (Exception e){
            log.error("gateway route init has some error:[{}]",e.getMessage(),e);
        }
        //添加一个监听器
        dynamicRouteByNacosListener(GatewayConfig.NACOS_ROUTE_DATA_ID,
        GatewayConfig.NACOS_GROUP_ID);
    }

    /**
     * 初始化nacosconfig，初始化之后才可以使用
     * @return
     */
    private ConfigService initConfigService()
    {
        try {
            Properties properties = new Properties();
            properties.setProperty("serverAddr",GatewayConfig.NACOS_SERVER_ADDR);
            properties.setProperty("namespace",GatewayConfig.NACOS_NAMESPACE);
            return configService= NacosFactory.createConfigService(properties);
        } catch (Exception e) {
            log.error("init gateway nacos config error:[{}]",e.getMessage(),e);
            return null;
        }
    }

    /**
     * 实现对nacos的监听，nacos下发的动态路由信息
     * @param dataId
     * @param group
     */
    private void dynamicRouteByNacosListener(String dataId,String group)
    {
        try {

            //给nacos config 客户端增加一个监听器
            configService.addListener(dataId, group, new Listener() {
                /**
                 * 提供线程池执行操作  return null;表示默认线程池
                 * @return
                 */
                @Override
                public Executor getExecutor() {
                    return null;
                }

                /**
                 * 监听器受到配置中心的配置更新
                 * nacos 中最新的配置定义
                 * @param configInfo  配置本来就是String类型，所以，我们需要将其转换为数组对象
                 */
                @Override
                public void receiveConfigInfo(String configInfo) {
                    log.info("start to update config:[{}]",configInfo);
                    List<RouteDefinition> routeDefinitions = JSON.parseArray(configInfo, 
                    RouteDefinition.class);
                    log.info("update route:[{}]",routeDefinitions.toString());
                    dynamicRouteService.updateList(routeDefinitions);
                }
            });
        }catch (NacosException ex){
            log.error("dynamic update gateway config error:[{}]",ex.getErrCode(),ex);
        }
    }
}

2：gateway路由配置（局部过滤器）

[
  {
    "id": "e-commerce-nacos-client",
    "predicates": [
      {
        "args": {
          "pattern": "/imooc/ecommerce-nacos-client/**"
        },
        "name": "Path"
      }
    ],
    "uri": "lb://e-commerce-nacos-client",
     //局部过滤器的用法，也就是需要在网关中声明
    "filters": [
      {
        "name": "HeaderToken"
      },
      {
        "name": "StripPrefix",
        "args": {
          "parts": "1"
        }
      }
    ]
  },
  {
  "id": "e-commerce-account-service",
  "predicates": [
    {
      "args": {
        "pattern": "/imooc/ecommerce-account-service/**"
      },
      "name": "Path"
    }
  ],
  "uri": "lb://e-commerce-account-service",
  "filters": [
    {
      "name": "StripPrefix",
      "args": {
        "parts": "1"
      }
    }
  ]
},
  {
    "id": "e-commerce-goods-service",
    "predicates": [
      {
        "args": {
          "pattern": "/imooc/ecommerce-goods-service/**"
        },
        "name": "Path"
      }
    ],
    "uri": "lb://e-commerce-goods-service",
    "filters": [
      {
        "name": "StripPrefix",
        "args": {
          "parts": "1"
        }
      }
    ]
  }
]

3：全局过滤器和局部过滤器

局部过滤器的使用（需要在网关配置类中声明，详细看第二点）

局部过滤器

/**
 * ProjectName xyc-commerce-springcloud
 * 请求头部携带token验证过滤器
 * @author xieyucan
 * <br>CreateDate 2022/9/6 9:08
 */
public class HeaderTokenGatewayFilter implements GatewayFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //从http header中寻找key为token，value为imooc的键值对  （这里采用两个token，第一个为假的伪造token）
        String name=exchange.getRequest().getHeaders().getFirst("token");
        if("imooc".equals(name))
        {
           return chain.filter(exchange);
        }
        //标记此次请求没有权限，并结束这次请求
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        return exchange.getResponse().setComplete();
    }

    @Override
    public int getOrder() {
        return HIGHEST_PRECEDENCE+2;
    }
}

局部过滤器工厂

/**
 * ProjectName xyc-commerce-springcloud
 * 让局部过滤器生效
 * 实现局部过滤器步骤：
 * 1：局部过滤器要实现 GatewayFilter, Ordered 相应方法
 * 2：实现抽象过滤器工厂
 * 3：在配置文件中配置  写GatewayFilterFactory 前面的即可，
 * 也就是 HeaderToken（不配置表示当前局部过滤器不生效）
 * @author xieyucan
 * <br>CreateDate 2022/9/6 9:22
 */
@Component
public class HeaderTokenGatewayFilterFactory 
    extends AbstractGatewayFilterFactory<Object> {

    @Override
    public GatewayFilter apply(Object config) {
        return new HeaderTokenGatewayFilter();
    }
}

全局过滤器(实现GlobalFilter, Ordered接口声明为@Component即可)

/**
 * ProjectName xyc-commerce-springcloud
 * 全局登录鉴权过滤器
 * @author xieyucan
 * <br>CreateDate 2022/9/6 10:26
 */
@Slf4j
@Component
public class GlobalLoginOrRegisterFilter implements GlobalFilter, Ordered {

    /**
     * 注册中心客户端，可以从注册中心中获取服务实例信息
     */
    private final LoadBalancerClient loadBalancerClient;

    private final RestTemplate restTemplate;

    public GlobalLoginOrRegisterFilter(LoadBalancerClient loadBalancerClient
                                       , RestTemplate restTemplate) {
        this.loadBalancerClient = loadBalancerClient;
        this.restTemplate = restTemplate;
    }

    /**
     * 登录、注册、鉴权
     * 1:如果是登录注册，则去授权中心拿token，返回给客户端
     * 2：如果是服务其他服务，则鉴权，没有权限返回401
     * @param exchange
     * @param chain
     * @return
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        // 如果是登录
        if(request.getURI().getPath().contains(GatewayConstant.LOGIN_URI))
        {
            //去授权中心获取token
            String token = getTokenAuthorityCenter(request, 
                           GatewayConstant.AUTHORITY_CENTER_TOKEN_FORMAT);

            //header 中不能设置为null
            response.getHeaders().
                add(CommonConstant.JWT_USER_INFO_KEY,token==null?"null":token);
            response.setStatusCode(HttpStatus.OK);
            return response.setComplete();
        }
        //如果是注册
        if(request.getURI().getPath().contains(GatewayConstant.REGISTER_URI))
        {
            //去授权中心拿token，先创建用户，再返回token
            String token = getTokenAuthorityCenter(request, 
            GatewayConstant.AUTHORITY_CENTER_REGISTER_FORMAT);
            response.getHeaders()
                .add(CommonConstant.JWT_USER_INFO_KEY,token==null?"null":token);
            response.setStatusCode(HttpStatus.OK);
        }


        //访问其他服务，则鉴权、校验是否能够从token中解析用户信息
        String token=request.getHeaders().getFirst(CommonConstant.JWT_USER_INFO_KEY);
        LoginUserInfo loginUserInfo=null;
        try {
            //解析token
            loginUserInfo= TokenParseUtil.parseUserInfoFromToken(token);
        }catch (Exception ex){
            log.error("parse user info from token error:[{}]",ex.getMessage(),ex);
        }
        //从token获取不到用户登录信息 返回401
        if(loginUserInfo==null)
        {
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        //解析通过则放行
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return HIGHEST_PRECEDENCE+2;
    }


    /**
     * 从post请求中获取到请求数据
     * @param request
     * @return
     */
    private String parseBodyFromRequest(ServerHttpRequest request)
    {
        //获取请求头
        Flux<DataBuffer> body=request.getBody();
        AtomicReference<String> bodyRef = new AtomicReference<>();

        //订阅缓冲区去消费请求体中的数据
        body.subscribe(buffer->{
            CharBuffer charBuffer = 
                StandardCharsets.UTF_8.decode(buffer.asByteBuffer());
            //释放之前缓存的数据，否则会出现内存泄漏
            DataBufferUtils.release(buffer);
            bodyRef.set(charBuffer.toString());
        });
        //获取 request body
        return bodyRef.get();
    }


    /**
     * 从授权中心获取token
     * @param request
     * @param uriFormat
     * @return
     */
    private String getTokenAuthorityCenter(ServerHttpRequest request,String uriFormat)
    {
        /**
         * service id就是服务名称，这里实现了负载均衡
         */
        ServiceInstance instance = loadBalancerClient
            .choose(CommonConstant.AUTHORITY_CENTER_SERVICE_ID);
        log.info("nacos client info:[{}],[{}],[{]]",
                instance.getServiceId(),
                instance.getInstanceId(),
                instance.getMetadata());

        String requestUrl=String.format(uriFormat,instance.getHost()
                                        ,instance.getPort());

        UsernameAndPassword usernameAndPassword=JSON.parseObject(
            parseBodyFromRequest(request),
            UsernameAndPassword.class);

        log.info("login request url and body:[{}],[{}]",requestUrl,
                 JSON.toJSONString(usernameAndPassword));

        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
        JwtToken token = restTemplate.postForObject(
                requestUrl,
                new HttpEntity<>(JSON.toJSONString(usernameAndPassword), httpHeaders),
                JwtToken.class);
        if(null!=token)
        {
            return token.getToken();
        }
        return null;
    }
}
谢钰灿
关注
专栏目录
Eureka上集成Spring Cloud 微服务网关 gateway
Java 技术专栏，从入门到精通，熟悉企业级开发
10-06 3万+
API 网关是一个搭建在客户端和微服务之间的服务，我们可以在 API 网关中处理一些非业务功能的逻辑，例如权限验证、监控、缓存、请求路由等。基于上一章节的内容，已经集成了Spring Cloud Netflix微服务组件。其中服务发现、注册组件：Eureka，服务远程调用、负载均衡组件：OpenFeign。本章节在DNS、Nginx层之后加入网关层，通过Nginx + GateWay 去访问服务。网关层可以做路由、限流、权限验证、请求过滤等操作。
SpringCloud.03.网关Gateway 配置文件
01-09
在Spring Cloud生态体系中，Spring Cloud Gateway作为新一代的API网关，被广泛应用于微服务架构中，用于统一处理请求路由、过滤器链、限流、熔断等核心功能。本篇将详细介绍Spring Cloud Gateway的配置文件相关知识...
Gateway
Flying_Fish_roe的博客
07-29 1726
Spring Cloud Gateway是一个基于Spring Boot的API网关，它提供了一种简单且有效的方式来路由请求、过滤请求和转发请求。轻量级：Spring Cloud Gateway使用了异步非阻塞的方式处理请求，使其具有较高的性能和较低的资源消耗。灵活的路由：Spring Cloud Gateway支持基于请求路径、请求头、请求参数等条件来进行路由，使其具有较强的灵活性。
gateway基本配置
Weirdo的博客
04-22 1509
Gateway是一个API网关，它提供了API的统一管理，是系统的唯一入口。API网关负责请求路由、安全认证、限流熔断、监控追踪等核心功能。在微服务架构中，Gateway通常作为前端调用后端服务的桥梁，实现了服务之间的解耦和统一管理。本文详细介绍了Gateway的基本配置，包括路由配置、过滤器配置、限流配置以及监控与日志等方面。通过合理的配置和使用Gateway，可以帮助开发者构建稳定、高效、安全的微服务架构。当然，Gateway的配置和使用还涉及更多高级功能和技巧，需要开发者在实际应用中不断探索和学习。
Spring cloud gateway 详解和配置使用（文章较长）
荡漾
11-08 20万+
目录 spring cloud gateway 介绍 1. 网关是怎么演化来的 2. 网关的基本功能 3.关于Spring Cloud Gateway 4.Spring Cloud Gateway 功能特征 5.predicate简介 6.GatewayFilter 工厂介绍 7.集成Hystrix的断路器功能 8.请求限流 pom.xml application.ym...
Gateway网关简介及使用
热门推荐
AlgoRain的博客
10-09 28万+
Gateway网关简介及使用 1. 什么是 API 网关（API Gateway） 分布式服务架构、微服务架构与 API 网关 在微服务架构里，服务的粒度被进一步细分，各个业务服务可以被独立的设计、开发、测试、部署和管理。这时，各个独立部署单元可以用不同的开发测试团队维护，可以使用不同的编程语言和技术平台进行设计，这就要求必须使用一种语言和平 台无关的服务协议作为各个单元间的通讯方式。 AP...
Nginx与Gateway
zj的博客
06-12 1328
nignx与gateway特点，相同与不同
GateWay原理
xingxinggua9620的博客
01-29 5668
1. 网关Gateway的基本组成 GateWay官网地址 中文官网 Route:路由是GateWay最基础的组件,它包含一个ID,一个目标Url,一些断言集合,一些过滤器集合;如果断言成功的话,路由器就会被匹配 Predicate:输入类型是Spring FrameworkServerWebExchange。这使您可以匹配HTTP请求中的所有内容，例如标头或参数。 Filter:这些是使用特定工厂构造的Spring FrameworkGatewayFilter实例。在这里，您可以在发送下游请求之前或
Gateway网关
Hvitur的博客
05-07 5915
Gateway网关 1.什么是Gateway网关 客户端和服务端中间的一堵墙，可以起到的作用有：请求转发、负载均衡、权限控制等等 Spring Cloud Gateway核心概念 网关提供API全托管服务，丰富的API管理功能，辅助企业管理大规模的API，以降低管理成本和安全风 险，包括协议适配、协议转发、安全策略、防刷、流量、监控日志等贡呢。一般来说网关对外暴露 的URL或者接口信息，我们统称为路由信息。如果研发过网关中间件或者使用过Zuul的人，会知道网关的 核心是Filter以及Filter Chai
GateWay配置
码上红尘仙的博客
11-22 3177
GateWay配置
Gateway网关打印请求日志
lmj3732018的博客
02-21 2753
【代码】Gateway网关打印请求日志。
GATEWAY
03-20
标题中的"GATEWAY"通常指的是网络中的网关，它在计算机网络中扮演着重要的角色，作为不同网络间通信的桥梁。网关可以是路由器、服务器或者其他设备，它们负责转发数据包，使得不同协议或者不同网络段的设备能够相互...
bfw gateway
09-01
bfw gateway / bfw 笔记
gateway_gateway_
10-04
Gateway education tool
springCloud 网关（gateway）配置跨域访问
最新发布
qq_43757153的博客
08-22 123
如果项目是分布式架构，通过网关进行路由转发的，那么项目中如果存在跨域的访问，在每一个项目中单独配置，显示是错误的，我们只需要在网关处进行处理，其它项目都是由网关进行转发的，他们是不会存在跨域访问的（具体为啥，可以查询跨域产生的原因）然后这个是一个挺简单的东西，没啥好说的，写出来的目的是方便以后遇到，可以及时想起这里有一个解决方案，如有更好方法，欢迎留言。将这个文件复制到网关中即可，当然，也可以在网关的配置文件中进行编写，
统一服务入口-Gateway（二）
Romised的博客
08-20 957
Gateway Filter Factories（网关过滤器工厂）、GatewayFilter、GlobalFilter、过滤器执行顺序、自定义GatewayFilter、定义GatewayFilter、配置过滤器、测试、自定义GlobalFilter、定义GlobalFilter、测试。
Prometheus：pushgateway使用
m0_60125201的博客
08-19 894
pushgateway的简单使用
007 SpringCloudAlibaba基础使用(nacos,gateway)
m0_46695127的博客
08-21 418
007 SpringCloudAlibaba基础使用(nacos,gateway)
Spring Cloud Gateway配置路由指南
"本文主要介绍了如何在Spring Cloud Gateway中配置路由，包括通过服务名实现动态路由和指定路径转发路由两种方法。" Spring Cloud Gateway 是一个基于Spring Framework 5和Spring Boot 2设计的API网关，它提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值