spring cloud gateway转发的websocket连接，客户端主动断开连接，网关服务报错1005

已于 2022-08-26 16:22:18 修改
阅读量1w 收藏 23
点赞数 16
分类专栏： java 文章标签： websocket java 网络协议
于 2022-08-26 16:02:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xieqj_0511/article/details/126544299
版权

spring cloud gateway版本3.1.0

客户端通过spring cloud gateway网关转发到webSocket服务器，建立webSocket连接，当客户端断开连接后。网关会报如下错误信息：
在这里插入图片描述
Caused by: java.lang.IllegalArgumentException: WebSocket close status code does NOT comply with RFC-6455: 1005

这个报错实测，不会造成什么功能影响。但是报错信息的产生，可能会导致系统误判。

跟踪

由于是网关报错，所以在spring cloud gateway方面进行排查。

出现问题的代码 WebsocketRoutingFilter

首先发现一个关闭的issues，发现已经解决了该报错提示
https://github.com/spring-cloud/spring-cloud-gateway/issues/1057
该提交记录的代码显示已经解决了报错信息。
https://github.com/spring-cloud/spring-cloud-gateway/commit/1c54a5abdf1dc846d8f0dc892040f260aab15664

但是在正式版本中，实际上这个问题还未解决。
因为这个原因
I think serverClose and proxyClose don’t need to be included in, and probably should be separated from the zip because they are sort of competing with the Mono from each WebSocketHandler, and zip will cancel the other publishers after one of them completes.
https://github.com/spring-cloud/spring-cloud-gateway/issues/2451

持续跟踪…

问题的来源

问题在于org.springframework.cloud.gateway.filter.WebsocketRoutingFilter使用的方式ReactorNettyWebSocketSession
在这里插入图片描述
https://github.com/reactor/reactor-netty/issues/1891

解决方案

自定义过滤器，在WebsocketRoutingFilter的基础上进行修改。

方法一

参考https://github.com/spring-cloud/spring-cloud-gateway/issues/1057

package com.qf.gateway.filter;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.headers.HttpHeadersFilter;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;
import org.springframework.web.reactive.socket.client.WebSocketClient;
import org.springframework.web.reactive.socket.server.WebSocketService;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.*;

/**
 * 解决websocket关闭异常 问题
 * @author admin
 * @Desc websocket客户端主动断开连接,网关服务报错1005
 * @date 2022/8/24 14:30
 */
@Component
public class CustomWebsocketRoutingFilter implements GlobalFilter, Ordered {

    public static final String SEC_WEBSOCKET_PROTOCOL = "Sec-WebSocket-Protocol";
    private static final Log log = LogFactory.getLog(CustomWebsocketRoutingFilter.class);
    private final WebSocketClient webSocketClient;
    private final WebSocketService webSocketService;
    private final ObjectProvider<List<HttpHeadersFilter>> headersFiltersProvider;
    private volatile List<HttpHeadersFilter> headersFilters;

    public CustomWebsocketRoutingFilter(WebSocketClient webSocketClient, WebSocketService webSocketService, ObjectProvider<List<HttpHeadersFilter>> headersFiltersProvider) {
        this.webSocketClient = webSocketClient;
        this.webSocketService = webSocketService;
        this.headersFiltersProvider = headersFiltersProvider;
    }

    static String convertHttpToWs(String scheme) {
        scheme = scheme.toLowerCase();
        return "http".equals(scheme) ? "ws" : ("https".equals(scheme) ? "wss" : scheme);
    }

    @Override
    public int getOrder() {
        return 2147483645;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        changeSchemeIfIsWebSocketUpgrade(exchange);
        URI requestUrl = (URI)exchange.getRequiredAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        String scheme = requestUrl.getScheme();
        if (!ServerWebExchangeUtils.isAlreadyRouted(exchange) && ("ws".equals(scheme) || "wss".equals(scheme))) {
            ServerWebExchangeUtils.setAlreadyRouted(exchange);
            HttpHeaders headers = exchange.getRequest().getHeaders();
            HttpHeaders filtered = HttpHeadersFilter.filterRequest(this.getHeadersFilters(), exchange);
            List<String> protocols = this.getProtocols(headers);
            return this.webSocketService.handleRequest(exchange, new CustomWebsocketRoutingFilter.ProxyWebSocketHandler(requestUrl, this.webSocketClient, filtered, protocols));
        } else {
            return chain.filter(exchange);
        }
    }

    List<String> getProtocols(HttpHeaders headers) {
        List<String> protocols = headers.get("Sec-WebSocket-Protocol");
        if (protocols != null) {
            ArrayList<String> updatedProtocols = new ArrayList();

            for(int i = 0; i < ((List)protocols).size(); ++i) {
                String protocol = (String)((List)protocols).get(i);
                updatedProtocols.addAll(Arrays.asList(StringUtils.tokenizeToStringArray(protocol, ",")));
            }

            protocols = updatedProtocols;
        }

        return (List)protocols;
    }

    List<HttpHeadersFilter> getHeadersFilters() {
        if (this.headersFilters == null) {
            this.headersFilters = (List)this.headersFiltersProvider.getIfAvailable(ArrayList::new);
            this.headersFilters.add((headers, exchange) -> {
                HttpHeaders filtered = new HttpHeaders();
                filtered.addAll(headers);
                filtered.remove("Host");
                boolean preserveHost = (Boolean)exchange.getAttributeOrDefault(ServerWebExchangeUtils.PRESERVE_HOST_HEADER_ATTRIBUTE, false);
                if (preserveHost) {
                    String host = exchange.getRequest().getHeaders().getFirst("Host");
                    filtered.add("Host", host);
                }

                return filtered;
            });
            this.headersFilters.add((headers, exchange) -> {
                HttpHeaders filtered = new HttpHeaders();
                Iterator var3 = headers.entrySet().iterator();

                while(var3.hasNext()) {
                    Map.Entry<String, List<String>> entry = (Map.Entry)var3.next();
                    if (!((String)entry.getKey()).toLowerCase().startsWith("sec-websocket")) {
                        filtered.addAll((String)entry.getKey(), (List)entry.getValue());
                    }
                }

                return filtered;
            });
        }

        return this.headersFilters;
    }

    static void changeSchemeIfIsWebSocketUpgrade(ServerWebExchange exchange) {
        URI requestUrl = (URI)exchange.getRequiredAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        String scheme = requestUrl.getScheme().toLowerCase();
        String upgrade = exchange.getRequest().getHeaders().getUpgrade();
        if ("WebSocket".equalsIgnoreCase(upgrade) && ("http".equals(scheme) || "https".equals(scheme))) {
            String wsScheme = convertHttpToWs(scheme);
            boolean encoded = ServerWebExchangeUtils.containsEncodedParts(requestUrl);
            URI wsRequestUrl = UriComponentsBuilder.fromUri(requestUrl).scheme(wsScheme).build(encoded).toUri();
            exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, wsRequestUrl);
            if (log.isTraceEnabled()) {
                log.trace("changeSchemeTo:[" + wsRequestUrl + "]");
            }
        }

    }

    private static class ProxyWebSocketHandler implements WebSocketHandler {
        private final WebSocketClient client;
        private final URI url;
        private final HttpHeaders headers;
        private final List<String> subProtocols;

        ProxyWebSocketHandler(URI url, WebSocketClient client, HttpHeaders headers, List<String> protocols) {
            this.client = client;
            this.url = url;
            this.headers = headers;
            if (protocols != null) {
                this.subProtocols = protocols;
            } else {
                this.subProtocols = Collections.emptyList();
            }

        }

        @Override
        public List<String> getSubProtocols() {
            return this.subProtocols;
        }

        @Override
        public Mono<Void> handle(WebSocketSession session) {
            return this.client.execute(this.url, this.headers, new WebSocketHandler() {
                @Override
                public Mono<Void> handle(WebSocketSession proxySession) {
                    Mono<Void> serverClose = proxySession.closeStatus().filter(__ -> session.isOpen())
                            .flatMap(session::close);
                    Mono<Void> proxyClose = session.closeStatus().filter(__ -> proxySession.isOpen())
                            .flatMap(proxySession::close);
                    // Use retain() for Reactor Netty
                    Mono<Void> proxySessionSend = proxySession
                            .send(session.receive().doOnNext(WebSocketMessage::retain));
                    Mono<Void> serverSessionSend = session
                            .send(proxySession.receive().doOnNext(WebSocketMessage::retain));
                    return Mono.zip(proxySessionSend, serverSessionSend, serverClose, proxyClose).then();
                }

                @Override
                public List<String> getSubProtocols() {
                    return CustomWebsocketRoutingFilter.ProxyWebSocketHandler.this.subProtocols;
                }
            });
        }
    }
}

方法二

参考https://github.com/spring-cloud/spring-cloud-gateway/pull/2702

package com.qf.gateway.filter;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.headers.HttpHeadersFilter;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.reactive.socket.CloseStatus;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;
import org.springframework.web.reactive.socket.client.WebSocketClient;
import org.springframework.web.reactive.socket.server.WebSocketService;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.*;

/**
 * 解决websocket关闭异常 问题
 * @author admin
 * @Desc websocket客户端主动断开连接,网关服务报错1005
 * @date 2022/8/20 14:30
 */
@Component
public class CustomWebsocketRoutingFilter implements GlobalFilter, Ordered {

    public static final String SEC_WEBSOCKET_PROTOCOL = "Sec-WebSocket-Protocol";
    private static final Log log = LogFactory.getLog(CustomWebsocketRoutingFilter.class);
    private final WebSocketClient webSocketClient;
    private final WebSocketService webSocketService;
    private final ObjectProvider<List<HttpHeadersFilter>> headersFiltersProvider;
    private volatile List<HttpHeadersFilter> headersFilters;

    public CustomWebsocketRoutingFilter(WebSocketClient webSocketClient, WebSocketService webSocketService, ObjectProvider<List<HttpHeadersFilter>> headersFiltersProvider) {
        this.webSocketClient = webSocketClient;
        this.webSocketService = webSocketService;
        this.headersFiltersProvider = headersFiltersProvider;
    }

    static String convertHttpToWs(String scheme) {
        scheme = scheme.toLowerCase();
        return "http".equals(scheme) ? "ws" : ("https".equals(scheme) ? "wss" : scheme);
    }

    @Override
    public int getOrder() {
        return 2147483645;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        changeSchemeIfIsWebSocketUpgrade(exchange);
        URI requestUrl = (URI)exchange.getRequiredAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        String scheme = requestUrl.getScheme();
        if (!ServerWebExchangeUtils.isAlreadyRouted(exchange) && ("ws".equals(scheme) || "wss".equals(scheme))) {
            ServerWebExchangeUtils.setAlreadyRouted(exchange);
            HttpHeaders headers = exchange.getRequest().getHeaders();
            HttpHeaders filtered = HttpHeadersFilter.filterRequest(this.getHeadersFilters(), exchange);
            List<String> protocols = this.getProtocols(headers);
            return this.webSocketService.handleRequest(exchange, new CustomWebsocketRoutingFilter.ProxyWebSocketHandler(requestUrl, this.webSocketClient, filtered, protocols));
        } else {
            return chain.filter(exchange);
        }
    }

    List<String> getProtocols(HttpHeaders headers) {
        List<String> protocols = headers.get("Sec-WebSocket-Protocol");
        if (protocols != null) {
            ArrayList<String> updatedProtocols = new ArrayList();

            for(int i = 0; i < ((List)protocols).size(); ++i) {
                String protocol = (String)((List)protocols).get(i);
                updatedProtocols.addAll(Arrays.asList(StringUtils.tokenizeToStringArray(protocol, ",")));
            }

            protocols = updatedProtocols;
        }

        return (List)protocols;
    }

    List<HttpHeadersFilter> getHeadersFilters() {
        if (this.headersFilters == null) {
            this.headersFilters = (List)this.headersFiltersProvider.getIfAvailable(ArrayList::new);
            this.headersFilters.add((headers, exchange) -> {
                HttpHeaders filtered = new HttpHeaders();
                filtered.addAll(headers);
                filtered.remove("Host");
                boolean preserveHost = (Boolean)exchange.getAttributeOrDefault(ServerWebExchangeUtils.PRESERVE_HOST_HEADER_ATTRIBUTE, false);
                if (preserveHost) {
                    String host = exchange.getRequest().getHeaders().getFirst("Host");
                    filtered.add("Host", host);
                }

                return filtered;
            });
            this.headersFilters.add((headers, exchange) -> {
                HttpHeaders filtered = new HttpHeaders();
                Iterator var3 = headers.entrySet().iterator();

                while(var3.hasNext()) {
                    Map.Entry<String, List<String>> entry = (Map.Entry)var3.next();
                    if (!((String)entry.getKey()).toLowerCase().startsWith("sec-websocket")) {
                        filtered.addAll((String)entry.getKey(), (List)entry.getValue());
                    }
                }

                return filtered;
            });
        }

        return this.headersFilters;
    }

    static void changeSchemeIfIsWebSocketUpgrade(ServerWebExchange exchange) {
        URI requestUrl = (URI)exchange.getRequiredAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        String scheme = requestUrl.getScheme().toLowerCase();
        String upgrade = exchange.getRequest().getHeaders().getUpgrade();
        if ("WebSocket".equalsIgnoreCase(upgrade) && ("http".equals(scheme) || "https".equals(scheme))) {
            String wsScheme = convertHttpToWs(scheme);
            boolean encoded = ServerWebExchangeUtils.containsEncodedParts(requestUrl);
            URI wsRequestUrl = UriComponentsBuilder.fromUri(requestUrl).scheme(wsScheme).build(encoded).toUri();
            exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, wsRequestUrl);
            if (log.isTraceEnabled()) {
                log.trace("changeSchemeTo:[" + wsRequestUrl + "]");
            }
        }

    }

    private static class ProxyWebSocketHandler implements WebSocketHandler {
        private final WebSocketClient client;
        private final URI url;
        private final HttpHeaders headers;
        private final List<String> subProtocols;

        ProxyWebSocketHandler(URI url, WebSocketClient client, HttpHeaders headers, List<String> protocols) {
            this.client = client;
            this.url = url;
            this.headers = headers;
            if (protocols != null) {
                this.subProtocols = protocols;
            } else {
                this.subProtocols = Collections.emptyList();
            }

        }

        @Override
        public List<String> getSubProtocols() {
            return this.subProtocols;
        }

        @Override
        public Mono<Void> handle(WebSocketSession session) {
            return this.client.execute(this.url, this.headers, new WebSocketHandler() {

                private CloseStatus adaptCloseStatus(CloseStatus closeStatus) {
                    int code = closeStatus.getCode();
                    if (code > 2999 && code < 5000) {
                        return closeStatus;
                    }
                    switch (code) {
                        case 1000:
                            return closeStatus;
                        case 1001:
                            return closeStatus;
                        case 1002:
                            return closeStatus;
                        case 1003:
                            return closeStatus;
                        case 1004:
                            // Should not be used in a close frame
                            // RESERVED;
                            return CloseStatus.PROTOCOL_ERROR;
                        case 1005:
                            // Should not be used in a close frame
                            // return CloseStatus.NO_STATUS_CODE;
                            return CloseStatus.PROTOCOL_ERROR;
                        case 1006:
                            // Should not be used in a close frame
                            // return CloseStatus.NO_CLOSE_FRAME;
                            return CloseStatus.PROTOCOL_ERROR;
                        case 1007:
                            return closeStatus;
                        case 1008:
                            return closeStatus;
                        case 1009:
                            return closeStatus;
                        case 1010:
                            return closeStatus;
                        case 1011:
                            return closeStatus;
                        case 1012:
                            // Not in RFC6455
                            // return CloseStatus.SERVICE_RESTARTED;
                            return CloseStatus.PROTOCOL_ERROR;
                        case 1013:
                            // Not in RFC6455
                            // return CloseStatus.SERVICE_OVERLOAD;
                            return CloseStatus.PROTOCOL_ERROR;
                        case 1015:
                            // Should not be used in a close frame
                            // return CloseStatus.TLS_HANDSHAKE_FAILURE;
                            return CloseStatus.PROTOCOL_ERROR;
                        default:
                            return CloseStatus.PROTOCOL_ERROR;
                    }
                }

                @Override
                public Mono<Void> handle(WebSocketSession proxySession) {
                    Mono<Void> serverClose = proxySession.closeStatus().filter(__ -> session.isOpen())
                            .map(this::adaptCloseStatus)
                            .flatMap(session::close);
                    Mono<Void> proxyClose = session.closeStatus().filter(__ -> proxySession.isOpen())
                            .map(this::adaptCloseStatus)
                            .flatMap(proxySession::close);
                    // Use retain() for Reactor Netty
                    Mono<Void> proxySessionSend = proxySession
                            .send(session.receive().doOnNext(WebSocketMessage::retain));
                    Mono<Void> serverSessionSend = session
                            .send(proxySession.receive().doOnNext(WebSocketMessage::retain));
                    // Ensure closeStatus from one propagates to the other
                    Mono.when(serverClose, proxyClose).subscribe();
                    // Complete when both sessions are done
                    return Mono.zip(proxySessionSend, serverSessionSend).then();
                }

                @Override
                public List<String> getSubProtocols() {
                    return CustomWebsocketRoutingFilter.ProxyWebSocketHandler.this.subProtocols;
                }
            });
        }
    }
}
清枫975
关注
专栏目录
SpringCloud GateWay转发websocket客户端主动断开连接，网关服务报错1005
qq_52425315的博客
02-01 938
【代码】SpringCloude GateWay转发websocket客户端主动断开连接，网关服务报错1005。
WebSocket协议状态码1005: 理解、应用与解决方案
博客
08-18 3540
WebSocket协议中定义了一系列状态码，用于表示连接状态和错误信息。状态码1005表示连接已关闭，没有提供错误信息。它是WebSocket协议中的一个特殊状态码，表示连接的关闭是由于未提供错误信息而引起的。WebSocket协议状态码1005表示连接已关闭，但没有提供错误信息。它是WebSocket协议中的一个特殊状态码，常见于网络故障、服务器错误或客户端错误的情况下。针对状态码1005，我们可以通过检查网络连接、检查服务器配置、更新浏览器版本或调整协议参数来解决问题。
Spring Gateway转发websocket原理
xsgnzb的专栏
06-22 1491
Spring Cloud Gateway简称Spring Gateway，它可以转发请求到后端微服务。Spring Gateway除了转发HTTP请求，也支持websocket请求。我们看下它是怎么实现的吧。
解决websocket不定时出现1005错误
vigor(软件开发)
09-01 3841
spring cloud gateway 转发websocket请求无法监听到 close 事件 没有收到预期的状态码。在gateway进行请求拦截。
spring cloud gateway客户端websocket断开连接，服务侧连接没有关闭的问题处理
最新发布
MasterC的博客
07-04 601
本文介绍了如何解决spring cloud gateway不能正确处理客户端断开websocket的问题
使用Spring Cloud Gateway代理转发websocket无法获取自定义的CloseReason的解决办法
zzk_01的博客
07-15 1642
使用Spring Cloud Gateway代理转发websocket无法获取自定义的CloseReason的解决办法 链接: 参考文章1 链接: 参考文章2 项目在开发过程中需要使用长连接websocket，使用起来也比较方便，而且gateway正好支持websocet的转发，负载使用uri: lb:ws: 直接使用void close(CloseReason closeReason)是可以正常返回的，此方法并没有问题，直接连接服务不走网关可以接收消息。经过网关代理后就接收不到了，code和reason都
SpringCloudAlibaba 应用webSocket，解决连接成功后会立刻断开等问题
xiao_nxy的博客
02-03 5483
最近公司有个大屏，需要做一个实时报警的功能，这就用到了webSocket技术，这个帖子就用来记录学习过程中的遇到的问题
记一次解决SpringCloud-Gateway转发WebSocket失败问题的过程
热门推荐
ranweizheng的专栏
10-13 1万+
目录问题背景问题现象解决过程1 检查网关配置2 跟源码，查找可能的原因3 异常原因分析解决方法心得参考 问题背景 将原有项目中的websocket模块迁移到基于SpringCloud Alibaba的微服务系统中，其中网关部分使用的是gateway。 问题现象 迁移后，我们在使用客户端连接websocket时报错： io.netty.handler.codec.http.websocketx.WebSocketHandshakeException: Invalid subprotocol. Actual:
websocket 1 分钟自动断开连接
weixin_51542566的博客
06-18 3230
websocket 1 分钟自动断开连接
SpringCloud Nacos Gateway 网关集成 Netty的Websocket不成功问题记录，以及解决思路记录 【以及websocket代码例子】
花儿小新♥
03-18 2795
目前项目由于导入导出业务处理时间过长；很容易连接超时，用户等待过长,体验感不佳相关业务使用http短连接请求，无法满足某些特定的业务场景，如消息通知弹窗、扫码登录故需要引入websocket因为原有项目网关是使用【springCloud-nacos-gateWay】，所以先项目websocket项目需要使用网关进行统一转发（便于管理）gateway连接不上websocket服务，转发失败我通过netty搭建websocket服务，所以项目中有两个端口，一个服务端口，一个netty端口。
springcloud下通过gateway转发websocket
07-14
在IT行业中，Spring Cloud Gateway作为Spring Cloud生态体系中的一个关键组件，被广泛用于构建微服务架构中的API网关。这个框架允许我们集中处理各种请求，包括路由、过滤、安全等，极大地简化了服务间的通信。而...
springcloud getway 示例 包含 网关 http websocket 两种转发包含网关JWT鉴权包含Clie
08-05
EurekaApplication Eureka也可以不用 gateway可直接转发外部的服务 PtGatewayApplication 网关服务 包含 网关 http ， websocket 两种转发包含网关 ，包含webSocket消息发送的流量监控 UserApplication 模拟...
springcloud实现gate网关转发功能和整合websocket源码
04-25
在本文中，我们将深入探讨如何使用Spring Cloud Gateway实现网关转发功能，并整合WebSocket源码，以便在微服务架构中提供高效、灵活的数据通信。首先，让我们先了解一下Spring Cloud Gateway及其重要性。 Spring ...
SpringCloudGateway转发WebSocket请求、以及静态路由
钢镚核恒
10-13 1833
SpringCloudGateway转发WebSocket请求 1、WebSocket 依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 配置类 WebSocketConfig @Configuration
springcloudgateway转发websocket异常解决
shengyin714959的博客
06-23 1956
按道理来讲，这是前端和后端定义的子协议，即前端传递这个请求头到后端，后端判断请求头的内容是不是一致，一致通过。但是如果后端没有制定相关业务逻辑那么就会报上面那个错误，解决办法：去掉前端这个请求头。这个报错的原因是前端请求头里面有这个：Sec-WebSocket-Protocol。
websocket连接1分钟未操作，自动断开的解决办法
大薄荷
04-01 1万+
​ var socket; var lockReconnect = false; //避免socket重复连接 var lc = (window.location.href + '').split('/'); var lca = lc[2].split(':'); var protocolStr = document.location.protocol; var wsProtocol = "wss" if (protocolStr == "http:") { wsProtocol = ".
关于聊天系统客户端强制关闭导致服务端报错问题解决（完结篇）
lkxd194257的博客
12-08 483
通过正则或者字符串切片获取到@后的姓名，并与list_name中的用户名进行比较如果存在则先该用户单独发送信息，如果不存在这向发送用户提示该用户不存在。在客服端不采用exit退出系统，而是强制关闭系统时，则服务器会产生错误，同时失效的套接字仍存在在list1列表中，继续发送信息时就会导致系统崩溃。在发送时使用try：监测发送语句，如果报错则删除掉报错的套接字并更新list_name，然后继续执行程序。可以使用多个list表来进行接收，根据客户端返回的聊天室房间号来添加list中，删除部分具体执行函数。
关于springboot一个接口请求后，主动取消后，后端是否还在跑
wppwpp1的专栏
03-06 1331
1、最近在思考一个问题，如果一个springboot的请求的接口比较耗时，中途中断该请求后，则后端服务是否会终止该线程的处理，于是写了一个demo。4、发现即使取消请求后，springboot后端还是会进行业务处理，不会自动终止的。
WebSocket 1005 错误 分析
justinsun221的博客
11-17 1万+
WebSocket 1005 的错误可以忽略 通常websocket是正常关闭的情况下一般是1000，1001 是前端页面刷新或者关闭浏览器引起的，1005 是因为某种外部因素造成websocket不能进行正常关闭引起的。 我们在postman做一个测试看看1005产生过程 这是一个正在链接的websocket ,我这时候关闭postman，就会产生1005的code error。 我们用wireshark抓包 这里我们对比发现1005 和1000这两种关闭方式种，1005由于网络原因没有带payloa
springcloud gateway websocket
04-30
SpringCloud Gateway是一个基于SpringBoot和SpringCloud的API网关服务，它是SpringCloud的一个组件。它的作用是集中管理微服务的通信，提供路由控制、服务降级、负载均衡、安全认证等一系列服务。而WebSocket是一种传输协议，在应用程序中实现全双工通信，特别适用于实时的Web应用程序。 SpringCloud Gateway可以通过集成WebSocket使得应用程序具有实时通信的能力。在传统的架构中，要实现Websocket，需要单独搭建WebSocket服务器，并且与其他微服务的交互存在一定的难度，而SpringCloud Gateway可以通过使用统一的API网关服务，将WebSocket接入统一管理，降低了开发难度并提高了稳定性。 在SpringCloud Gateway中集成WebSocket，通常需要使用Spring框架的WebSocket API，实现双向通信的功能。在建立连接的时候，Gateway会创建一个WebSocket会话，这个会话与客户端的会话相对应。建立连接后，就可以实现客户端与服务端之间的实时数据传输。 总之，SpringCloud Gateway通过集成WebSocket，使得应用程序具有实时通信的能力，降低了开发难度，提高了稳定性，是现代企业级系统中必不可少的组件。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值