同事吹只需简单调用腾讯云DeepSeek API，就能实现智能AI客服？我表示...

环境说明：Windows 10 + IntelliJ IDEA 2021.3.2 + Jdk 1.8

package org.example;

public class Main {

    public static void main(String[] args) {
        String sid = Session.getSessionId();
        System.out.println("session id: " + sid);
//        HttpSSE sseClient = new HttpSSE();
//        sseClient.sseInvoke("你是谁", sid);
        String reqId = Session.getRequestId();
        System.out.println("request id: " + reqId);
        MyWebSocket webSocketClient = new MyWebSocket();
        webSocketClient.webSocketInvoke("你能回答我一些问题吗？",sid, reqId);
    }
}

package com.hh.common.utils.deepSeek;

import okhttp3.*;
import okhttp3.sse.EventSource;
import okhttp3.sse.EventSourceListener;
import okhttp3.sse.EventSources;
import org.json.JSONException;
import org.json.JSONObject;
import org.springframework.stereotype.Component;

import java.util.concurrent.CountDownLatch;

@Component
public class HttpSSE {

    private final String sseUrl = "https://wss.lke.cloud.tencent.com/v1/qbot/chat/sse"; // SSE 服务器的 URL
    private static String botAppKey = "xxxx"; // 机器人密钥，不是BotBizId (从运营接口人处获取)
    private static String visitorBizId = "202403180002"; //   访客 ID（外部系统提供，需确认不同的访客使用不同的 ID）
    private static String msg = ""; // 用于接收返回的内容。

    // 用 CountDownLatch 确保异步任务完成后再返回结果
    public void sseInvoke(String content, String sid, CountDownLatch latch) {
        OkHttpClient client = new OkHttpClient();

        // 创建 JSON 请求体
        MediaType mediaType = MediaType.get("application/json");
        JSONObject reqBody = new JSONObject();
        try {
            reqBody.put("content", content);
            reqBody.put("bot_app_key", botAppKey);
            reqBody.put("visitor_biz_id", visitorBizId);
            reqBody.put("session_id", sid);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Request request = new Request.Builder()
                .url(sseUrl)
                .post(RequestBody.create(reqBody.toString(), mediaType))
                .build();

        EventSourceListener listener = new EventSourceListener() {
            @Override
            public void onOpen(EventSource eventSource, Response response) {
                System.out.println("SSE connection opened");
            }

            @Override
            public void onClosed(EventSource eventSource) {
                System.out.println("SSE connection closed");
            }

            @Override
            public void onEvent(EventSource eventSource, String id, String type, String data) {
                if (type.equals("reply")) {
                    try {
                        JSONObject dataObj = new JSONObject(data);
                        JSONObject payload = dataObj.getJSONObject("payload");
                        if (payload.length() > 0) {
                            boolean isFromSelf = payload.getBoolean("is_from_self");
                            boolean isFinal = payload.getBoolean("is_final");
                            String content = payload.getString("content");
                            if (isFromSelf) {
                                System.out.println("is_from_self, event: " + type + ", content: " + content);
                            } else if (isFinal) {
                                msg = content;
                                latch.countDown(); // 确保异步任务完成
                            }
                        }
                    } catch (JSONException e) {
                        throw new RuntimeException(e);
                    }
                } else {
                    System.out.println("Received SSE event: " + type);
                }
            }

            @Override
            public void onFailure(EventSource eventSource, Throwable t, Response response) {
                System.err.println("Error occurred: " + t.getMessage());
                latch.countDown(); // 确保错误时也能够结束
            }
        };

        EventSource.Factory factory = EventSources.createFactory(client);
        factory.newEventSource(request, listener);
    }

    // 更新后的 receiveMsg 方法，使用 CountDownLatch 等待结果
    public String receiveMsg(String content) {
        String sid = Session.getSessionId();
        System.out.println("session id: " + sid);

        CountDownLatch latch = new CountDownLatch(1); // 用于等待异步任务完成
        HttpSSE sseClient = new HttpSSE();
        sseClient.sseInvoke(content, sid, latch);

        try {
            latch.await(); // 等待异步任务完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return msg; // 返回最终接收到的消息
    }

    public static void main(String[] args) {
        HttpSSE sseClient = new HttpSSE();
        String response = sseClient.receiveMsg("好朋友科技上市有望吗？"); // 调用 SSE 接口，发送测试消息
        System.out.println("最终接收到的回复: " + response);
    }
}

    @ApiOperation("智能问答")
    @PostMapping("/sendMsg")
    public R<String> sendMsg(@RequestBody SendMsgModel model) {
        return R.ok(deepSeekService.sendMsg(model));
    }

    //智能问答
    String sendMsg(SendMsgModel model);

@Component
public class DeepSeekServiceImpl implements DeepSeekService {
    @Resource
    private HttpSSE httpSSE;

    @Override
    public String sendMsg(SendMsgModel model) {
        System.out.println("问题为：" + model.getMsg());
        String content = httpSSE.receiveMsg(model.getMsg());
        System.out.println("回答为：" + content);
        return content;
    }
}

data = {
    "document": "这是一个包含常见问题的文档，问题包括：如何注册、如何重置密码等。"
}

response = requests.post(url, headers=headers, json=data)
parsed_document = response.json()

embedding_url = "https://api.deeplake.com/v1/embedding"
embedding_data = {
    "text": "如何重置密码？"
}

embedding_response = requests.post(embedding_url, headers=headers, json=embedding_data)
embedding_result = embedding_response.json()

rewrite_url = "https://api.deeplake.com/v1/rewrite"
rewrite_data = {
    "text": "我忘记密码了，该怎么办？"
}

rewrite_response = requests.post(rewrite_url, headers=headers, json=rewrite_data)
optimized_answer = rewrite_response.json()