springcloud 中 gateway 转发前端 websocket 请求到微服务模块

在 Spring Cloud Gateway 中转发 WebSocket 请求到后端微服务模块需要进行以下步骤：

1. 在 Gateway 配置文件中添加 WebSocket 路由规则，例如：

spring:
  cloud:
    gateway:
      routes:
        - id: websocket_route
          uri: lb://websocket-service
          predicates:
            - Path=/websocket/**
          filters:
            - RewritePath=/websocket/(?<segment>.*), /$\{segment}
            - WebSocket

这里定义了一个 ID 为 `websocket_route` 的路由规则，将所有 `/websocket/**` 的请求转发到名为 `websocket-service` 的微服务上。

2. 在微服务模块中添加 WebSocket 支持，可以使用 Spring Boot 自带的 WebSocket 支持或者其他第三方库。例如：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
 
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyWebSocketHandler(), "/websocket")
                .setAllowedOrigins("*")
                .addInterceptors(new HandshakeInterceptor() {
                    @Override
                    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
                        // 这里可以进行一些握手前的处理，例如获取用户信息等
                        return true;
                    }
 
                    @Override
                    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
                        // 这里可以进行一些握手后的处理
                    }
                });
    }
}

这里定义了一个 WebSocket 处理器 `MyWebSocketHandler`，将其注册到 `/websocket` 路径上，并设置了一些握手拦截器。

3. 在前端页面中使用 WebSocket 连接到 Gateway。例如：

var webSocket = new WebSocket("ws://gateway-host:gateway-port/websocket");
webSocket.onopen = function(event) {
    console.log("WebSocket connected");
};
webSocket.onmessage = function(event) {
    console.log("Received message: " + event.data);
};

这里使用 JavaScript 中的 WebSocket 对象连接到 Gateway 上的 `/websocket` 路径，当连接成功后可以进行数据交换。

4. 在 Gateway 中转发 WebSocket 请求到后端微服务模块。由于 WebSocket 是一种长连接协议，需要使用 `WebSocket` 过滤器进行转发。例如：

public class WebSocketFilter implements GatewayFilter {
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        if (WebSocketHandlerSupport.isWebSocketUpgrade(exchange)) {
            URI uri = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
            if (uri != null) {
                String path = uri.getPath();
                if (path.startsWith("/websocket")) {
                    ServerHttpRequest request = exchange.getRequest();
                    HttpHeaders headers = request.getHeaders();
                    String upgrade = headers.getFirst("Upgrade");
                    String connection = headers.getFirst("Connection");
                    String secWebSocketKey = headers.getFirst("Sec-WebSocket-Key");
                    String version = headers.getFirst("Sec-WebSocket-Version");
                    if ("WebSocket".equalsIgnoreCase(upgrade) && "Upgrade".equalsIgnoreCase(connection) && secWebSocketKey != null && version != null) {
                        ServerHttpRequest newRequest = request.mutate()
                                .header("Upgrade", "websocket")
                                .header("Connection", "Upgrade")
                                .build();
                        return exchange.getApplicationContext().getBean(ReactorNettyWebSocketClient.class)
                                .execute(uri, newRequest, clientHandler(uri))
                                .doOnSuccess(webSocketSession -> exchange.getAttributes().put(ATTRIBUTE_WEBSOCKET_SESSION, webSocketSession))
                                .flatMap(webSocketSession -> Mono.empty());
                    }
                }
            }
        }
        return chain.filter(exchange);
    }
 
    private Function<? super NettyDataBufferFactory, ? extends ClientHandler> clientHandler(URI uri) {
        return factory -> new ReactorNettyWebSocketClient()
                .execute(uri, session -> session.receive()
                        .map(WebSocketMessage::getPayloadAsText)
                        .map(factory::wrap)
                        .map(dataBuffer -> {
                            HttpHeaders headers = new HttpHeaders();
                            headers.setContentType(MediaType.TEXT_PLAIN);
                            return new DefaultWebSocketFrame(dataBuffer, headers, false);
                        })
                        .map(frame -> {
                            if (log.isDebugEnabled()) {
                                log.debug("Received frame: " + frame.getPayloadAsText());
                            }
                            return frame;
                        })
                        .map(session::textMessage)
                )
                .cast(ClientHandler.class);
    }
}

这里定义了一个 `WebSocketFilter` 过滤器，在过滤器中判断当前请求是否为 WebSocket 协议，如果是则使用 `ReactorNettyWebSocketClient` 将请求转发到后端微服务模块。

以上就是在 Spring Cloud Gateway 中转发 WebSocket 请求到后端微服务模块的完整流程。