Spring Cloud Gateway

于 2024-08-22 17:41:31 发布
阅读量769 收藏 8
点赞数 17
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kersixy/article/details/141433531
版权

1. SpringCloud Gateway 简介

Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。

1.1 网关介绍

在SpringCloud中网关的实现包括两种：

  • gateway：Spring Cloud Gateway属于响应式编程的实现，具备更好的性能，需要Spring Boot和Spring Webflux提供的Netty运行时。它不能在传统的Servlet容器中工作，也不能以WAR的形式构建。

  • zuul：Zuul是基于Servlet的实现，属于阻塞式编程。

1.1.1 SpringCloud Zuul的IO模型

Springcloud中所集成的Zuul版本，采用的是Tomcat容器，使用的是传统的Servlet IO处理模型。

servlet由servlet container进行生命周期管理。container启动时构造servlet对象并调用servlet init()进行初始化；container关闭时调用servlet destory()销毁servlet；container运行时接受请求，并为每个请求分配一个线程（一般从线程池中获取空闲线程）然后调用service()。

弊端：servlet是一个简单的网络IO模型，当请求进入servlet container时，servlet container就会为其绑定一个线程，在并发不高的场景下这种模型是适用的，但是一旦并发上升，线程数量就会上涨，而线程资源代价是昂贵的（上线文切换，内存消耗大）严重影响请求的处理时间。在一些简单的业务场景下，不希望为每个request分配一个线程，只需要1个或几个线程就能应对极大并发的请求，这种业务场景下servlet模型没有优势。

所以Springcloud Zuul 是基于servlet之上的一个阻塞式处理模型，即spring实现了处理所有request请求的一个servlet（DispatcherServlet），并由该servlet阻塞式处理处理。所以Springcloud Zuul无法摆脱servlet模型的弊端。虽然Zuul 2.0开始，使用了Netty，并且已经有了大规模Zuul 2.0集群部署的成熟案例，但是，Springcloud官方已经没有集成改版本的计划了。

1.1.2 Webflux 服务器

Webflux模式替换了旧的Servlet线程模型。用少量的线程处理request和response io操作，这些线程称为Loop线程，而业务交给响应式编程框架处理，响应式编程是非常灵活的，用户可以将业务中阻塞的操作提交到响应式框架的work线程中执行，而不阻塞的操作依然可以在Loop线程中进行处理，大大提高了Loop线程的利用率。

Webflux虽然可以兼容多个底层的通信框架，但是一般情况下，底层使用的还是Netty，毕竟，Netty是目前业界认可的最高性能的通信框架。而Webflux的Loop线程，正好就是著名的Reactor 模式IO处理模型的Reactor线程，如果使用的是高性能的通信框架Netty，这就是Netty的EventLoop线程。

1.2 SpringCloud Gateway 特征

网关的核心功能特性：

  • 请求路由：一切请求都必须先经过gateway，但网关不处理业务，而是根据某种规则，把请求转发到某个微服务，这个过程叫做路由。当然路由的目标服务有多个时，还需要做负载均衡。

  • 权限控制：网关作为微服务入口，需要校验用户是是否有请求资格，如果没有则进行拦截。

  • 限流：当请求流量过高时，在网关中按照下流的微服务能够接受的速度来放行请求，避免服务压力过大。

架构图：

1.3 SpringCloud Gateway 核心概念

  1. 路由(Route):

    • 路由是网关的基础功能，它定义了请求匹配规则和转发规则。

    • 每个路由都包含一个或多个断言(Predicate)和过滤器(Filter)。

    • 断言用于匹配请求，过滤器则用于修改请求或响应。

  2. 断言(Predicate):

    • 断言用来决定是否将请求转发给特定的路由。

    • 例如，你可以根据请求路径、HTTP 方法、头部信息等条件来创建断言。

    • 断言返回 true 或 false，只有当所有断言都返回 true 时，路由才会被激活。

  3. 过滤器(Filter):

    • 过滤器用于修改进入和离开网关的请求和响应。

    • 例如，可以添加日志记录、身份验证、修改请求头等。

    • Spring Cloud Gateway 支持多种内置过滤器，也可以自定义过滤器。

2. SpringCloud Gateway快速入门

2.1 创建gateway服务，引入依赖

  1. 创建服务：

  2. 引入依赖：

    <!--网关-->
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!--nacos服务发现依赖-->
<dependency>
  <groupId>com.alibaba.cloud</groupId>
  <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

2.2 编写启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
​
@SpringBootApplication
public class GatewayServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayServiceApplication.class, args);
    }
}

2.3 编写基础配置和路由规则

创建application.yml文件，内容如下：

server:
  port: 10010 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #nacos地址
    gateway:
      routes: # 网关路由配置
        - id: user-service # 路由id，自定义，只要唯一即可
          # uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
          uri: lb://userservice # 路由的目标地址 lb就是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
            - Path=/user/** # 这个是按照路径匹配，只要以/user/开头就符合要求

我们将符合Path 规则的一切请求，都代理到 uri参数指定的地址。

本例中，我们将 /user/**开头的请求，代理到lb://userservice，lb是负载均衡，根据服务名拉取服务列表，实现负载均衡。

2.4 重启测试

重启网关，访问http://localhost:10010/user/1时，符合/user/**规则，请求转发到uri：http://userservice/user/1，得到了结果：

2.5 网关路由的流程图

整个访问的流程如下：

2.6 总结

网关搭建步骤：

  1. 创建项目，引入nacos服务发现和gateway依赖

  2. 配置application.yml，包括服务基本信息、nacos地址、路由

路由配置包括：

  1. 路由id：路由的唯一标示

  2. 路由目标（uri）：路由的目标地址，http代表固定地址，lb代表根据服务名负载均衡

  3. 路由断言（predicates）：判断路由的规则，

  4. 路由过滤器（filters）：对请求或响应做处理

3. Route Predicate（路由断言）工厂

3.1 断言工厂种类

Spring Cloud Gateway将路由匹配作为Spring WebFlux HandlerMapping 基础设施的一部分。Spring Cloud Gateway包括许多内置的路由断言工厂。所有这些谓词都与HTTP请求的不同属性相匹配。你可以用逻辑 and 语句组合多个路由断言工厂。详见：Spring Cloud Gateway

名称说明示例
After是某个时间点后的请求- After=2037-01-20T17:42:47.789-07:00[America/Denver]
Before是某个时间点之前的请求- Before=2031-04-13T15:14:47.433+08:00[Asia/Shanghai]
Between是某两个时间点之前的请求- Between=2037-01-20T17:42:47.789-07:00[America/Denver], 2037-01-21T17:42:47.789-07:00[America/Denver]
Cookie请求必须包含某些cookie- Cookie=chocolate, ch.p
Header请求必须包含某些header- Header=X-Request-Id, \d+
Host请求必须是访问某个host（域名）- Host=.somehost.org,.anotherhost.org
Method请求方式必须是指定方式- Method=GET,POST
Path请求路径必须符合指定规则- Path=/red/{segment},/blue/**
Query请求参数必须包含指定参数- Query=name, Jack或者- Query=name
RemoteAddr请求者的ip必须是指定范围- RemoteAddr=192.168.1.1/24
Weight权重处理- Weight=group1, 2

自定义断言工厂

自定义 Route Predicate，你需要提供一个实现了 RoutePredicateFactory 的 bean。有一个抽象的类叫做 AbstractRoutePredicateFactory，你可以继承它。

例如：在9-18点之间可以正常访问，否则返回404。

  1. 写一个AbstractRoutePredicateFactory的实现类

    /**
 * 自定义的断言工厂
 * 1.名称必须是配置+RoutePredicateFactory
 * 2.必须继承AbstractRoutePredicateFactory
 */
@Component
public class HourRoutePredicateFactory extends AbstractRoutePredicateFactory<HourRoutePredicateFactory.Config> {
​
    public HourRoutePredicateFactory() {
        super(HourRoutePredicateFactory.Config.class);
    }
​
    //读取配置文件的参数值，赋值到配置类中的属性上
    public List<String> shortcutFieldOrder() {
        //顺序必须与yml文件中的配置顺序对应
        return Arrays.asList("startHour", "endHour");
    }
​
    public Predicate<ServerWebExchange> apply(HourRoutePredicateFactory.Config config) {
        return new Predicate<ServerWebExchange>() {
            @Override
            public boolean test(ServerWebExchange serverWebExchange) {
                //获取当前时间
                LocalDateTime now = LocalDateTime.now();
                int hour = now.getHour();
                if(hour >= config.getStartHour() && hour <= config.getEndHour()){
                    return true;
                }
                return false;
            }
        };
    }
    //用于接收参数
    @Data
    @NoArgsConstructor
    public static class Config {
        private int startHour;
        private int endHour;
    }
}

  2. 配置配置文件

    spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/user/*
            - Hour=9,18

4. Filters 过滤器工厂

GatewayFilter是网关中提供的一种过滤器，可以对进入网关的请求和微服务返回的响应做处理：

4.1 路由过滤器的种类

Spring提供了31种不同的路由过滤器工厂。例如：

名称说明示例
AddRequestHeader给当前请求添加一个请求头- AddRequestHeader=Truth, Hello World!
SetRequestHeader设置请求头信息- SetRequestHeader=X-Request-Red, Blue
RemoveRequestHeader移除请求中的一个请求头- RemoveRequestHeader=X-Request-Foo
AddResponseHeader给响应结果中添加一个响应头- AddResponseHeader=Truth, Hello World!
RemoveResponseHeader从响应结果中移除有一个响应头- RemoveResponseHeader=X-Request-Foo
RequestRateLimiter限制请求的流量(令牌桶算法)

- name: RequestRateLimiter
  args:

          redis-rate-limiter.replenishRate: 10
          redis-rate-limiter.burstCapacity: 20

          redis-rate-limiter.requestedTokens: 1

PrefixPath对所有的请求路径添加前缀- PrefixPath=/mypath
StripPrefix跳过指定路径- StripPrefix=2
RedirectTo重定向，配置包含重定向的返回码和地址- RedirectTo=302, www.baidu.com
RewritePath改写路径- RewritePath=/where(?<segment>/?.), /test(?<segment>/?.)
SetPath设置请求路径，与RewritePath类似- SetPath=/{segment}
SetStatus设置回执状态码- SetStatus=401

4.2 请求头过滤器

以AddRequestHeader 为例。需求：给所有进入userservice的请求添加一个请求头：Truth=Hello World!

只需要修改gateway服务的application.yml文件，添加路由过滤即可：

spring:
  cloud:
    gateway:
      routes:
        - id: user-service 
          uri: lb://user-service 
          predicates: 
          - Path=/user/** 
          filters: # 过滤器
          - AddRequestHeader=Truth, Hello World! # 添加请求头

当前过滤器写在user-service路由下，因此仅仅对访问user-service的请求有效。

4.3 默认过滤器

如果要对所有的路由都生效，则可以将过滤器工厂写到default下。格式如下：

spring:
  cloud:
    gateway:
      routes:
      	- id: user-service 
      uri: lb://userservice 
      predicates: 
      - Path=/user/**
      default-filters: # 默认过滤项
      - AddRequestHeader=Truth, Hello World!

4.4 全局过滤器

4.4.1 全局过滤器作用

全局过滤器的作用也是处理一切进入网关的请求和微服务响应，与GatewayFilter的作用一样。区别在于GatewayFilter通过配置定义，处理逻辑是固定的；而GlobalFilter的逻辑需要自己写代码实现。

定义方式是实现GlobalFilter接口。

public interface GlobalFilter {
    /**
     *  处理当前请求，有必要的话通过{@link GatewayFilterChain}将请求交给下一个过滤器处理
     *
     * @param exchange 请求上下文，里面可以获取Request、Response等信息
     * @param chain 用来把请求委托给下一个过滤器 
     * @return {@code Mono<Void>} 返回标示当前过滤器业务结束
     */
    Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}

在filter中编写自定义逻辑，可以实现下列功能：

  • 登录状态判断

  • 权限校验

  • 请求限流等

4.4.2 自定义全局过滤器

需求：定义全局过滤器，拦截请求，判断请求的参数是否满足下面条件：

  • 参数中是否有authorization，

  • authorization参数值是否为admin

如果同时满足则放行，否则拦截

实现：

在gateway中定义一个过滤器：

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class AuthorizeFilter implements GlobalFilter ,Ordered{
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取请求参数
        MultiValueMap<String, String> params = exchange.getRequest().getQueryParams();
        // 2.获取authorization参数
        String auth = params.getFirst("authorization");
        // 3.校验
        if ("admin".equals(auth)) {
            // 放行
            return chain.filter(exchange);
        }
        // 4.拦截
        // 4.1.禁止访问，设置状态码
        exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
        // 4.2.结束处理
        return exchange.getResponse().setComplete();
    }
}

4.4.3 过滤器执行顺序

请求进入网关会碰到三类过滤器：当前路由的过滤器、DefaultFilter、GlobalFilter

请求路由后，会将当前路由过滤器和DefaultFilter、GlobalFilter，合并到一个过滤器链（集合）中，排序后依次执行每个过滤器：

4.4.3.1 源码解析

  1. 定义局部过滤器和默认过滤器

    spring:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates: 
            - Path=/user/**
          filters:
            - AddRequestHeader=RouterFilter1, router1
            - AddRequestHeader=RouterFilter2, router2
      default-filters:
        - AddRequestHeader=DefaultFilter1, default1
        - AddRequestHeader=DefaultFilter1, default2

  2. 定义两个全局过滤器

    import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
​
@Slf4j
@Component
public class GlobalFilter1 implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("============global1=============");
        return chain.filter(exchange);
    }
    @Override
    public int getOrder() {
        return 2;
    }
}
    import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
​
@Slf4j
@Component
public class GlobalFilter2 implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("============global2=============");
        return chain.filter(exchange);
    }
    @Override
    public int getOrder() {
        return 1;
    }
}

注意：

如果是Global过滤器，可以让Global过滤器实现org.springframework.core.Ordered接口来设置过滤器的顺序，但是这里注意@org.springframework.core.annotation.Order这个注解是不起作用的。

  1. 在org.springframework.cloud.gateway.handler.FilteringWebHandler#handle()上打断点

    public Mono<Void> handle(ServerWebExchange exchange) {
    Route route = (Route)exchange.getRequiredAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
    List<GatewayFilter> gatewayFilters = route.getFilters();
    List<GatewayFilter> combined = new ArrayList(this.globalFilters);
    combined.addAll(gatewayFilters);
    AnnotationAwareOrderComparator.sort(combined);
    if (logger.isDebugEnabled()) {
        logger.debug("Sorted gatewayFilterFactories: " + combined);
    }
​
    return (new DefaultGatewayFilterChain(combined)).filter(exchange); //打断点
}

  2. 发送请求从源码中可以看出来，是先添加的Global过滤器，然后再添加的路由过滤器，从上面的截图也可以看出来，GlobalFilter2排在最前面，后面依次是default1、router1、GlobalFilter1、default2、router2。

4.4.3.2 3种过滤器的类型都不一样为啥可以在一块进行排序？

Global过滤器是org.springframework.cloud.gateway.filter.GlobalFilter的子类，但是路由过滤器和Default过滤器是org.springframework.cloud.gateway.filter.GatewayFilter的子类，他们为啥可以放在一个集合中进行排序呢？

org.springframework.cloud.gateway.handler.FilteringWebHandler这个类，它里面有一个loadFilters()方法：

private static List<GatewayFilter> loadFilters(List<GlobalFilter> filters) {
    return (List)filters.stream().map((filter) -> {
        GatewayFilterAdapter gatewayFilter = new GatewayFilterAdapter(filter);
        if (filter instanceof Ordered) {
            int order = ((Ordered)filter).getOrder();
            return new OrderedGatewayFilter(gatewayFilter, order);
        } else {
            return gatewayFilter;
        }
    }).collect(Collectors.toList());
}
private static class GatewayFilterAdapter implements GatewayFilter {
    private final GlobalFilter delegate;
​
    GatewayFilterAdapter(GlobalFilter delegate) {
        this.delegate = delegate;
    }
​
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return this.delegate.filter(exchange, chain);
    }
​
    public String toString() {
        StringBuilder sb = new StringBuilder("GatewayFilterAdapter{");
        sb.append("delegate=").append(this.delegate);
        sb.append('}');
        return sb.toString();
    }
}

从上面的源码可以看出来，gateway框架在启动的时候，会把系统中所有的GlobalFilter适配成GatewayFilterAdapter，而GatewayFilterAdapter是实现了GatewayFilter接口的，因此GlobalFilter也就适配成了GatewayFilter ，因此他们是可以放到一个集合进行排序的。同时可以看到，在获取GlobalFilter的order时候，只是使用Ordered接口并没有使用@Order注解。

4.4.3.3 总结

排序的规则:

  • 每一个过滤器都必须指定一个int类型的order值，order值越小，优先级越高，执行顺序越靠前。

  • GlobalFilter通过实现Ordered接口，由我们自己指定。

  • 路由过滤器和defaultFilter的order由Spring指定，默认是按照声明顺序从1递增。

  • 当过滤器的order值一样时，会按照 GlobalFilter > defaultFilter > 路由过滤器 的顺序执行。

4.5 限流

  1. 添加依赖

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

  2. 配置redis

    spring:
  redis:
    host: localhost
    port: 6379

  3. 配置限流

    spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/user/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20
                key-resolver: "#{@userKeyResolver}"

    这里的关键配置项包括：

    • redis-rate-limiter.replenishRate: 表示每秒补充的令牌数量，即每秒允许的最大请求数量。

    • redis-rate-limiter.burstCapacity: 表示令牌桶的最大容量，即初始允许的最大请求数量。

    • key-resolver: 用来确定限流的键，通常是一个 Bean 的名称，该 Bean 实现了 RateLimiterKeyResolver 接口，用于返回限流键。

  4. 创建 Key Resolver

    import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
​
@Component
public class UserKeyResolver implements RateLimiterKeyResolver {
​
    @Override
    public Mono<String> resolve(ServerWebExchange exchange) {
        return Mono.just(exchange.getRequest().getRemoteAddress().getAddress().getHostAddress());
    }
}

  5. 测试限流

    通过连续发送多个请求来测试是否达到限流阈值。

5. 跨域

5.1 什么是跨域

跨域：域名不一致就是跨域。主要包括：

  • 域名不同

  • 域名相同，端口不同

跨域问题：浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题

推荐文章:https://www.ruanyifeng.com/blog/2016/04/cors.html

5.2 SpringCloud Gateway解决跨域

5.2.1 全局跨域

spring:
  cloud:
    gateway:
      # ...
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        corsConfigurations:
          '[/**]':
            allowedOrigins: # 允许哪些网站的跨域请求 "*"表示所有请求都通过
              - "http://localhost:8090"
            allowedMethods: # 允许的跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" # 允许在请求中携带的头信息
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期

5.2.2 路由跨域

spring:
  cloud:
    gateway:
      routes:
      - id: user-service
        uri: lb://user-service
        predicates:
        - Path=/user/**
        metadata:
          cors
            allowedOrigins: '*'
            allowedMethods:
              - GET
              - POST
            allowedHeaders: '*'
            maxAge: 30
可儿·四系桜
关注
  • 17
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringCloud-Gateway Feign
weixin_45701868的博客
07-13 3460
SpringCloud-Gateway Feign
SpringCloud--Feign&Gateway
hcjdhsjs的博客
01-16 980
SpringClond学习教程 HTTP客户端Feign Gateway服务网关
04SpringCloud-Feign、Gateway
ZUCK的博客
11-15 1042
1.http客户端Feign 1.1 基于Feign远程调用 RestTemplate方式调用存在的问题 先来看我们以前利用RestTemplate发起远程调用的代码: 存在下面的问题: 代码可读性差，编程体验不统一 参数复杂URL难以维护 Feign的介绍 Feign是一个声明式的http客户端，官方地址: https://github.com/OpenFeign/feign 其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。 什么叫声明式？之前学习事务就解除过，早期是手动开启事
Spring Cloud（三）Feign请求方式、GateWay网关
Zach1Lavine的博客
05-12 5427
文章目录Feign请求方式基本使用自定义配置性能优化最佳实践Gateway网关搭建网关服务路由断言工厂（Route Predicate Factory）路由过滤器GatewayFilter全局过滤器 GlobalFilter Feign请求方式 之前在order-service中，我们使用RestTemplate发起远程调用。 String url = "http://userservice/user/" + order.getUserId(); User user = restTemplate.getFo
SpringCloud(二)
weixin_52271826的博客
02-26 291
先看SpringCloud(一)，在看SpringCloud(二) Feign：介绍与使用 作用 Feign存在的目的就是为了简化微服务之间的调用。 介绍 Feign可以把Rest的请求进行隐藏，伪装SpringMVC的Controller一样，又类似于Mybatis的Mapper接口。你不用再自己拼接url，拼接参数等等操作，一切的一切都交给Feign去做。 使用 操作步骤 第一步：配置依赖(在user-consumer中添加如下依赖):<!-- 配置openfeign启.
springcloud gateway 全局过滤器统一签名判定.doc
12-01
在Spring Cloud Gateway中，全局过滤器（Global Filter）是一种强大的机制，用于在请求路由到具体的服务之前或之后执行通用的处理逻辑。在这个场景中，我们关注的是如何利用全局过滤器来实现统一的签名验证，这在...
最新Spring Cloud Gateway 官方参考指南-中文版-3.x
08-16
Spring Cloud Gateway 是一款基于Spring生态系统构建的API网关，它主要设计用于提供一种简单而有效的方式来路由API，并为API提供核心关注点，如安全性、监控/度量和弹性。在3.1.3版本中，它利用了Spring Boot 2.x、...
springcloudgateway
05-14
自定义网关虽然Spring云网关具有许多内置过滤器，但有时您可能需要一种非常特殊的重定向形式，使用内置过滤器不容易构造。 对 >的请求应重定向到/ website /％s / home，其中％s应该用graph LRGateway-->Service_...
Spring cloud gateway工作流程原理解析
08-19
Spring Cloud Gateway 工作流程原理解析 Spring Cloud Gateway 是一种基于 Spring Boot 和 Spring WebFlux 构建的 API 网关，提供了访问控制、路由、安全性、监控和其他功能。Gateway 工作流程是指从客户端请求到...
springcloud gateway
07-24
**SpringCloud Gateway 深入解析** SpringCloud Gateway 是基于 Spring Framework 5、Spring Boot 2 和 Project Reactor 等技术构建的云原生微服务网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理...
带有OpenFeign的Spring-Cloud-Gateway：Hello World-具有OpenFeign的Spring Cloud Gateway
02-17
带有OpenFeign的Spring-Cloud-Gateway Spring Cloud Gateway + OpenFeign服务1服务2供应商MSA服务 실행 网关와Service1，Service2맞는맞는실행한실행한실행한 网关（8080） 服务1（10001） 服务2（10002） 하면服务1에서OpenFeign통해网关있는Service2의Hello를다 기타 OpenFeign的服务请求JWT的服务于发布
Spring Cloud Alibaba 2.1.0.RELEASE 整合 Nocas Feign Webflux Gateway Sentinel等组件代码
09-18
Spring Cloud Alibaba 2.1.0.RELEASE 整合 Nocas Feign Webflux Gateway Sentinel等组件
springboot2.0 +zuul gateway + eureka + feign 整合
07-24
本demo采用最简单的流程创建一个springboot2.0 +zuul gateway + eureka + feign的调用请求流程，程序下载解压导入就可运行，可自己补充里面的内容
SpringCloud学习笔记（三）Feign和Gateway
qq_44648936的博客
03-26 1134
Feign和Gateway的简单使用
[SpringCloud] Feign 与 Gateway 简介
joyride_run的博客
10-31 2170
Feign 是 Netflix 开发的声明式、模板化的 Http 客户端，Feign 可以帮助我们更快捷、优雅地调用Http API。Feign 是在 Ribbon 的基础上进行了一次改进，是一个使用起来更加方便的 HTTP 客户端。SpringCloud 对 Feign 进行了增强，使 Feign 支持了 Spring MVC 注解，并整合了 Ribbon 和 Eureka，集成了服务发现和负载均衡，从而让 Feign 的使用更加方便。
SpringCloud 远程调用Feign、网关Gateway、配置中心Nacos、微服务架构小结、Nacos搭建集群
weixin_46589095的博客
05-12 2492
SpringCloud 远程调用Feign、网关Gateway、配置中心Nacos、微服务架构小结、Nacos搭建集群
Spring Cloud Gateway如何优雅地进行feign调用
sslulu520的博客
04-13 8226
Spring Cloud Gateway通过WebFlux响应式框架实现了全异步处理，看过Spring Cloud Gateway源码的同学应该都深有体会，响应式编程的代码有多么难理解。正因为Spring Cloud Gateway的响应式编程，导致它直接调用feign会有问题，因为feign的调用是同步调用。遇到feign同步调用的问题，直接通过线程池强制将feign调用转成异步调用，简单粗暴，在我看来也并不是一个好的方案。
Springcloud的学习-----Fegin,GateWay
最新发布
m0_68185369的博客
04-06 243
Fegin，GateWay
Spring Cloud使用Feign+gateway+nacos实现远程接口的调用
weixin_67268418的博客
12-25 2290
本文通过springcloud中feign+gateway+nacos实现服务之间的调用。服务A,服务B,gateway将自己注册到Nacos的配置中心当中,在服务A想要调用服务B时,使用feign,将请求发送到gateway,gateway根据请求url去nacos服务列表中找到服务B的ip转发请求。使用的springboot，springcloud，springcloudalibaba 版文稳定，可供参考。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值