java Springboot使用扣子Coze实现实时音频对话智能客服功能

 <dependency>
            <groupId>com.coze</groupId>
            <artifactId>coze-api</artifactId>
            <version>0.3.0</version>
</dependency>
<!-- 以下非必须！！！！我把私钥文件放到resources下了，所以打包需要加上这个类型->
<build>
      <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.pem</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

@Slf4j
@Component
public class CozeOAuth {
    /**
     * JWT鉴权token
     */
    public String getJWTToken() {
        String token = "";
        try {
            // 获取私钥文件
            String jwtOauthPrivateKeyFilePath = "这里是你的私钥文件地址";
            ClassLoader classLoader = this.getClass().getClassLoader();
            java.net.URL resourceUrl = classLoader.getResource(jwtOauthPrivateKeyFilePath);
            if (resourceUrl == null) {
                log.info("私钥资源文件未找到，{}", jwtOauthPrivateKeyFilePath);
                return token;
            }
            String jwtOauthPrivateKey = new String(
                    Files.readAllBytes(Paths.get(resourceUrl.toURI())), StandardCharsets.UTF_8);
            JWTOAuthClient oauth = new JWTOAuthClient.JWTOAuthBuilder()
                    .clientID("这里是你之前创建的OAuth应用Id")
                    .privateKey(jwtOauthPrivateKey)
                    .publicKey("这里是你的公钥")
                    .baseURL(com.coze.openapi.service.config.Consts.COZE_CN_BASE_URL)
                    .build();
            // 获取token
            OAuthToken resp = oauth.getAccessToken();
            System.out.println(resp);
            if (Objects.nonNull(resp)) {
                token = resp.getAccessToken();
            }
        } catch (Exception e) {
            log.error("获取coze JWT token异常！", e);
        }
        log.info("获取coze JWT token：{}", token);
        return token;
    }
}

@Slf4j
public class MyWebsocketsChatCallbackHandler extends WebsocketsChatCallbackHandler {
    public void onChatCreated(WebsocketsChatClient client, ChatCreatedEvent event) {
        log.info("扣子服务端返回，对话连接成功,{}", JSON.toJSONString(event));
    }
    public void onChatUpdated(WebsocketsChatClient client, ChatUpdatedEvent event) {
        log.info("扣子服务端返回，对话配置成功,{}", JSON.toJSONString(event));
    }
    public void onConversationChatCreated(WebsocketsChatClient client, ConversationChatCreatedEvent event) {
        log.info("扣子服务端返回，对话开始,{}", JSON.toJSONString(event));
    }
    public void onConversationChatInProgress(WebsocketsChatClient client, ConversationChatInProgressEvent event) {
        log.info("扣子服务端返回，对话正在处理,{}", JSON.toJSONString(event));
    }
    public void onConversationMessageDelta(WebsocketsChatClient client, ConversationMessageDeltaEvent event) {
        log.info("扣子服务端返回，增量消息,{}", JSON.toJSONString(event));
    }
    public void onConversationAudioDelta(WebsocketsChatClient client, ConversationAudioDeltaEvent event) {
        log.info("扣子服务端返回，增量语音,{}", JSON.toJSONString(event));
       // TODO 处理实际业务，比如返回给用户的语音
    }
    public void onConversationMessageCompleted(WebsocketsChatClient client, ConversationMessageCompletedEvent event) {
        log.info("扣子服务端返回，消息完成,{}", JSON.toJSONString(event));
    }
    public void onConversationAudioCompleted(WebsocketsChatClient client, ConversationAudioCompletedEvent event) {
        log.info("扣子服务端返回，语音回复完成,{}", JSON.toJSONString(event));
    }
    public void onConversationChatCompleted(WebsocketsChatClient client, ConversationChatCompletedEvent event) {
        log.info("扣子服务端返回，对话完成,{}", JSON.toJSONString(event));
    }
    public void onConversationChatFailed(WebsocketsChatClient client, ConversationChatFailedEvent event) {
        log.info("扣子服务端返回，对话失败,{}", JSON.toJSONString(event));
    }
    public void onInputAudioBufferCompleted(WebsocketsChatClient client, InputAudioBufferCompletedEvent event) {
        log.info("扣子服务端返回，流式提交的音频完成,{}", JSON.toJSONString(event));
    }
    public void onInputAudioBufferCleared(WebsocketsChatClient client, InputAudioBufferClearedEvent event) {
        log.info("扣子服务端返回，清除缓冲区音频成功,{}", JSON.toJSONString(event));
    }
    public void onConversationCleared(WebsocketsChatClient client, ConversationClearedEvent event) {
        log.info("扣子服务端返回，上下文清除完成,{}", JSON.toJSONString(event));
    }
    public void onConversationChatCanceled(WebsocketsChatClient client, ConversationChatCanceledEvent event) {
        log.info("扣子服务端返回，智能体输出中断,{}", JSON.toJSONString(event));
    }
    public void onConversationAudioTranscriptUpdate(WebsocketsChatClient client, ConversationAudioTranscriptUpdateEvent event) {
        log.info("扣子服务端返回，用户语音识别字幕,{}", JSON.toJSONString(event));
    }
    public void onConversationAudioTranscriptCompleted(WebsocketsChatClient client, ConversationAudioTranscriptCompletedEvent event) {
        log.info("扣子服务端返回，用户语音识别完成,{}", JSON.toJSONString(event));
    }
    public void onConversationChatRequiresAction(WebsocketsChatClient client, ConversationChatRequiresActionEvent event) {
        log.info("扣子服务端返回，端插件请求,{}", JSON.toJSONString(event));
    }
    public void onInputAudioBufferSpeechStarted(WebsocketsChatClient client, InputAudioBufferSpeechStartedEvent event) {
        log.info("扣子服务端返回，用户开始说话,{}", JSON.toJSONString(event));
    }
    public void onInputAudioBufferSpeechStopped(WebsocketsChatClient client, InputAudioBufferSpeechStoppedEvent event) {
        log.info("扣子服务端返回，用户结束说话,{}", JSON.toJSONString(event));
    }
    public void onClosing(WebsocketsChatClient client, int code, String reason) {
        log.info("扣子服务端返回，onClosing,code：{}，reason：{}",code, reason);
    }
    public void onClosed(WebsocketsChatClient client, int code, String reason) {
        log.info("扣子服务端返回，onClosed,code:{},reason：{}", code,reason);
    }
    public void onError(WebsocketsChatClient client, ErrorEvent event) {
        log.info("扣子服务端返回，onError,event：{}", JSON.toJSONString(event));
    }
    public void onFailure(WebsocketsChatClient client, Throwable t) {
        log.info("扣子服务端返回，onFailure,event：{}", JSON.toJSONString(t));
    }
    public void onClientException(WebsocketsChatClient client, Throwable t) {
        log.info("扣子服务端返回，onFailure,event：{}", JSON.toJSONString(t.getMessage()));
    }
}

@Slf4j
@Component
public class WebSocketUtils {
    @Resource
    private CozeOAuth cozeOAuth;
    /**
     * 更新对话配置 请求参数
     */
    public ChatUpdateEventData initChatUpdateEventData() {
        // 对话配置
        ChatConfig chatConfig = new ChatConfig();
        chatConfig.setAutoSaveHistory(true);
        // 输入音频格式
        InputAudio inputAudio = new InputAudio("pcm", "g711a", 8000, 1, 16);
       PCMConfig pcmConfig = new PCMConfig(100,8000);
        // 输出音频格式
        OutputAudio outputAudio = new OutputAudio("pcm", pcmConfig, null, null, null);
        // 转检测配置
        // server_vad 模式下，VAD 检测到语音之前要包含的音频量，单位为 ms。默认为 600ms。
        // server_vad 模式下，检测语音停止的静音持续时间，单位为 ms。默认为 500ms
        TurnDetection turnDetection = new TurnDetection("server_vad", 300, 500);
        return cChatUpdateEventData.builder()
                .inputAudio(inputAudio)
                .outputAudio(outputAudio)
                .chatConfig(chatConfig)
                .turnDetection(turnDetection)
                .build();
    }
    public CozeAPI getCozeApi(){
        return new CozeAPI.Builder()
                .baseURL(Consts.COZE_CN_BASE_URL)
                .auth(new TokenAuth(cozeOAuth.getJWTToken()))
                .readTimeout(10000)
                .build();
    }
}

        byte[] buffer = new byte[1500];
        CozeAPI cozeAPI = webSocketUtils.getCozeApi();
        WebsocketsChatClient websocketsChatClient = cozeAPI.websockets()
                .chat()
                .create(new WebsocketsChatCreateReq("这里是你的智能体ID", new MyWebsocketsChatCallbackHandler()));
        // 更新对话配置               
        websocketsChatClient.chatUpdate(webSocketUtils.initChatUpdateEventData());
        // 此处可以根据实际业务接收语音流
        byte[] audioData = 
        Files.readAllBytes(Paths.get("/音频.pcm"));
        // 流式上传音频片段
        websocketsChatClient.inputAudioBufferAppend(audioData);