spring geteway 网关代理HTTPS http转HTTPS

已于 2023-02-20 09:13:01 修改
阅读量750 收藏 1
点赞数
分类专栏： java springboot springgeteway 文章标签： http spring https
于 2022-09-11 11:03:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40127376/article/details/126803264
版权
springboot 同时被 3 个专栏收录
16 篇文章 0 订阅
订阅专栏
java
7 篇文章 0 订阅
订阅专栏
springgeteway
1 篇文章 0 订阅
订阅专栏

geteway 代理HTTPS 中遇到这样的错误
在这里插入图片描述

2022-09-11 10:53:13.988 ERROR 9612 --- [ctor-http-nio-4] o.s.w.s.adapter.HttpWebHandlerAdapter    : [c3543410-2] 500 Server Error for HTTP GET "/auth/w"

javax.net.ssl.SSLHandshakeException: General SSLEngine problem
	at sun.security.ssl.Handshaker.checkThrown(Handshaker.java:1478) ~[na:1.8.0_151]
	Suppressed: reactor.core.publisher.FluxOnAssembly$OnAssemblyException: 
Error has been observed at the following site(s):
	|_ checkpoint ⇢ org.springframework.cloud.gateway.filter.WeightCalculatorWebFilter [DefaultWebFilterChain]
	|_ checkpoint ⇢ HTTP GET "/auth/w" [ExceptionHandlingWebHandler]
Stack trace:
		at sun.security.ssl.Handshaker.checkThrown(Handshaker.java:1478) ~[na:1.8.0_151]
		at sun.security.ssl.SSLEngineImpl.checkTaskThrown(SSLEngineImpl.java:535) ~[na:1.8.0_151]
		at sun.security.ssl.SSLEngineImpl.readNetRecord(SSLEngineImpl.java:813) ~[na:1.8.0_151]
		at sun.security.ssl.SSLEngineImpl.unwrap(SSLEngineImpl.java:781) ~[na:1.8.0_151]
		at javax.net.ssl.SSLEngine.unwrap(SSLEngine.java:624) ~[na:1.8.0_151]
		at io.netty.handler.ssl.SslHandler$SslEngineType$3.unwrap(SslHandler.java:282) ~[netty-handler-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.handler.ssl.SslHandler.unwrap(SslHandler.java:1387) [netty-handler-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.handler.ssl.SslHandler.decodeJdkCompatible(SslHandler.java:1282) [netty-handler-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.handler.ssl.SslHandler.decode(SslHandler.java:1329) [netty-handler-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.handler.codec.ByteToMessageDecoder.decodeRemovalReentryProtection(ByteToMessageDecoder.java:508) ~[netty-codec-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.handler.codec.ByteToMessageDecoder.callDecode(ByteToMessageDecoder.java:447) ~[netty-codec-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:276) ~[netty-codec-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:379) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:365) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:357) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.DefaultChannelPipeline$HeadContext.channelRead(DefaultChannelPipeline.java:1410) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:379) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:365) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:919) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.nio.AbstractNioByteChannel$NioByteUnsafe.read(AbstractNioByteChannel.java:166) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:719) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:655) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:581) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:493) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:989) ~[netty-common-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74) ~[netty-common-4.1.58.Final.jar:4.1.58.Final]
		at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30) ~[netty-common-4.1.58.Final.jar:4.1.58.Final]
		at java.lang.Thread.run(Thread.java:748) ~[na:1.8.0_151]
Caused by: javax.net.ssl.SSLHandshakeException: General SSLEngine problem
	at sun.security.ssl.Alerts.getSSLException(Alerts.java:192) ~[na:1.8.0_151]
	at sun.security.ssl.SSLEngineImpl.fatal(SSLEngineImpl.java:1728) ~[na:1.8.0_151]
	at sun.security.ssl.Handshaker.fatalSE(Handshaker.java:304) ~[na:1.8.0_151]
	at sun.security.ssl.Handshaker.fatalSE(Handshaker.java:296) ~[na:1.8.0_151]
	at sun.security.ssl.ClientHandshaker.serverCertificate(ClientHandshaker.java:1514) ~[na:1.8.0_151]
	at sun.security.ssl.ClientHandshaker.processMessage(ClientHandshaker.java:216) ~[na:1.8.0_151]
	at sun.security.ssl.Handshaker.processLoop(Handshaker.java:1026) ~[na:1.8.0_151]
	at sun.security.ssl.Handshaker$1.run(Handshaker.java:966) ~[na:1.8.0_151]
	at sun.security.ssl.Handshaker$1.run(Handshaker.java:963) ~[na:1.8.0_151]
	at java.security.AccessController.doPrivileged(Native Method) ~[na:1.8.0_151]
	at sun.security.ssl.Handshaker$DelegatedTask.run(Handshaker.java:1416) ~[na:1.8.0_151]
	at io.netty.handler.ssl.SslHandler.runAllDelegatedTasks(SslHandler.java:1557) [netty-handler-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.handler.ssl.SslHandler.runDelegatedTasks(SslHandler.java:1571) [netty-handler-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.handler.ssl.SslHandler.unwrap(SslHandler.java:1455) [netty-handler-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.handler.ssl.SslHandler.decodeJdkCompatible(SslHandler.java:1282) [netty-handler-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.handler.ssl.SslHandler.decode(SslHandler.java:1329) [netty-handler-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.handler.codec.ByteToMessageDecoder.decodeRemovalReentryProtection(ByteToMessageDecoder.java:508) ~[netty-codec-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.handler.codec.ByteToMessageDecoder.callDecode(ByteToMessageDecoder.java:447) ~[netty-codec-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:276) ~[netty-codec-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:379) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:365) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:357) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.channel.DefaultChannelPipeline$HeadContext.channelRead(DefaultChannelPipeline.java:1410) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:379) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:365) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:919) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]
	at io.netty.channel.nio.AbstractNioByteChannel$NioByteUnsafe.read(AbstractNioByteChannel.java:166) ~[netty-transport-4.1.58.Final.jar:4.1.58.Final]

解决方案

spring:
  cloud:
            # 信任所有证书
    gateway:
      httpclient:
        ssl:
          use-insecure-trust-manager: true

重写https HttpClient bean 方法

package com.qz.mos.config;

import io.netty.channel.ChannelOption;
import io.netty.handler.ssl.SslContextBuilder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.boot.context.properties.PropertyMapper;
import org.springframework.cloud.gateway.config.HttpClientCustomizer;
import org.springframework.cloud.gateway.config.HttpClientProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import reactor.netty.http.client.HttpClient;
import reactor.netty.resources.ConnectionProvider;
import reactor.netty.tcp.ProxyProvider;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.time.Duration;
import java.util.List;

import static org.springframework.cloud.gateway.config.HttpClientProperties.Pool.PoolType.DISABLED;
import static org.springframework.cloud.gateway.config.HttpClientProperties.Pool.PoolType.FIXED;

/**
 * 覆盖gateway默认的httpClient配置 支持jks格式的证书
 * 
 * @author 易通
 * @since 2022/9/11
 */
@Configuration
@Slf4j
public class GatewayHttpClientConfig {
    protected final Log logger = LogFactory.getLog(getClass());

    @Bean
    public HttpClient gatewayHttpClient(HttpClientProperties properties,
                                        List<HttpClientCustomizer> customizers) {

        // configure pool resources
        ConnectionProvider connectionProvider = buildConnectionProvider(properties);

        HttpClient httpClient = HttpClient.create(connectionProvider)
                // TODO: move customizations to HttpClientCustomizers
                .httpResponseDecoder(spec -> {
                    if (properties.getMaxHeaderSize() != null) {
                        // cast to int is ok, since @Max is Integer.MAX_VALUE
                        spec.maxHeaderSize(
                                (int) properties.getMaxHeaderSize().toBytes());
                    }
                    if (properties.getMaxInitialLineLength() != null) {
                        // cast to int is ok, since @Max is Integer.MAX_VALUE
                        spec.maxInitialLineLength(
                                (int) properties.getMaxInitialLineLength().toBytes());
                    }
                    return spec;
                }).tcpConfiguration(tcpClient -> {

                    if (properties.getConnectTimeout() != null) {
                        tcpClient = tcpClient.option(
                                ChannelOption.CONNECT_TIMEOUT_MILLIS,
                                properties.getConnectTimeout());
                    }

                    // configure proxy if proxy host is set.
                    HttpClientProperties.Proxy proxy = properties.getProxy();

                    if (StringUtils.hasText(proxy.getHost())) {

                        tcpClient = tcpClient.proxy(proxySpec -> {
                            ProxyProvider.Builder builder = proxySpec
                                    .type(ProxyProvider.Proxy.HTTP)
                                    .host(proxy.getHost());

                            PropertyMapper map = PropertyMapper.get();

                            map.from(proxy::getPort).whenNonNull().to(builder::port);
                            map.from(proxy::getUsername).whenHasText()
                                    .to(builder::username);
                            map.from(proxy::getPassword).whenHasText()
                                    .to(password -> builder.password(s -> password));
                            map.from(proxy::getNonProxyHostsPattern).whenHasText()
                                    .to(builder::nonProxyHosts);
                        });
                    }
                    return tcpClient;
                });

        HttpClientProperties.Ssl ssl = properties.getSsl();
        if ((ssl.getKeyStore() != null && ssl.getKeyStore().length() > 0)
                || ssl.getTrustedX509CertificatesForTrustManager().length > 0
                || ssl.isUseInsecureTrustManager()) {
            httpClient = httpClient.secure(sslContextSpec -> {
                // configure ssl
                SslContextBuilder sslContextBuilder = SslContextBuilder.forClient();

                X509Certificate[] trustedX509Certificates = ssl
                        .getTrustedX509CertificatesForTrustManager();
                if (trustedX509Certificates.length > 0) {
                    sslContextBuilder = sslContextBuilder
                            .trustManager(trustedX509Certificates);
                }
                else if (ssl.isUseInsecureTrustManager()) {
                    X509TrustManager tm = new X509TrustManager() {
                        @Override
                        public void checkClientTrusted(X509Certificate[] chain,
                                                       String authType) throws CertificateException {
                        }
                        @Override
                        public void checkServerTrusted(X509Certificate[] chain,
                                                       String authType) throws CertificateException {
                        }
                        @Override
                        public X509Certificate[] getAcceptedIssuers() {
                            return null;
                        }
                    };
                    sslContextBuilder = sslContextBuilder.trustManager(tm);
                }

                try {
                    sslContextBuilder = sslContextBuilder
                            .keyManager(ssl.getKeyManagerFactory());
                }
                catch (Exception e) {
                    logger.error(e);
                }

                sslContextSpec.sslContext(sslContextBuilder)
                        .defaultConfiguration(ssl.getDefaultConfigurationType())
                        .handshakeTimeout(ssl.getHandshakeTimeout())
                        .closeNotifyFlushTimeout(ssl.getCloseNotifyFlushTimeout())
                        .closeNotifyReadTimeout(ssl.getCloseNotifyReadTimeout());
            });
        }

        if (properties.isWiretap()) {
            httpClient = httpClient.wiretap(true);
        }

        if (properties.isCompression()) {
            httpClient = httpClient.compress(true);
        }

        if (!CollectionUtils.isEmpty(customizers)) {
            customizers.sort(AnnotationAwareOrderComparator.INSTANCE);
            for (HttpClientCustomizer customizer : customizers) {
                httpClient = customizer.customize(httpClient);
            }
        }

        return httpClient;
    }

    private ConnectionProvider buildConnectionProvider(
            HttpClientProperties properties) {
        HttpClientProperties.Pool pool = properties.getPool();

        ConnectionProvider connectionProvider;
        if (pool.getType() == DISABLED) {
            connectionProvider = ConnectionProvider.newConnection();
        }
        else {
            // create either Fixed or Elastic pool
            ConnectionProvider.Builder builder = ConnectionProvider
                    .builder(pool.getName());
            if (pool.getType() == FIXED) {
                builder.maxConnections(pool.getMaxConnections())
                        .pendingAcquireMaxCount(-1).pendingAcquireTimeout(
                        Duration.ofMillis(pool.getAcquireTimeout()));
            }
            else {
                // Elastic
                builder.maxConnections(Integer.MAX_VALUE)
                        .pendingAcquireTimeout(Duration.ofMillis(0))
                        .pendingAcquireMaxCount(-1);
            }

            if (pool.getMaxIdleTime() != null) {
                builder.maxIdleTime(pool.getMaxIdleTime());
            }
            if (pool.getMaxLifeTime() != null) {
                builder.maxLifeTime(pool.getMaxLifeTime());
            }
            builder.evictInBackground(pool.getEvictionInterval());
            connectionProvider = builder.build();
        }
        return connectionProvider;
    }
}

各位老铁点赞加关注，不能白嫖啊！

qq_40127376
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springcloud Gateway网关-压测用.zip
07-22
网关里包括一个简单aop代理，使用简单路由及默认过滤器，还有5个一样的修改request body的自定义全局过滤器。
Spring Cloud Gateway--支持https
IT利刃出鞘的博客
12-17 4727
https转http 其他网址 SpringCloud Gateway Https设置 以Http 转发 路由 给后台微服务_jingle_1995的博客-CSDN博客 http转https 其他网址 Spring Cloud Gateway同时监听HTTP和HTTPS（http自动转发https端口）_jingle_1995的博客-CSDN博客 ...
Spring gateway / nginx / https正向代理
weixin_30398227的博客
07-19 2380
前言 两台机器192.168.1.121,192.168.1.122 keepalived (vip 192.168.12.19) 目标: 两台主机上都安装gateway nginx keepalived 192.168.12.19:8280 作为nginx到gateway的反向代理路径 192.168.12.19:8290 作为nginx对外正向代理 涉及 dnsmasq keep...
springcloud 之gateway配置注意事项
qq_43633503的博客
07-01 3033
springcloud 之gateway配置注意事项 1.springcloud 的底层用的是自家的WebFlux 以及netty 但是我们自己用的boot项目是tomcat 和 springmvc 这样会导致我们项目编译都不会通过 如果直接导入了web starter 会提示找到了mvc idea 不抽风的话会提示移除不恰当的springmvc 图1 这里提示我们的tomcat已经启动成功 但是报错： java.lang.ClassCastException: org.springf
*__checkpoint ⇢ org.springframework.cloud.gateway.filter.WeightCalculatorWebFilter [DefaultWebFilter
qq_1801743621的博客
09-24 3570
java.lang.IllegalStateException: block()/blockFirst()/blockLast() are blocking, which is not supported in thread reactor-http-nio-2 at *__checkpoint ⇢ org.springframework.cloud.gateway.filter.WeightCalculatorWebFilter [DefaultWebFilterChain]
聊聊spring cloud gateway的NettyConfiguration
yygr的博客
04-13 1653
https://segmentfault.com/a/1190000015154148 序 本文主要研究下spring cloud gateway的NettyConfiguration NettyConfiguration @Configuration @ConditionalOnProperty(name = "spring.cloud.gateway.enabled", matchIfMissing = true) @EnableConfigurationProperties @AutoC
spring cloud gateway实现https访问
qq_35469920的博客
08-26 4222
通过配置spring cloud gateway实现服务网关https访问
SpringCloud GateWay配置(TLS 和 SSL、Http超时配置)—官方原版
深圳市多克创新科技有限公司
03-05 1079
SpringCloud GateWay配置—TLS 和 SSL、Http超时配置
SpringCloud网关Gateway架构解析
08-24
SpringCloud 网关 Gateway 架构解析 SpringCloud 网关 Gateway 架构解析是当前微服务架构中不可或缺的一部分，它介于客户端和服务器端之间，所有的外部请求都会先经过网关这一层。网关架构的主要优点是提高业务灵活...
Spring Cloud Gateway 服务网关快速实现解析
08-25
Spring Cloud Gateway 服务网关快速实现解析 Spring Cloud Gateway 是 Spring Cloud 微服务平台的一个子项目，属于 Spring 开源社区，依赖名叫：spring-cloud-starter-gateway。它构建于 Spring 5+，基于 Spring ...
基于Springcloud的基础框架，统一gateWay网关鉴权demo，附下载地址
最新发布
09-04
基于Springcloud的基础框架，统一gateWay网关鉴权demo，附下载地址 使用方法具体见：https://blog.csdn.net/a1139628523/article/details/132664763
【Java开发】Spring Cloud 11：Gateway 配置 ssl 证书（https、http、域名访问）
尹煜的博客
05-03 5817
最近研究给微服务项目配置 ssl 证书，如此才可以对接微信小程序（需要使用 https 请求）。传统单体项目来说，首先往项目中添加证书文件，然后在配置文件中配置 ssl 证书路径、密码等相关信息；那么微服务这么多项目，总不能一个个配置 ssl 证书，最后发现可以直接通过网关 Gateway 解决该问题，完全不用对微服务下的项目做变动，亲测有效。
【springcloud gateway诡异间歇性500异常解决】500 Server Error，ConcurrentModificationException: null
热门推荐
龍一騰的专栏
02-19 1万+
springcloud gateway 诡异 间歇性500 异常解决
SpringCloud 2.x学习笔记：15、Spring Cloud Gateway之Filter过滤器（Greenwich版本）
程裕强的专栏
06-21 1833
1、AddRequestHeader过滤器 server: port: 7013 --- spring: cloud: gateway: routes: - id: add_request_header_route uri: http://httpbin.org filters: - AddRequestHea...
Https原理及流程
通往神秘的道路的专栏
05-30 399
HTTPS通信过程 HTTPS协议 = HTTP协议 + SSL/TLS协议，在HTTPS数据传输的过程中，需要用SSL/TLS对数据进行加密和解密，需要用HTTP对加密后的数据进行传输，由此可以看出HTTPS是由HTTP和SSL/TLS一起合作完成的。 SSL的全称是Secure Sockets Layer，即安全套接层协议，是为网络通信提供安全及数据完整性的一种安全协议。SSL协议在1994年被Netscape发明，后来各个浏览器均支持SSL，其最新的版本是3.0 TLS的全称是Transport La
Springboot项目配置Elasticsearch，设置账号密码后报javax.net.ssl.SSLHandshakeException: General SSLEngine problem
htx845928748的博客
07-28 6283
ES 报错：javax.net.ssl.SSLHandshakeException: General SSLEngine problem
spring cloud gateway 实现https
weixin_55741551的博客
08-15 1690
spring cloud 配置https
springboot @Scheduled 多线程与单线程和@Scheduled不生效
qq_40127376的博客
11-28 7773
问题1 之前定时任务一致好好的，某天突然服务没有执行，重启之后也不执行，本地起服务也不执行。。。。 解决方法 https://blog.csdn.net/weixin_37882382/article/details/82217729 问题2 加了@EnableScheduling 定时器还是不管用 解决方法 定时任务类没有加 @Service 问题3 @Scheduled 定时任务慢,明明时间设...
Spring Cloud Gateway网关
07-27
Spring Cloud Gateway是一个用于构建微服务架构中的网关的开源项目。它基于Spring Framework 5、Spring Boot 2和Project Reactor等技术栈，提供了一种灵活且可扩展的方式来路由和过滤请求。 作为微服务架构中的一个重要组件，网关在服务之间起到了路由、负载均衡、安全认证、限流等功能。Spring Cloud Gateway通过使用路由断言和过滤器链的方式来实现这些功能。 路由断言用于匹配请求的条件，例如请求的路径、请求的参数等。过滤器链用于对请求进行处理，例如添加请求头、修改请求体等。 此外，Spring Cloud Gateway还提供了动态路由的能力，可以通过配置中心来动态地添加、修改或删除路由规则，从而实现灵活的服务路由。 总而言之，Spring Cloud Gateway提供了一个轻量级、灵活且可扩展的网关解决方案，可以帮助开发者构建高性能的微服务架构。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值