增强网关设计与使用

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量1.2k 收藏
点赞数
分类专栏： 微服务 文章标签： java 过滤器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42207682/article/details/114284076
版权

增强网关

目的

  • 整合错误码，对外显示友好，对内便于快速定位问题

  • 记录出错请求，依照错误码制定处理策略

设计

状态码格式
  • 示例 E01001B002
  • 解析
    • E 统一前缀，表明异常
    • 01 应用标识
    • 001 功能域
    • B 错误类型
    • 002 错误码
配置格式

Better-Gateway 简单说明

核心实现

设计思路

配置文件读取

  • NacosClient 封装后的Nacos客户端，便于手动操作获取配置。
  • NacosConfChangeHandler Nacos监听器，用于监听主配置文件的改动。
  • CoreContainerService 配置实体容器操作接口
public interface CoreContainerService {
    /**
     * 数据初始化，用于第一次加载数据
     *
     * @return 变化的dataId 的集合
     */
    void initData();
    /**
     * 查找服务商管理配置中并且更新服务提供商的列表 那些配置发生了变化，返回 dataId;
     *
     * @param ServiceProviderList
     * @return 返回服务提供商配置列表中变化的dataId
     */
    List<String> findServerProviderDataDifferent(List<ServiceProvider> ServiceProviderList);
    /**
     * 得到服务提供商
     *
     * @return 得到所有的服务提供商
     */
    Map<String, ServiceProvider> getServiceProvider();
    /**
     * 得到错误码
     *
     * @return 得到所有的状态码
     */
    Map<String, List<UrlStatusCode>> getUrlStatusCode();
    /**
     * 处理 变化的dataId,并且通知给数据格式转换接口实现类
     *
     * @param dataDifferent
     */
    void fetchUrlStatusCode(List<String> dataDifferent);
}
  • DataFormatConversion 数据格式转换接口
public interface DataFormatConversion {
    /**
     * 更新服务提供商
     *
     * @param serviceProviderList
     */
    void updateServiceProvider(JSONArray serviceProviderList);
    /**
     * 更新状态码
     *
     * @param dataId
     * @param statusCodeList
     */
    void updateStatusCode(String dataId, JSONArray statusCodeList);
}
错误码转换

  • CacheRequestBodyFilter 缓存请求体过滤器，获取请求体并重写getBody方法，以便后续过滤器可以多次读取请求参数
@Component
public class CacheRequestBodyFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        MediaType contentType = exchange.getRequest().getHeaders().getContentType();
        exchange.getAttributes().put(Constant.Attributes.REQUEST_URL, exchange.getRequest().getURI());
        if (exchange.getRequest().getHeaders().getContentType() == null) {
            return chain.filter(exchange);
        } else {
            if (!MediaType.APPLICATION_FORM_URLENCODED.equals(contentType) && !MediaType.APPLICATION_JSON.equals(contentType)) {
                return chain.filter(exchange);
            }
            NettyDataBufferFactory factory = (NettyDataBufferFactory) exchange.getResponse().bufferFactory();
            return DataBufferUtils.join(exchange.getRequest().getBody().defaultIfEmpty(factory.wrap(new EmptyByteBuf(factory.getByteBufAllocator()))))
                    .flatMap(dataBuffer -> {
                        DataBufferUtils.retain(dataBuffer);
                        Flux<DataBuffer> cachedFlux = Flux.defer(() -> Flux.just(dataBuffer.slice(0, dataBuffer.readableByteCount())));
                        ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(exchange.getRequest()) {
                            @Override
                            public Flux<DataBuffer> getBody() {
                                return cachedFlux;
                            }
                        };
                        return chain.filter(exchange.mutate().request(mutatedRequest).build());
                    });
        }
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
}
  • ErrorCodeFilter 错误码转换过滤器
@Component
public class ErrorCodeFilter implements GlobalFilter, Ordered {

    private static final Logger logger = LoggerFactory.getLogger(ErrorCodeFilter.class);

    private static final String UNKNOWN_ERROR_APP_CODE = "E99999P999";
    private static final String UNKNOWN_ERROR_TIPS = "【E99999P999】未知的错误发生了，请联系平台技术人员";
    private static final String ERROR_CODE_PLACEHOLDER = "#APPCODE#";
    private static final String RAW_MSG_PLACEHOLDER = "#MSG#";

    @Autowired
    private RequestFailSolve requestFailSolve;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest serverHttpRequest = exchange.getRequest();
        ServerHttpResponse originalResponse = exchange.getResponse();
        DataBufferFactory bufferFactory = originalResponse.bufferFactory();
        ServerHttpResponseDecorator decoratedResponse = new ServerHttpResponseDecorator(originalResponse) {
            @Override
            public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                String contentType = getDelegate().getHeaders().getFirst(HttpHeaders.CONTENT_TYPE);
                List<String> encodings = exchange.getResponse().getHeaders().get(HttpHeaders.CONTENT_ENCODING);
                boolean jsonFlag = MediaType.APPLICATION_JSON_VALUE.equals(contentType) || MediaType.APPLICATION_JSON_UTF8_VALUE.equals(contentType);
                boolean gzipFlag = encodings != null && encodings.contains("gzip");
                if (body instanceof Flux && jsonFlag) {
                    Flux<? extends DataBuffer> fluxBody = (Flux<? extends DataBuffer>) body;
                    return super.writeWith(fluxBody.buffer().map(dataBuffer -> {
                        DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
                        DataBuffer join = dataBufferFactory.join(dataBuffer);
                        byte[] responseContent = new byte[join.readableByteCount()];
                        join.read(responseContent);
                        DataBufferUtils.release(join);
                        return bufferFactory.wrap(responseAnalysis(exchange, responseContent, gzipFlag));
                    }));
                }
                return super.writeWith(body);
            }
        };
        return chain.filter(exchange.mutate().response(decoratedResponse).build());
    }

    @Override
    public int getOrder() {
        return NettyWriteResponseFilter.WRITE_RESPONSE_FILTER_ORDER - 20;
    }

    private byte[] responseAnalysis(ServerWebExchange exchange, byte[] source, boolean gzipFlag) {
        // 读取响应内容
        if (gzipFlag) {
            source = GZIPUtil.uncompress(source);
        }
        String body = new String(source, StandardCharsets.UTF_8);
        // 处理
        JSONObject result = JSONObject.parseObject(body);
        if (!ResultCode.SUCCESS.getCode().equals(result.getInteger("code"))) {
            String responseBody = body;
            // 记录请求日志
            HttpMethod method = exchange.getRequest().getMethod();
            MediaType contentType = exchange.getRequest().getHeaders().getContentType();
            if (HttpMethod.POST.equals(method)) {
                if (MediaType.APPLICATION_FORM_URLENCODED.equals(contentType) || MediaType.APPLICATION_JSON.equals(contentType)) {
                    Flux<DataBuffer> requestBody = exchange.getRequest().getBody();
                    requestBody.subscribe(buffer -> {
                        CharBuffer charBuffer = StandardCharsets.UTF_8.decode(buffer.asByteBuffer());
                        DataBufferUtils.release(buffer);
                        logger.info("请求出现异常！请求Url [{}] 请求头 [{}] 请求内容 [{}] 响应内容 [{}]",
                                exchange.getRequest().getURI(), exchange.getRequest().getHeaders(), charBuffer.toString(), responseBody);
                    });
                } else {
                    logger.info("请求出现异常！请求Url [{}] 请求头 [{}] 请求内容为文件 响应内容 [{}]",
                            exchange.getRequest().getURI(), exchange.getRequest().getHeaders(), responseBody);
                }
            }
            body = errorCodeRevert(result, exchange);
        }
        // 封装响应内容
        byte[] target = new String(body.getBytes(), StandardCharsets.UTF_8).getBytes();
        if (gzipFlag) {
            target = GZIPUtil.compress(target);
        }
        return target;
    }

    private String errorCodeRevert(JSONObject result, ServerWebExchange exchange) {
        // 转换响应码
        String key = result.getString("path") + "#" + result.getString("appCode");
        ErrorCode errorCode = Optional.ofNullable(ErrorCodeDataFormatConversionImpl.errorCodeMap.get(key)).orElse(new ErrorCode());
        ServiceProvider provider = ErrorCodeDataFormatConversionImpl.serviceProviderMap.get(errorCode.getDataId());
        String code = UNKNOWN_ERROR_APP_CODE;
        String msg = UNKNOWN_ERROR_TIPS;
        if (provider != null) {
            code = String.format("E%s%s%s%s", provider.getCode(), errorCode.getFeatCode(), errorCode.getType(), errorCode.getCode());
            msg = errorCode.getTips().replace(ERROR_CODE_PLACEHOLDER, code)
                    .replace(RAW_MSG_PLACEHOLDER, result.getString("msg"));
        }
        result.put("appCode", code);
        result.put("result", msg);
        // 异常策略处理
        return requestFailSolve.solveRequestFail(exchange, result, errorCode);
    }
}
异常策略处理

  • RequestFailSolve 异常请求处理类
  • CompensationService 补偿策略接口

使用中的问题

堆外内存泄漏
  • 现象

日志报错：

[WARN] 2021-01-21 15:56:34.350 [reactor-http-nio-2] io.netty.channel.AbstractChannelHandlerContext - An exception 'io.netty.util.internal.OutOfDirectMemoryError: failed to allocate 16777216 byte(s) of direct memory (used: 3758096391, max: 3765960704)' [enable DEBUG level for full stacktrace] was thrown by a user handler's exceptionCaught() method while handling the following exception:
io.netty.util.internal.OutOfDirectMemoryError: failed to allocate 16777216 byte(s) of direct memory (used: 3758096391, max: 3765960704)
  • 定位问题

开启Netty内存泄漏检测

-Dio.netty.leakDetection.level=PAPANOID

Netty的内存泄漏检测分为四个级别：

  • DISABLED - 完成禁止检测内存泄漏，这个是不推荐。
  • SIMPLE - 如果buffer中出现1%的内存泄漏，打印错误日志，就是上面那样。但是日志是看不到详细在什么位置出现了内存泄漏。鉴于性能考虑，这个是在生产环境中默认使用。
  • ADVANCED - 如果buffer的1%出现内存泄漏，打印错误，并且输出详细的内存泄漏信息。
  • PARANOID - 这个和ADVANCED输出的内容是一样的，但它会对每一次请求的buffer做检查。很适用于调试和单元测试。

确认 HttpServerRequestDecoder 时发生了内存泄漏，猜测问题出现在缓存请求体过滤器：

[ERROR] 2021-01-21 16:03:14.726 [reactor-http-nio-8] io.netty.util.ResourceLeakDetector - LEAK: ByteBuf.release() was not called before it's garbage-collected. See http://netty.io/wiki/reference-counted-objects.html for more information.
Recent access records: 
Created at:
	io.netty.buffer.SimpleLeakAwareByteBuf.unwrappedDerived(SimpleLeakAwareByteBuf.java:143)
	io.netty.buffer.SimpleLeakAwareByteBuf.readRetainedSlice(SimpleLeakAwareByteBuf.java:67)
	io.netty.handler.codec.http.HttpObjectDecoder.decode(HttpObjectDecoder.java:305)
	io.netty.handler.codec.http.HttpServerCodec$HttpServerRequestDecoder.decode(HttpServerCodec.java:101)
	io.netty.handler.codec.ByteToMessageDecoder.decodeRemovalReentryProtection(ByteToMessageDecoder.java:489)
	io.netty.handler.codec.ByteToMessageDecoder.callDecode(ByteToMessageDecoder.java:428)
	io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:265)
	io.netty.channel.CombinedChannelDuplexHandler.channelRead(CombinedChannelDuplexHandler.java:253)
	io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:362)
	io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:348)
	io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:340)
	io.netty.channel.DefaultChannelPipeline$HeadContext.channelRead(DefaultChannelPipeline.java:1434)
	io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:362)
	io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:348)
	io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:965)
	io.netty.channel.nio.AbstractNioByteChannel$NioByteUnsafe.read(AbstractNioByteChannel.java:163)
	io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:628)
	io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:563)
	io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:480)
	io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:442)
	io.netty.util.concurrent.SingleThreadEventExecutor$5.run(SingleThreadEventExecutor.java:884)
	java.lang.Thread.run(Thread.java:748)

再次调试，定位具体代码：

@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    exchange.getAttributes().put(Constant.Attributes.REQUEST_URL, exchange.getRequest().getURI());
    if (exchange.getRequest().getHeaders().getContentType() == null) {
        return chain.filter(exchange);
    } else {
        DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
        return DataBufferUtils.join(exchange.getRequest().getBody().defaultIfEmpty(dataBufferFactory.wrap(new byte[0]))).flatMap(dataBuffer -> {
            NettyDataBufferFactory nettyDataBufferFactory = new NettyDataBufferFactory(new PooledByteBufAllocator(true));
            NettyDataBuffer nettyDataBuffer = nettyDataBufferFactory.wrap(dataBuffer.asByteBuffer());
            DataBufferUtils.retain(nettyDataBuffer);
            Flux<DataBuffer> cachedFlux = Flux.defer(() -> Flux.just(nettyDataBuffer));
            ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(exchange.getRequest()) {
                @Override
                public Flux<DataBuffer> getBody() {
                    return cachedFlux;
                }
            };
            return chain.filter(exchange.mutate().request(mutatedRequest).build());
        });
    }
}

定位后发现存在以下问题：

  1. DataBufferUtils.retain(nettyDataBuffer) 语句将 nettyDataBuffer 对象的引用计数+1，以便后续可以再次订阅。但在错误码过滤器中没有及时释放，导致netty直接内存中一直持有缓存的对象。
  2. 没有对请求体内容进行过滤，缓存文件会耗费大量堆内堆外内存，导致OOM
  3. 网关自身发生异常时，缓存的对象无法释放。
  • 处理办法
  1. 调整请求头缓存过滤器的逻辑，及时释放引用。
  2. 判断请求类型，只对 application/x-www-form-urlencoded 和 application/json进行缓存。
  3. 在网关发生异常时，释放掉缓存的对象。
@Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        MediaType contentType = exchange.getRequest().getHeaders().getContentType();
        if (MediaType.APPLICATION_JSON.equals(contentType) || MediaType.APPLICATION_FORM_URLENCODED.equals(contentType)) {
            DataBuffer body = exchange.getAttributeOrDefault(CACHED_REQUEST_BODY_ATTR, null);
            if (body != null) {
                return chain.filter(exchange);
            }
            return ServerWebExchangeUtils.cacheRequestBody(exchange, (serverHttpRequest) -> {
                // don't mutate and build if same request object
                if (serverHttpRequest == exchange.getRequest()) {
                    return chain.filter(exchange);
                }
                return chain.filter(exchange.mutate().request(serverHttpRequest).build()).doOnError(throwable -> {
                    log.info("发生异常:异常信息为:", throwable);
                    Object attribute = exchange.getAttributes().remove(CACHED_REQUEST_BODY_ATTR);
                    if (attribute != null && attribute instanceof PooledDataBuffer) {
                        PooledDataBuffer dataBuffer = (PooledDataBuffer) attribute;
                        if (dataBuffer.isAllocated()) {
                            dataBuffer.release();
                        }
                    }
                });
            });
        }
        return chain.filter(exchange);
    }

public class GlobalExceptionHandler extends DefaultErrorWebExceptionHandler {

    public GlobalExceptionHandler(ErrorAttributes errorAttributes, ResourceProperties resourceProperties,
                                  ErrorProperties errorProperties,
                                  ApplicationContext applicationContext) {
        super(errorAttributes, resourceProperties, errorProperties, applicationContext);
    }

	//省略无关代码
    
    @Override
    protected Map<String, Object> getErrorAttributes(ServerRequest request, ErrorAttributeOptions options) {
        log.info("发生异常:异常信息为:{}", request.attributes().get(ERROR_ATTRIBUTE));
        //释放缓存的body
        Object attribute = request.attributes().remove("cachedRequestBody");
        if (attribute != null && attribute instanceof PooledDataBuffer) {
            PooledDataBuffer dataBuffer = (PooledDataBuffer) attribute;
            if (dataBuffer.isAllocated()) {
                dataBuffer.release();
            }
        }
        //重写响应体
        return response(1000);
    }

}
别告诉我有BUG
关注
专栏目录
Spring 5 中文解析之核心篇-Null-safety和DataBuffer
liyong1028826685的专栏
08-17 1209
Null-safety 尽管Java不允许你使用其类型系统来表示空安全性，但Spring框架现在在org.springframework.lang包中提供了以下注解，以使你声明API和字段的空能力： @Nullable:指示特定参数，返回值或字段可以为null的注解。 @NonNull: 指示特定参数，返回值或字段不能为null的注释（分别适用于@NonNullApi和@NonNullFields的参数/返回值和字段不需要）。 @NonNullApi:包级别的注解，它声明非null作为参数和返回值的默认语
SpringCloudGateway笔记(7)-响应不全
yingziisme的博客
07-06 3513
实际使用遇到的问题 – 获取ResponseBody不完整和Memory LEAK的问题 第一种获取方式，会遇到获取ResponseBody不完整的问题 具体的代码如下 @Slf4j @Component public class ResponseBodyFilter implements GlobalFilter, Ordered { @Override public Mono&...
SpringCloud gateway 防止XSS漏洞_springcloud项目添加xss防护
2401_84183033的博客
04-10 1167
此外，面对XSS，往往要牺牲产品的便利性才能保证完全的安全，如何在安全和便利之间平衡也是一件需要考虑的事情。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。而反射型和DOM型的XSS则需要我们去诱使用户点击我们构造的恶意的URL，需要我们和用户有直接或者间接的接触，比如利用社会工程学或者利用在其他网页挂马的方式。对输入的内容进行过滤，可以分为黑名单过滤和白名单过滤。
SpringWebFlux-5(WebSocket 学习笔记2021.11.10)
志豪的博客
01-26 2702
SpringWebFlux -5(5.3.12版学习笔记2021.11.10) 3.0 WebSockets (自行看官网 、中文文档) 3.1.2. 何时使用 WebSockets WebSockets 可以使网页具有动态性和交互性。但是，在许多情况下，结合使用 Ajax 和 HTTP 流或长时间轮询可以提供一种简单有效的解决方案。 例如，新闻，邮件和社交订阅源需要动态更新，但是每隔几分钟这样做是完全可以的。另一方面，协作，游戏和金融应用程序需要更接近实时。 仅延迟并不是决定因素。如果消息量相对较少(
Java基础22-【Buffered缓冲流&DataInputStream&DataOutputStream】
renVictory的博客
09-27 583
Java基础22-Buffered缓冲IO流 Buffered缓冲IO流 缓冲IO流： 是处理流，负责在其他IO流基础上增加缓冲功能。提高效率 BufferedReader —> Reader BufferedWriter —> Writer BufferedInputStream —> InputStream BufferedOutputStream —> OutputStream BufferedReader除了继承了Reader的那些读的方法，还增加了一个：`String re
3-服务网关Gateway_网关过滤器学习笔记(2020.3.31)
志豪的博客
03-31 1256
3-服务网关Gateway_网关过滤器学习笔记(2020.3.31) 前言: 过滤器允许以某种方式修改传入的HTTP请求或返回的HTTP响应。过滤器的作用域是某些特定路由。Spring Cloud Gateway包括许多内置的 Filter工厂。 1. 网关过滤器 按需求使用那些过滤器。 有关如何使用以下任何过滤器的更多详细示例，请查看单元测试。 1.1 AddRequestHeader(...
从Spring Cloud Gateway过滤器中获取请求体的最优方案
m0_57640408的博客
12-15 2568
这个全局过滤器的目的就是把原有的request请求中的body内容读出来（原有的body都是以流的形式被传递），并且使用ServerHttpRequestDecorator这个请求装饰器对request进行包装，重写getBody方法，并把包装后的请求放到过滤器链中传递下去。可以满足多次获取请求。出现这个问题的时候我们第一反应应该很简单，但是真正实现的时候却有点困难。下面我就把我的方便理解的解决方案写下来。经过多方面的查看资料得出以上两个步骤就能完美的解决gateway过滤器中获取请求体的方案。
EPA安全网关原理与应用设计
07-23
EPA安全网关原理与应用设计的知识点可以概括如下： 1. EPA网络安全规范： EPA（Ethernet for Plant Automation）是一种适用于工业自动化领域的以太网通信协议，旨在实现工业测量和控制系统中设备的互联互通。EPA...
智能家居网关的设计与实现.pdf
07-15
智能家居网关的设计与实现 随着科技的进步和人们对高品质生活的追求，智能家居作为新兴的住宅智能化技术，已经逐渐走进了我们的生活。智能家居系统致力于实现家居设备的智能化控制，通过网络化手段，使用户能够远程...
基于IAIDL 的家庭网关设计与实现
07-30
【基于IAIDL的家庭网关设计与实现】 家庭网关在现代智能家居系统中扮演着至关重要的角色，它连接了内部信息家电网络与外部互联网，实现了家电设备的远程监控和智能管理。本文提出的方案基于IAIDL（信息家电接口定义...
基于WSN的矿井监控系统网关设计与实现
10-26
基于WSN的矿井监控系统网关设计与实现涉及到多个关键技术和组成部分。下面对这些技术点进行详细阐述： 1. 无线传感器网络（WSN）：WSN是一种低功耗、短距离、低速率、自组织的网络技术。在矿井监控系统中，WSN位于...
Webflux返回文件流
xiaoQL520的博客
06-30 2749
1. 环境 kotlin + webflux gradle依赖 implementation("org.springframework.boot:spring-boot-starter-webflux") implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core") implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor") 2. 从文件中获取数据并返回文件流
SpringCloud Gateway 构建应用请求日志输出 与 param和json参数打印
李虹柏的博客
05-31 2153
SpringCloud Gateway 构建应用请求日志输出 与 param和json参数打印
Spring Cloud Gateway--全局过滤器(GlobalFilter)--作用/使用
IT利刃出鞘的博客
04-28 9656
SpringCloud Gateway支持自定义过滤器，可以很灵活的进行请求或者响应的控制。
网关gateway出现netty_data_buffer(OOM)内存溢出问题
oprim的专栏
04-20 3642
网关gateway出现netty_data_buffer(OOM)内存溢出问题
【译文】Spring Cloud Gateway 3.0.4 官方文档
西伯利亚疯狂的蚯蚓
11-29 2414
Spring Cloud Gateway 3.0.4 本项目提供了一个构建在 Spring 生态系统之上的 API 网关，包括：Spring 5、Spring Boot 2 和 Project Reactor。 Spring Cloud Gateway 旨在提供一种简单而有效的方式来路由到 API 并为它们提供交叉关注点，例如：安全性、监控/指标和弹性。 1. 如何加入 要将 Spring Cloud Gateway 包含在您的项目中，请使用具有 org.springframework.cloud 的组 I
WebFlux下载文件控制层示例
qq_43762562的博客
01-11 335
WebFlux下载文件
Java-网络
最新发布
2301_81543552的博客
09-14 805
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
基于ARM11的物联网网关设计与实现
"基于ARM11的物联网网关设计-论文" 本文主要探讨了一种基于ARM11处理器的物联网(IoT)网关设计，旨在解决传统物联网网关存在的成本高昂、人机交互体验不佳以及应用领域单一的问题。网关的核心是采用Samsung公司的S3C...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值