在Spring Boot中使用外部Tomcat同时使用WebSocket时，可能会遇到的一个常见问题是WebSocket不工作。这通常是因为Servlet容器（例如Tomcat）的配置不正确或缺少对WebSocket支持的处理程序。

解决方法：

1. 确保你的pom.xml或build.gradle中包含了Spring Boot的WebSocket依赖。

对于Maven，添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

对于Gradle，添加以下依赖：

implementation 'org.springframework.boot:spring-boot-starter-websocket'

2. 确保你的Spring Boot应用程序配置了WebSocket。你可以创建一个配置类来扩展WebSocketConfigurer并覆盖相应的方法来注册WebSocket端点。

例如：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myWebSocketHandler(), "/websocket-endpoint")
            .setAllowedOrigins("*");
    }
 
    @Bean
    public WebSocketHandler myWebSocketHandler() {
        return new MyCustomWebSocketHandler();
    }
}

3. 如果你正在使用外部Tomcat，确保Tomcat的版本支持WebSocket。从Tomcat 7开始，Tomcat内置了对WebSocket的支持。如果你使用的是Tomcat 8或更高版本，应该已经包含了对WebSocket的支持。
4. 确保你的application.properties或application.yml中没有禁用WebSocket的配置。
5. 如果你在使用Spring Security，确保WebSocket的端点没有被安全配置拦截。
6. 如果以上步骤都正确无误，但WebSocket仍然不工作，可以考虑查看日志文件，以找出可能的错误原因。

如果你遵循了以上步骤，但问题依然存在，可能需要进一步检查你的WebSocket处理程序代码或者检查外部Tomcat的配置是否正确。

以下是一个简化的Java Spring Boot后端代码示例，用于创建WebSocket端点，并在Vue前端接收和显示消息。

Java后端代码:

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
 
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
 
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(messageHandler(), "/ws/messages")
                .setAllowedOrigins("http://localhost:8080"); // 允许Vue前端的源
    }
 
    @Bean
    public WebSocketMessageHandler messageHandler() {
        return new WebSocketMessageHandler(); // 自定义的WebSocketMessageHandler实现
    }
}

Vue前端代码:

<template>
  <div>
    <div v-for="message in messages" :key="message">{{ message }}</div>
  </div>
</template>
 
<script>
export default {
  data() {
    return {
      messages: [],
      socket: null
    };
  },
  created() {
    this.connectWebSocket();
  },
  methods: {
    connectWebSocket() {
      this.socket = new WebSocket('ws://localhost:8080/ws/messages');
      this.socket.onmessage = this.handleMessage;
      this.socket.onclose = this.handleClose;
      this.socket.onerror = this.handleError;
    },
    handleMessage(event) {
      this.messages.push(event.data);
    },
    handleClose() {
      console.log('WebSocket Closed');
    },
    handleError(event) {
      console.error('WebSocket Error', event);
    },
    sendMessage(message) {
      if (this.socket.readyState === WebSocket.OPEN) {
        this.socket.send(message);
      }
    }
  },
  beforeDestroy() {
    this.socket.close();
  }
};
</script>

在这个例子中，我们创建了一个简单的WebSocket连接，在Vue前端显示从后端接收的消息。记得在实际部署时，WebSocket的URL需要根据实际部署的服务器地址进行相应的替换。

在Spring Boot中集成WebSocket，你可以使用Spring的@EnableWebSocketMessageBroker注解来配置一个WebSocket消息代理。以下是一个简单的例子：

1. 添加依赖到你的pom.xml：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

2. 配置WebSocketMessageBroker：

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
 
    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

3. 创建一个控制器来处理WebSocket消息：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
@Controller
public class WebSocketController {
 
    @MessageMapping("/hello")
    @SendTo("/topic/greetings")
    public String greeting(String message) {
        return "Hello, " + message + "!";
    }
}

4. 前端使用SockJS和STOMP：

<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1.7.0/dist/sockjs.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/stompjs@2.3.3/stomp.min.js"></script>
<script>
    var socket = new WebSocket('ws://localhost:8080/ws');
    var stompClient = Stomp.over(socket);
    stompClient.connect({}, function(frame) {
        console.log('Connected: ' + frame);
        stompClient.subscribe('/topic/greetings', function(greeting){
            console.log(greeting.body);
        });
    });
    
    function sendName() {
        s

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
 
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
 
    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}

这段代码定义了一个配置类WebSocketConfig，该类实现了WebSocketMessageBrokerConfigurer接口。在registerStompEndpoints方法中，我们注册了一个WebSocket端点/ws，并且指示Spring使用SockJS。在configureMessageBroker方法中，我们配置了一个简单的消息代理，监听/topic目的地的消息，并指定所有应用程序目的地都以/app为前缀。这样，客户端可以通过/topic/some.dest接收广播消息，通过/app/some.dest发送消息到服务器。

在Spring Boot中创建一个WebSocket客户端，你可以使用WebSocketClient类。以下是一个简单的例子，展示了如何使用Spring的WebSocketClient发送和接收消息。

首先，添加Spring WebSocket的依赖到你的pom.xml文件中：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

然后，你可以创建一个配置类来定义和初始化WebSocket客户端：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.client.standard.StandardWebSocketClient;
 
import javax.annotation.PostConstruct;
 
@Configuration
public class WebSocketClientConfig {
 
    private WebSocketClient webSocketClient;
 
    @PostConstruct
    public void initWebSocketClient() {
        this.webSocketClient = new StandardWebSocketClient();
    }
 
    // 获取WebSocketClient实例的方法
    public WebSocketClient getWebSocketClient() {
        return webSocketClient;
    }
}

最后，你可以使用WebSocketClient连接到服务器并发送接收消息：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.socket.WebSocketHttpHeaders;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.client.WebSocketClient;
 
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
 
public class WebSocketClientRunner {
 
    @Autowired
    private WebSocketClient webSocketClient;
 
    public void startClient(String uri) throws Exception {
        WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
        // 添加自定义头部信息，如果需要的话
        Map<String, Object> handshakeAttributes = new HashMap<>();
 
        final CountDownLatch latch = new CountDownLatch(1);
 
        webSocketClient.doHandshake(new WebSocketHandler() {
            @Override
            public void afterConnectionEstablished(WebSocketSession session) throws Exception {
                // 连接建立后的回调
                latch.countDown();
            }
 
            @Override
            public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
                // 处理接收到的消息
            }
 
            // 其他的方法可以根据需要实现
        }, headers, uri, handshakeAttributes);
 
        latch.await(); // 等待连接完成
        // 发送消息，使用session发送等...
    }
}

在这个例子中，WebSocketClientRunner类使用了WebSocketClient连接到指定的URI，并在连接建立后实现了WebSocketHandler接口来处

from channels.generic.websocket import AsyncWebsocketConsumer
from channels.routing import route
from asgiref.sync import async_to_sync
import redis
 
# 连接到Redis
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)
 
class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        # 连接WebSocket时被调用
        await self.accept()
        await redis_client.hset('chat_consumers', self.channel_name, '')
 
    async def disconnect(self, close_code):
        # 断开WebSocket连接时被调用
        await redis_client.hdel('chat_consumers', self.channel_name)
 
    async def receive(self, text_data):
        # 接收到消息时被调用
        await redis_client.lpush('chat_messages', text_data)
        await self.send_chat_message(text_data)
 
    async def send_chat_message(self, message):
        # 发送消息给所有连接的客户端
        await self.send(text_data=message)
 
    @staticmethod
    async def broadcast_chat_message(message):
        # 广播消息给所有连接的客户端
        for consumer in async_to_sync(redis_client.hkeys)('chat_consumers'):
            await consumer.send_chat_message(message)
 
# 路由定义
application = route('websocket.connect', ChatConsumer.connect) \
              .route('websocket.disconnect', ChatConsumer.disconnect) \
              .route('websocket.receive', ChatConsumer.receive)

这个示例代码展示了如何使用Django Channels和Redis来创建一个简单的WebSocket聊天服务。它包括连接处理、断开连接处理、接收消息处理以及广播消息给所有连接的客户端。这个例子是一个很好的起点，展示了如何将Redis用作存储活跃的WebSocket连接和消息队列。

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.*;
 
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/my-websocket-endpoint")
            .setAllowedOrigins("*"); // 允许所有域进行WebSocket连接
    }
 
    @Bean
    public WebSocketHandler myHandler() {
        // 实现自定义的WebSocketHandler
        return new MyCustomWebSocketHandler();
    }
}

在这个代码实例中，我们定义了一个名为WebSocketConfig的配置类，该类实现了WebSocketConfigurer接口。在registerWebSocketHandlers方法中，我们添加了一个WebSocket处理器myHandler，并将其指向路径/my-websocket-endpoint。我们还设置了setAllowedOrigins("*")，允许所有域通过WebSocket进行连接。这是一个安全的实践，通常在生产环境中会指定具体的域名而不是使用通配符。

同时，我们还定义了一个名为MyCustomWebSocketHandler的WebSocket处理器Bean，这个类需要你自己实现WebSocketHandler接口来处理WebSocket的连接、接收消息、发送消息等逻辑。

错误代码1009通常表示WebSocket连接在服务器端被关闭。在Spring框架中，这可能是因为Servlet容器（如Tomcat）在处理WebSocket时遇到了问题。

解决方法：

1. 检查服务器日志：查看服务器（如Tomcat）的日志文件，以获取关于为何关闭连接的详细信息。
2. 检查WebSocket配置：确保你的Spring配置正确无误，包括注解@EnableWebSocketMessageBroker的使用，以及WebSocketMessageBrokerConfigurer接口的实现。
3. 检查客户端代码：确保客户端代码正确处理WebSocket连接，并且没有任何可能导致连接关闭的错误。
4. 增加容器的日志级别：在你的Servlet容器配置中（如Tomcat的logging.properties文件），增加日志级别可以获取更多关于连接关闭的信息。
5. 检查系统资源：有时候，服务器可能因为资源限制（如内存不足）而关闭连接。检查服务器资源并进行适当调整。
6. 升级Spring和Servlet容器版本：如果你使用的是旧版本的Spring或Servlet容器，尝试升级到最新稳定版本。
7. 使用不同的浏览器或设备：有时候，问题可能是特定于浏览器或设备的，尝试使用不同的环境测试。
8. 网络问题：检查是否有任何网络问题导致连接不稳定。

如果以上步骤不能解决问题，可能需要进一步的调试和分析才能找到根本原因。

Spring Cloud Gateway 默认不支持 WebSocket，因为 WebSocket 是一个持久化的连接，而 Spring Cloud Gateway 当前版本（2021 年初）不支持 WebSocket 路由。

但是，你可以使用 Spring Cloud Gateway 的过滤器（Filter）来尝试实现 WebSocket 的转发。一个可能的解决方案是自定义一个过滤器来处理 WebSocket 的握手请求，并将其转发到后端服务。

以下是一个简化的例子，展示了如何创建一个自定义的网关过滤器来处理 WebSocket 的转发：

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
import java.net.URI;
 
public class WebsocketGlobalFilter implements GlobalFilter, Ordered {
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
 
        // 检查是否为 WebSocket 握手请求
        if ("websocket".equals(request.getHeaders().getUpgrade())) {
            // 修改原始请求的 URL 以指向后端服务地址
            URI url = request.getURI();
            String newUrl = "ws://your-websocket-service-url"; // 替换为你的WebSocket服务地址
            ServerHttpRequest newRequest = request.mutate().uri(URI.create(newUrl)).build();
 
            // 使用新的 URL 进行转发
            return chain.filter(exchange.mutate().request(newRequest).build());
        }
 
        // 不是 WebSocket 握手请求则继续正常的 Gateway 处理流程
        return chain.filter(exchange);
    }
 
    @Override
    public int getOrder() {
        // 确保这个过滤器在 WebSocketHandler 之前执行
        return -1;
    }
}

然后，你需要将这个过滤器注册到你的 Spring Cloud Gateway 路由中：

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.builder.Routes;
 
@Configuration
public class GatewayConfig {
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("websocket_route", r -> r.path("/ws/**")
                        .filters(f -> f.filter(new WebsocketGlobalFilter()))
                        .uri("your-websocket-service-uri")) // 替换为你的WebSocket服务地址
                .build();
    }
}

请注意，这个示例代码是基于假设的条件编写的，并且可能需要进行一些额外的配置或者错误处理。此外，WebSocket 的转发可能会遇到与 WebSocket 协议相关的复杂问题，如协议不匹配、握手失败等。在实际应用中，你可能需要对 WebSocket 的握手过程和消息传递做更深入的了解。

from pwn import *
 
# 设置pwntools的context，以便在不同的平台上正确地设置字节序和架构
context.update(os='linux', arch='amd64', endian='little')
 
# 定义一个函数来生成WebSocket的handshake请求
def handshake(host, path):
    # 创建一个TCP连接
    s = remote(host, 80)
 
    # 构造WebSocket的握手请求
    request = (
        "GET " + path + " HTTP/1.1\r\n"
        "Host: " + host + "\r\n"
        "Upgrade: websocket\r\n"
        "Connection: Upgrade\r\n"
        "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
        "Sec-WebSocket-Version: 13\r\n\r\n"
    )
 
    # 发送请求
    s.send(request)
 
    # 接收响应
    banner = s.recv()
 
    # 关闭连接
    s.close()
 
    return banner
 
# 使用函数并打印结果
banner = handshake('your-vulnerable-host.com', '/ws')
print(banner)

这段代码使用了pwntools库来简化了对WebSocket握手请求的发送过程。它定义了一个handshake函数，该函数接受目标主机的地址和路径作为参数，创建一个TCP连接，构造了一个WebSocket握手请求，发送请求，接收响应，然后关闭连接并返回响应数据。这个函数可以用来测试Apache Tomcat服务器是否存在CVE-2020-13935漏洞。