spring 起一个 webSocket 接口，将音频数据以流的方式每隔1s钟，写入1024字节

最新推荐文章于 2025-03-13 10:55:58 发布

qq_33192454

最新推荐文章于 2025-03-13 10:55:58 发布

阅读量2.4k

点赞数 30

文章标签： websocket 网络协议网络

本文链接：https://blog.csdn.net/qq_33192454/article/details/140447225

版权

在 Spring 中使用 WebSocket 接口可以实现实时传输音频数据。下面是一个实现示例，包括前端和后端代码。

后端代码

首先，我们需要设置 WebSocket 配置和处理器。

1. WebSocket 配置

创建一个 WebSocket 配置类来注册 WebSocket 端点。

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(new AudioStreamHandler(), "/audio-stream").setAllowedOrigins("*");
    }
}

2. WebSocket 处理器

创建一个 WebSocket 处理器来处理音频流的发送。

import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.BinaryWebSocketHandler;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class AudioStreamHandler extends BinaryWebSocketHandler {

    private final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // Start streaming audio data
        executorService.scheduleAtFixedRate(new AudioStreamTask(session), 0, 1, TimeUnit.SECONDS);
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        exception.printStackTrace();
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        executorService.shutdown();
    }

    private static class AudioStreamTask implements Runnable {
        private static final String AUDIO_FILE_PATH = "path/to/your/audio/file.mp3";
        private final WebSocketSession session;
        private FileInputStream fileInputStream;

        public AudioStreamTask(WebSocketSession session) {
            this.session = session;
            try {
                this.fileInputStream = new FileInputStream(AUDIO_FILE_PATH);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            try {
                if (session.isOpen() && fileInputStream != null) {
                    byte[] buffer = new byte[1024];
                    int bytesRead = fileInputStream.read(buffer);

                    if (bytesRead == -1) {
                        session.close();
                        fileInputStream.close();
                        return;
                    }

                    session.sendMessage(new BinaryMessage(buffer, 0, bytesRead));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

前端代码

前端代码使用 JavaScript WebSocket API 来接收音频数据并将其播放。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WebSocket Audio Stream</title>
</head>
<body>
    <button id="playAudio">Play Audio</button>
    <audio id="audioPlayer" controls></audio>

    <script>
        document.getElementById('playAudio').addEventListener('click', () => {
            const audioPlayer = document.getElementById('audioPlayer');
            const mediaSource = new MediaSource();
            audioPlayer.src = URL.createObjectURL(mediaSource);

            mediaSource.addEventListener('sourceopen', () => {
                const mimeCodec = 'audio/mpeg';
                const sourceBuffer = mediaSource.addSourceBuffer(mimeCodec);
                let websocket = new WebSocket('ws://localhost:8080/audio-stream');
                
                websocket.binaryType = 'arraybuffer';
                
                websocket.onmessage = (event) => {
                    const data = new Uint8Array(event.data);
                    sourceBuffer.appendBuffer(data);
                };

                websocket.onclose = () => {
                    mediaSource.endOfStream();
                };
            });
        });
    </script>
</body>
</html>

说明

后端 WebSocket 配置：
- WebSocketConfig：配置 WebSocket 端点。
- AudioStreamHandler：处理 WebSocket 连接和音频数据的发送。
前端 WebSocket 连接：
- 通过 MediaSource 对象创建一个媒体流。
- 使用 WebSocket 接收音频数据，并将其追加到 SourceBuffer 中。

注意事项

请确保路径 path/to/your/audio/file.mp3 是正确的，并且音频文件存在。
在生产环境中，请配置 CORS 和 WebSocket 安全设置。
确保服务器和客户端的 WebSocket 连接地址（ws://localhost:8080/audio-stream）是正确的。

springboot 起一个 webSocket 接口，将音频数据以流的方式每隔1s钟，写入1024字节

了解了。我们需要在 Spring Boot 应用中创建一个 WebSocket 服务，向客户端发送音频数据，每秒钟写入 1024 字节。以下是详细的步骤和代码示例：

步骤

配置 WebSocket 端点。
实现 WebSocket 处理器。
前端代码接收并播放音频数据。

后端代码

1. 配置 WebSocket 端点

创建一个 WebSocket 配置类，用于注册 WebSocket 端点。

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(new AudioStreamHandler(), "/audio-stream").setAllowedOrigins("*");
    }
}

2. 实现 WebSocket 处理器

创建一个 WebSocket 处理器来处理音频流的发送。

import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.BinaryWebSocketHandler;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class AudioStreamHandler extends BinaryWebSocketHandler {

    private final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // Start streaming audio data
        executorService.scheduleAtFixedRate(new AudioStreamTask(session), 0, 1, TimeUnit.SECONDS);
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        exception.printStackTrace();
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        executorService.shutdown();
    }

    private static class AudioStreamTask implements Runnable {
        private static final String AUDIO_FILE_PATH = "path/to/your/audio/file.mp3";
        private final WebSocketSession session;
        private FileInputStream fileInputStream;

        public AudioStreamTask(WebSocketSession session) {
            this.session = session;
            try {
                this.fileInputStream = new FileInputStream(AUDIO_FILE_PATH);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            try {
                if (session.isOpen() && fileInputStream != null) {
                    byte[] buffer = new byte[1024];
                    int bytesRead = fileInputStream.read(buffer);

                    if (bytesRead == -1) {
                        session.close();
                        fileInputStream.close();
                        return;
                    }

                    session.sendMessage(new BinaryMessage(buffer, 0, bytesRead));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

前端代码

前端代码使用 JavaScript WebSocket API 来接收音频数据并将其播放。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WebSocket Audio Stream</title>
</head>
<body>
    <button id="playAudio">Play Audio</button>
    <audio id="audioPlayer" controls></audio>

    <script>
        document.getElementById('playAudio').addEventListener('click', () => {
            const audioPlayer = document.getElementById('audioPlayer');
            const mediaSource = new MediaSource();
            audioPlayer.src = URL.createObjectURL(mediaSource);

            mediaSource.addEventListener('sourceopen', () => {
                const mimeCodec = 'audio/mpeg';
                const sourceBuffer = mediaSource.addSourceBuffer(mimeCodec);
                const websocket = new WebSocket('ws://localhost:8080/audio-stream');

                websocket.binaryType = 'arraybuffer';
                websocket.onmessage = (event) => {
                    const data = new Uint8Array(event.data);
                    if (!sourceBuffer.updating) {
                        sourceBuffer.appendBuffer(data);
                    } else {
                        sourceBuffer.addEventListener('updateend', () => {
                            sourceBuffer.appendBuffer(data);
                        }, { once: true });
                    }
                };

                websocket.onclose = () => {
                    mediaSource.endOfStream();
                };
            });
        });
    </script>
</body>
</html>

说明

后端 WebSocket 配置：
- WebSocketConfig：配置 WebSocket 端点 /audio-stream。
- AudioStreamHandler：处理 WebSocket 连接并发送音频数据，每秒发送 1024 字节。
前端 WebSocket 连接：
- 使用 MediaSource 对象和 SourceBuffer 处理接收的音频数据。
- 使用 WebSocket 接收音频数据并将其追加到 SourceBuffer 中。
- 通过 updateend 事件确保在 SourceBuffer 完成更新后再追加新的数据。

注意事项

请确保路径 path/to/your/audio/file.mp3 是正确的，并且音频文件存在。
在生产环境中，请配置 CORS 和 WebSocket 安全设置。
确保服务器和客户端的 WebSocket 连接地址（ws://localhost:8080/audio-stream）是正确的。

通过这种方式，后端可以以流的方式每秒发送 1024 字节音频数据，前端实时接收并播放音频数据。

Spring boot钟没有WebSocketConfigurer

在 Spring Boot 中，如果你没有看到 WebSocketConfigurer，请确保你的项目引入了 spring-boot-starter-websocket 依赖。这个依赖包含了 WebSocket 的相关类和接口。以下是一个完整的 Spring Boot 项目示例，包括必要的依赖配置和完整的代码实现。

添加依赖

首先，确保你的 pom.xml 文件包含 WebSocket 依赖：

xml<dependencies> <!-- Other dependencies --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> </dependencies>

创建 WebSocket 配置类

使用 WebSocketHandlerRegistry 来注册 WebSocket 端点。

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(new AudioStreamHandler(), "/audio-stream").setAllowedOrigins("*");
    }
}

创建 WebSocket 处理器

实现一个 WebSocket 处理器类来处理音频流的发送。

import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.BinaryWebSocketHandler;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class AudioStreamHandler extends BinaryWebSocketHandler {

    private final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // Start streaming audio data
        executorService.scheduleAtFixedRate(new AudioStreamTask(session), 0, 1, TimeUnit.SECONDS);
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        exception.printStackTrace();
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        executorService.shutdown();
    }

    private static class AudioStreamTask implements Runnable {
        private static final String AUDIO_FILE_PATH = "path/to/your/audio/file.mp3";
        private final WebSocketSession session;
        private FileInputStream fileInputStream;

        public AudioStreamTask(WebSocketSession session) {
            this.session = session;
            try {
                this.fileInputStream = new FileInputStream(AUDIO_FILE_PATH);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            try {
                if (session.isOpen() && fileInputStream != null) {
                    byte[] buffer = new byte[1024];
                    int bytesRead = fileInputStream.read(buffer);

                    if (bytesRead == -1) {
                        session.close();
                        fileInputStream.close();
                        return;
                    }

                    session.sendMessage(new BinaryMessage(buffer, 0, bytesRead));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

前端代码

使用 JavaScript WebSocket API 来接收音频数据并将其播放。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WebSocket Audio Stream</title>
</head>
<body>
    <button id="playAudio">Play Audio</button>
    <audio id="audioPlayer" controls></audio>

    <script>
        document.getElementById('playAudio').addEventListener('click', () => {
            const audioPlayer = document.getElementById('audioPlayer');
            const mediaSource = new MediaSource();
            audioPlayer.src = URL.createObjectURL(mediaSource);

            mediaSource.addEventListener('sourceopen', () => {
                const mimeCodec = 'audio/mpeg';
                const sourceBuffer = mediaSource.addSourceBuffer(mimeCodec);
                const websocket = new WebSocket('ws://localhost:8080/audio-stream');

                websocket.binaryType = 'arraybuffer';
                websocket.onmessage = (event) => {
                    const data = new Uint8Array(event.data);
                    if (!sourceBuffer.updating) {
                        sourceBuffer.appendBuffer(data);
                    } else {
                        sourceBuffer.addEventListener('updateend', () => {
                            sourceBuffer.appendBuffer(data);
                        }, { once: true });
                    }
                };

                websocket.onclose = () => {
                    mediaSource.endOfStream();
                };
            });
        });
    </script>
</body>
</html>

运行项目

启动 Spring Boot 应用：确保 Spring Boot 应用运行。
启动前端 HTML 页面：使用浏览器打开 HTML 文件。

通过这种方式，后端可以每秒发送 1024 字节音频数据，前端可以实时接收并播放音频数据。确保路径 path/to/your/audio/file.mp3 是正确的，并且音频文件存在。

AudioStreamHandler 这个是那个jar中的

AudioStreamHandler 不是 Spring Boot 中的内置类或库。它是一个自定义的 WebSocket 处理器，你需要在你的项目中创建这个类。我之前提供的代码示例中，AudioStreamHandler 是一个简单的内部静态类，用于处理 WebSocket 连接并发送音频数据。

你需要在你的 Spring Boot 项目中创建这个类，并确保它能够被正确地引用和注册。通常情况下，这个类应该位于你的项目包结构下，例如 com.example.websocket 包中。

你可以将上面提供的 AudioStreamHandler 类复制到你的项目中，并根据你的需求进行调整。然后，确保在 WebSocket 配置中将它注册为 WebSocket 端点。

websocket 跟spring-boot的哪些包有冲突

WebSocket 在 Spring Boot 中通常不会与其他核心包产生冲突，但可能会与其他 WebSocket 实现或一些第三方库产生冲突。在使用 WebSocket 时，可能会遇到一些常见的冲突情况，以下是一些可能导致冲突的因素：

依赖冲突：当引入的依赖包含了自己的 WebSocket 实现或依赖，可能会与 Spring Boot 中的 WebSocket 实现产生冲突。要避免这种情况，可以检查你的依赖，并确保它们与 Spring Boot 兼容。
端口冲突：如果你的 Spring Boot 应用程序使用了 WebSocket，确保你的应用程序使用的端口没有被其他应用程序占用。WebSocket 默认使用的端口是 8080，如果这个端口已经被其他程序占用了，可能会导致冲突。
注解冲突：如果你的 WebSocket 控制器使用了与其他 Spring 注解（如 @RestController、@Controller 等）相冲突的注解，可能会导致一些意外的行为或错误。
版本冲突：如果你在使用 Spring Boot 的同时，还在同一项目中使用了其他与 WebSocket 相关的库，并且这些库的版本与 Spring Boot 中的版本不兼容，可能会导致冲突。

为了避免这些冲突，你可以：

仔细管理你的项目依赖，确保它们与 Spring Boot 兼容，并且不会产生冲突。
确保你的应用程序使用的端口没有被其他应用程序占用。
当引入其他库或框架时，查看它们的文档并检查它们是否与 Spring Boot 兼容。
将 WebSocket 控制器与其他控制器分开，并避免在同一控制器中使用与其他 Spring 注解相冲突的注解。

通过这些方法，你应该能够避免大多数与 WebSocket 相关的冲突。如果你遇到了特定的冲突或问题，请提供更多的细节，我将尽力提供帮助。

@Configuration @EnableWebSocket 加完着两个注解后，启动报错：but was actually of type 'org.springframework.beans.factory.support,NullBean'

启动报错可能是因为 Spring 容器无法正确初始化 WebSocket 配置。通常情况下，添加 @Configuration 和 @EnableWebSocket 注解应该是没有问题的，但是在特定情况下可能会出现一些问题，例如：

依赖问题：确保你的项目中引入了正确的 WebSocket 相关依赖。Spring Boot 通常会自动配置 WebSocket 相关的依赖，但是如果你手动引入了不兼容的依赖，可能会导致冲突或错误。
包扫描问题：Spring Boot 默认会扫描 @Configuration 注解的类以及其他的 Spring 组件。如果你的 WebSocket 配置类位于不同的包中，可能会导致扫描不到的问题。你可以尝试使用 @ComponentScan 注解来指定要扫描的包。
其他配置问题：检查其他与 WebSocket 相关的配置，确保没有其他的配置与 WebSocket 配置产生冲突。

如果以上方法都无法解决问题，我建议你提供更多的信息，例如完整的错误信息、其他相关的配置类以及依赖信息，这样我可以更好地帮助你解决问题。

spring boot 还有其他方式来实现 websocket 么

是的，Spring Boot 中除了使用 @Configuration 和 @EnableWebSocket 注解外，还可以使用 @Bean 注解来注册 WebSocket 处理器和 WebSocket 端点。这种方式更加灵活，可以更精确地控制 WebSocket 相关的配置。

以下是使用 @Bean 注解来配置 WebSocket 的示例：

import org.springframework.context.annotation.Bean;
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(audioStreamHandler(), "/audio-stream").setAllowedOrigins("*");
    }

    @Bean
    public AudioStreamHandler audioStreamHandler() {
        return new AudioStreamHandler();
    }
}

在这个例子中，我们移除了 AudioStreamHandler 类上的 @Component 注解，并通过 @Bean 注解来声明它作为一个 Bean。然后在 WebSocketConfig 配置类中通过调用 audioStreamHandler() 方法来获取 AudioStreamHandler 实例，并将其注册为 WebSocket 端点处理器。

这种方式可以更加灵活地控制 WebSocket 的配置，并且可以避免一些不必要的自动配置行为。如果你遇到了在使用 @Configuration 和 @EnableWebSocket 注解时无法解决的问题，可以尝试使用 @Bean 注解的方式来配置 WebSocket。

ScheduledExecutorService websocket 注入这个线程池干啥，我就是最简单的即可

对于简单的 WebSocket 应用，你可能不需要使用 ScheduledExecutorService。ScheduledExecutorService 是一个用于执行定时任务的线程池，在某些情况下可以用来定时向客户端发送数据或执行一些后台任务。

在 WebSocket 应用中，通常的做法是创建一个 WebSocket 处理器，在客户端连接建立后，处理器负责接收客户端的请求并发送响应。如果你的需求比较简单，只是要实现一个简单的 WebSocket 服务，你可以不使用 ScheduledExecutorService。

下面是一个简单的 WebSocket 处理器示例，不使用 ScheduledExecutorService：

import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.BinaryWebSocketHandler;

import java.io.IOException;

public class SimpleWebSocketHandler extends BinaryWebSocketHandler {

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        super.afterConnectionEstablished(session);
        System.out.println("WebSocket connection established");
    }

    @Override
    protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) throws Exception {
        // Handle binary message from client
        byte[] data = message.getPayload().array();
        // Process binary data
        // Example: echo back the received data
        session.sendMessage(new BinaryMessage(data));
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        super.afterConnectionClosed(session, status);
        System.out.println("WebSocket connection closed");
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        super.handleTransportError(session, exception);
        System.out.println("WebSocket transport error: " + exception.getMessage());
    }
}

在这个示例中，SimpleWebSocketHandler 类继承自 BinaryWebSocketHandler，并重写了一些方法来处理 WebSocket 连接、接收消息、发送消息以及处理连接关闭和传输错误等情况。

你可以将这个处理器注册到你的 WebSocket 配置中，并在客户端连接建立后处理客户端的请求。

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(new SimpleWebSocketHandler(), "/websocket");
    }
}

这样，当客户端连接到 ws://your-server/websocket 时，SimpleWebSocketHandler 将会处理客户端的请求。

我需要每隔1s钟把音频文件写入到流里面，

如果你需要每隔1秒将音频文件写入到流中，你可以使用 ScheduledExecutorService 来定时执行

import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class AudioStreamer {

    private static final String AUDIO_FILE_PATH = "path/to/your/audio/file.mp3";
    private static final int PORT = 8888;

    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(PORT);
            System.out.println("Server started on port " + PORT);

            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress());

                OutputStream outputStream = clientSocket.getOutputStream();

                ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
                executorService.scheduleAtFixedRate(new AudioStreamTask(outputStream), 0, 1, TimeUnit.SECONDS);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class AudioStreamTask implements Runnable {
        private final OutputStream outputStream;
        private FileInputStream fileInputStream;

        public AudioStreamTask(OutputStream outputStream) {
            this.outputStream = outputStream;
            try {
                this.fileInputStream = new FileInputStream(AUDIO_FILE_PATH);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            try {
                byte[] buffer = new byte[1024];
                int bytesRead;
                while ((bytesRead = fileInputStream.read(buffer)) != -1) {
                    outputStream.write(buffer, 0, bytesRead);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (fileInputStream != null) {
                        fileInputStream.close();
                    }
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

这个示例创建了一个简单的服务器，它监听指定的端口，并在接受到客户端连接后，每隔1秒钟向客户端写入音频文件。请确保将 "path/to/your/audio/file.mp3" 替换为实际的音频文件路径，并根据需要调整端口号。

springboot 起一个 webSocket 接口，将音频数据以流的方式每隔1s钟，写入1024字节，不要使用线程池

理解了，你想要在 Spring Boot 中创建一个 WebSocket 接口，每隔1秒将音频数据以流的方式写入到客户端。以下是一个简单的实现，不使用线程池：

import org.springframework.stereotype.Component;
import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.BinaryWebSocketHandler;

import java.io.IOException;
import java.io.InputStream;

@Component
public class AudioWebSocketHandler extends BinaryWebSocketHandler {

    private static final String AUDIO_FILE_PATH = "path/to/your/audio/file.mp3";
    private static final int CHUNK_SIZE = 1024;

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        super.afterConnectionEstablished(session);
        sendAudioData(session);
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        super.afterConnectionClosed(session, status);
    }

    private void sendAudioData(WebSocketSession session) {
        try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream(AUDIO_FILE_PATH)) {
            byte[] buffer = new byte[CHUNK_SIZE];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                session.sendMessage(new BinaryMessage(buffer, 0, bytesRead));
                Thread.sleep(1000); // 每隔1秒发送一次数据
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，AudioWebSocketHandler 类继承自 BinaryWebSocketHandler，它是一个 WebSocket 处理器。在 afterConnectionEstablished 方法中，我们调用 sendAudioData 方法来发送音频数据给客户端。在 sendAudioData 方法中，我们从音频文件中读取数据，然后每隔1秒发送一次数据给客户端。

请确保将 "path/to/your/audio/file.mp3" 替换为实际的音频文件路径。这个例子是一个简单的实现，如果你的应用需要更复杂的功能或性能，可能需要更多的调整和优化。

那么前端改如何调用呢

前端使用 WebSocket 来接收音频数据，并根据接收到的数据进行处理和播放。以下是一个简单的前端代码示例，演示了如何使用 JavaScript WebSocket API 来连接到后端的 WebSocket 接口，并接收音频数据：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WebSocket Audio Streaming</title>
</head>
<body>
    <audio controls></audio>

    <script>
        const audioPlayer = document.querySelector('audio');

        const websocket = new WebSocket('ws://localhost:8080/audio-stream');

        websocket.binaryType = 'arraybuffer';

        websocket.onopen = function () {
            console.log('WebSocket connection established');
        };

        websocket.onmessage = function (event) {
            const audioData = event.data;
            audioPlayer.src = URL.createObjectURL(new Blob([audioData], { type: 'audio/mpeg' }));
            audioPlayer.play();
        };

        websocket.onerror = function (event) {
            console.error('WebSocket error:', event);
        };

        websocket.onclose = function () {
            console.log('WebSocket connection closed');
        };
    </script>
</body>
</html>

在这个示例中，前端使用 WebSocket API 创建了一个 WebSocket 连接到后端的 ws://localhost:8080/audio-stream 接口。当 WebSocket 连接建立后，每次接收到消息时，通过创建 Blob 对象来处理接收到的音频数据，并设置到 <audio> 元素的 src 属性上，然后播放音频。

确保你的后端 WebSocket 接口的路径与前端代码中的路径相匹配，并且 WebSocket 服务正常运行。这样，当你运行前端代码时，它就会连接到后端 WebSocket 接口，并接收音频数据进行播放。

springboot 起一个 webSocket 接口，将音频数据以流的方式每隔1s钟，写入1024字节，不要使用线程池，前后端给我完整的例子

好的，下面是一个完整的示例，演示了如何在 Spring Boot 中实现一个 WebSocket 接口，将音频数据以流的方式每隔1秒写入1024字节。

后端代码

首先，创建一个 Spring Boot 项目，并添加以下类：

WebSocketConfig.java：

import org.springframework.context.annotation.Bean;
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(audioWebSocketHandler(), "/audio-stream").setAllowedOrigins("*");
    }

    @Bean
    public AudioWebSocketHandler audioWebSocketHandler() {
        return new AudioWebSocketHandler();
    }
}

AudioWebSocketHandler.java：

import org.springframework.stereotype.Component;
import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.BinaryWebSocketHandler;

import java.io.IOException;
import java.io.InputStream;

@Component
public class AudioWebSocketHandler extends BinaryWebSocketHandler {

    private static final String AUDIO_FILE_PATH = "/path/to/your/audio/file.mp3";
    private static final int CHUNK_SIZE = 1024;

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        super.afterConnectionEstablished(session);
        sendAudioData(session);
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        super.afterConnectionClosed(session, status);
    }

    private void sendAudioData(WebSocketSession session) {
        try (InputStream inputStream = getClass().getResourceAsStream(AUDIO_FILE_PATH)) {
            byte[] buffer = new byte[CHUNK_SIZE];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                session.sendMessage(new BinaryMessage(buffer, 0, bytesRead));
                Thread.sleep(1000); // 每隔1秒发送一次数据
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

前端代码

创建一个 HTML 文件，作为前端页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WebSocket Audio Streaming</title>
</head>
<body>
    <audio controls></audio>

    <script>
        const audioPlayer = document.querySelector('audio');

        const websocket = new WebSocket('ws://localhost:8080/audio-stream');

        websocket.binaryType = 'arraybuffer';

        websocket.onopen = function () {
            console.log('WebSocket connection established');
        };

        websocket.onmessage = function (event) {
            const audioData = event.data;
            audioPlayer.src = URL.createObjectURL(new Blob([audioData], { type: 'audio/mpeg' }));
            audioPlayer.play();
        };

        websocket.onerror = function (event) {
            console.error('WebSocket error:', event);
        };

        websocket.onclose = function () {
            console.log('WebSocket connection closed');
        };
    </script>
</body>
</html>

确保将 "/path/to/your/audio/file.mp3" 替换为实际的音频文件路径，并确保该文件存在。然后运行 Spring Boot 项目和前端 HTML 文件，浏览器中打开 HTML 文件，你就能够在页面中播放音频流了。

前端报错 Error during websocket handshake Unexpected Response code 403

出现状态代码 403 可能是因为 WebSocket 连接受到了拒绝访问的响应。这通常是由于 WebSocket 端点的跨域请求策略导致的。在 Spring Boot 中，默认情况下，WebSocket 端点只允许来自同一源的连接，而不允许跨域连接。

要解决这个问题，你可以尝试以下几种方法之一：

配置允许跨域访问：在 Spring Boot 项目的 WebSocket 配置中添加允许跨域访问的配置。可以通过 setAllowedOrigins("*") 来允许来自任意源的连接。
```
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
    registry.addHandler(audioWebSocketHandler(), "/audio-stream")
            .setAllowedOrigins("*"); // 允许来自任意源的连接
}
```
这样设置允许了所有源的 WebSocket 连接，适用于开发和测试阶段。在生产环境中，建议根据实际需求进行配置，以确保安全性。
确保前端页面和后端 WebSocket 端点在同一源上：将前端页面放置在与 WebSocket 端点相同的源上，以确保它们在同一源上。这样就不会受到跨域访问限制的影响。

例如，在 Spring Boot 项目中，可以将前端页面放置在 src/main/resources/static 目录下，这样它们就可以通过 localhost:8080 访问，与后端 WebSocket 端点在同一源上。

尝试上述方法之一，应该可以解决 WebSocket 连接状态代码 403 的问题。