WebSocket实时通信实战：通义千问服务端集成指南（含完整代码）_通义 model server error!code=-1, error msg is invali-CSDN博客

博客介绍了通义千问相关内容，包括灵积控制台、开发参考等。重点讲解了WebSocket协议，它基于TCP，客户端通过特定HTTP请求与服务器建立连接。还介绍了Spring方式使用WebSocket，如依赖和重写接口方法自定义逻辑，最后给出了通义千问和WebSocket的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

通义千问整合webSocket

模型概览

API详情

传送门
在这里插入图片描述

webSocket

介绍

WebSocket 协议本质上是一个基于 TCP 的协议。
为了建立一个 WebSocket 连接，客户端浏览器首先要向服务器发起一个 HTTP 请求，这个请求和通常的 HTTP 请求不同，包含了一些附加头信息，其中附加头信息"Upgrade: WebSocket"表明这是一个申请协议升级的 HTTP 请求，服务器端解析这些附加的头信息然后产生应答信息返回给客户端，客户端和服务器端的 WebSocket 连接就建立起来了，双方就可以通过这个连接通道自由的传递信息，并且这个连接会持续存在直到客户端或者服务器端的某一方主动的关闭连接。

Spring 方式

一、依赖

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

二、实现WebSocketHandler接口重写其接口方法的方式自定义逻辑

@Component
public class SpringSocketHandle implements WebSocketHandler {

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        System.out.println("SpringSocketHandle, 收到新的连接: " + session.getId());
    }

    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        String msg = "SpringSocketHandle, 连接：" + session.getId() +  "，已收到消息。";
        System.out.println(msg);
        session.sendMessage(new TextMessage(msg));
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        System.out.println("WS 连接发生错误");
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
        System.out.println("WS 关闭连接");
    }

    // 支持分片消息
    @Override
    public boolean supportsPartialMessages() {
        return false;
    }
}

afterConnectionEstablished：连接成功后调用。
handleMessage：处理发送来的消息。
handleTransportError： WS 连接出错时调用。
afterConnectionClosed：连接关闭后调用。
supportsPartialMessages：是否支持分片消息。

handleMessage
handleMessage 方法中有一个 WebSocketMessage 参数，这也是一个接口，我们一般不直接使用这个接口而是使用它的实现类，它有以下几个实现类：
- BinaryMessage：二进制消息体
- TextMessage：文本消息体
- PingMessage： Ping ****消息体
- PongMessage： Pong ****消息体

代码实现

通义千问代码

DashscopeChatController

import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.farbun.fission.config.ChatGPTConfig;
import com.farbun.fission.util.ApiUrl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author: 小新
 * @Date: 2024/1/24 14:45
 */
@RestController
@RequestMapping("/dashscope")
@Slf4j
public class DashscopeChatController {
    @Autowired
    private ChatGPTConfig chatGPTConfig;


    @PostMapping("/dashscopeChat/stream")
    @ResponseBody
    public void dashscopeChat(@RequestBody String message,
                              HttpServletResponse response) {
        log.info("/dashscope/dashscopeChat/stream 接口入参：" + message);
        // message
        Map<String, Object> inputMap = new HashMap<>();
        List list = JSON.parseArray(message).toJavaList(Map.class);
        inputMap.put("messages", list);

        //result_format
        Map<String, Object> parametersMap = new HashMap<>();
        parametersMap.put("result_format","message");

        // request result
        Map<String, Object> chatMap = new HashMap<>();
        chatMap.put("model", "qwen-plus");
        chatMap.put("input", inputMap);
        chatMap.put("parameters",parametersMap);

        String requestData = JSONUtil.toJsonStr(chatMap);
        System.out.println("请求体" + requestData.toString());

        try {
            log.info("开始发送请求");
            URL url = new URL(ApiUrl.dashscopeUrl); //public static String dashscopeUrl = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation";
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("Authorization", "Bearer " + chatGPTConfig.getApiKey());
            conn.setRequestProperty("X-DashScope-SSE","enable"); // SSE
            conn.setDoOutput(true);
            conn.getOutputStream().write(requestData.getBytes(StandardCharsets.UTF_8));

            int responseCode = conn.getResponseCode();
            log.info("HTTP响应代码: {}", responseCode);

            BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            log.info("发送请求结束");
            String line;
            ServletOutputStream outputStream = response.getOutputStream();
            while ((line = reader.readLine()) != null) {
                if (line.contains("data") || line.contains("id")) {
                    outputStream.write(line.getBytes(StandardCharsets.UTF_8));
                    outputStream.flush();
                }
                if (line.contains("stop")){
                    log.info("result: {}", line);
                    break;
                }
            }

        } catch (Exception e) {
            log.error("ERROR:", e);
        }
    }
}

ChatGPTConfig

@Data
@Component
@ConfigurationProperties(prefix = ChatGPTConfig.PREFIX)
public class ChatGPTConfig {

    public static final String PREFIX = "chat.gpt";

    private String chatGptIp;

    private String chatGptPort;

    private String dashscopeGtp;

    private String apiKey;
}

webSocket代码

ChatGptWebSocketBean

import org.springframework.web.socket.WebSocketSession;

public class ChatGptWebSocketBean {

    private WebSocketSession webSocketSession;
    private int clientId;

    public int getClientId() {
        return clientId;
    }

    public void setClientId(int clientId) {
        this.clientId = clientId;
    }
    
    public WebSocketSession getWebSocketSession() {
        return webSocketSession;
    }

    public void setWebSocketSession(WebSocketSession webSocketSession) {
        this.webSocketSession = webSocketSession;
    }
}

ChatGptWebSocketConfiguration

package com.farbun.fission.websocket.chatgpt;

import com.farbun.fission.config.ChatGPTConfig;
import com.farbun.fission.mapper.LbUserMapper;
import com.farbun.fission.mapper.session.LbSessionShareAcquireCountMapper;
import com.farbun.fission.mapper.session.LbSessionSplicingContentMapper;
import com.farbun.fission.mapper.session.LbSessionSplicingRulesMapper;
import com.farbun.fission.mapper.session.LbSessionTopicMapper;
import com.farbun.fission.service.ILbLawyerService;
import com.farbun.fission.service.session.LbSessionMessageService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import redis.clients.jedis.JedisPool;

import javax.annotation.Resource;


@Configuration
public class ChatGptWebSocketConfiguration implements WebSocketConfigurer {

    @Resource(name = "db4RedisTemplate")
    private RedisTemplate<String, String> db4RedisTemplate;
 
    @Resource
    private ChatGPTConfig chatGPTConfig;

    @Resource
    private LbSessionMessageService lbSessionMessageService;
   
    @Resource(name = "JedisPool")
    private JedisPool jedisPool;


    @Bean
    public ChatGptWebSocketInterceptor webSocketInterceptor() {
        ChatGptWebSocketInterceptor socketInterceptor = new ChatGptWebSocketInterceptor();
        socketInterceptor.setRedisTemplate(db4RedisTemplate);
        return socketInterceptor;
    }

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry webSocketHandlerRegistry) {
        ChatGptWebsocketHandler chatGptWebsocketHandler = new ChatGptWebsocketHandler();
        chatGptWebsocketHandler.setLbSessionMessageService(lbSessionMessageService);
        chatGptWebsocketHandler.setChatGPTConfig(chatGPTConfig);
        chatGptWebsocketHandler.setJedisPool(jedisPool);
        webSocketHandlerRegistry.addHandler(chatGptWebsocketHandler, "/gptSocket").addInterceptors(webSocketInterceptor());

    }
}

ChatGptWebSocketInterceptor

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;

import java.util.Map;

@Slf4j
public class ChatGptWebSocketInterceptor extends HttpSessionHandshakeInterceptor {

    private RedisTemplate<String, String> db4RedisTemplate;

    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
        log.info("[ChatGptWebSocketInterceptor#BeforeHandshake] Request from " + request.getRemoteAddress().getHostString());
        if (request instanceof ServletServerHttpRequest) {
            ServletServerHttpRequest serverHttpRequest = (ServletServerHttpRequest) request;
            // 校验token是否存在
            String token = serverHttpRequest.getServletRequest().getHeader("Authentication-token");
            log.info("Authentication-token:{}",token);
            if (StringUtils.isEmpty(token)) {
                log.warn("[ChatGptWebSocketInterceptor#beforeHandshake]未设置认证信息");
                return false;
            }
//            Boolean hasToken = db4RedisTemplate.hasKey("user:token:"+token);
//            if (hasToken == null || !hasToken) {
//                log.warn("[ChatGptWebSocketInterceptor]token:{}无效", token);
//                return false;
//            }
            return super.beforeHandshake(request, response, wsHandler, attributes);
        }
        return super.beforeHandshake(request, response, wsHandler, attributes);
    }

    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception ex) {
        log.info("[ChatGptWebSocketInterceptor#afterHandshake] Request from " + request.getRemoteAddress().getHostString());
    }

    public void setRedisTemplate(RedisTemplate<String, String> db4RedisTemplate) {
        this.db4RedisTemplate = db4RedisTemplate;
    }

}

ChatGptWebsocketHandler

package com.farbun.fission.websocket.chatgpt;

import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.farbun.fission.config.ChatGPTConfig;
import com.farbun.fission.entity.LbLawyer;
import com.farbun.fission.entity.LbUser;
import com.farbun.fission.entity.session.*;
import com.farbun.fission.enums.ProcedureSubjectEnum;
import com.farbun.fission.mapper.LbUserMapper;
import com.farbun.fission.mapper.session.LbSessionShareAcquireCountMapper;
import com.farbun.fission.mapper.session.LbSessionSplicingContentMapper;
import com.farbun.fission.mapper.session.LbSessionSplicingRulesMapper;
import com.farbun.fission.mapper.session.LbSessionTopicMapper;
import com.farbun.fission.service.ILbLawyerService;
import com.farbun.fission.service.session.LbSessionMessageService;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.AbstractWebSocketHandler;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.io.InputStream;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Slf4j
public class ChatGptWebsocketHandler extends AbstractWebSocketHandler {


    private static final Map<String, ChatGptWebSocketBean> webSocketBeanMap;
    private Map<String, LbSessionMessage> sessionMessageMap = new ConcurrentHashMap<>();
    private static final AtomicInteger clientIdMaker;   //仅用用于标识客户端编号

    static {
        webSocketBeanMap = new ConcurrentHashMap<>();
        clientIdMaker = new AtomicInteger(0);
    }

    private LbSessionMessageService lbSessionMessageService;
    private ChatGPTConfig chatGPTConfig;
    private JedisPool jedisPool;

    private StringBuffer allContent = new StringBuffer();
    private StringBuilder allsContent = new StringBuilder();

    public void setLbSessionMessageService(LbSessionMessageService lbSessionMessageService) {
        this.lbSessionMessageService = lbSessionMessageService;
    }

    public void setJedisPool(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    public void setChatGPTConfig(ChatGPTConfig chatGPTConfig) {
        this.chatGPTConfig = chatGPTConfig;
    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        //当WebSocket连接正式建立后，将该Session加入到Map中进行管理
        ChatGptWebSocketBean chatGptWebSocketBean = new ChatGptWebSocketBean();
        chatGptWebSocketBean.setWebSocketSession(session);
        chaGptWebSocketBean.setClientId(clientIdMaker.getAndIncrement());
        webSocketBeanMap.put(session.getId(), chatGptWebSocketBean);
        // 映射会话id 和  lbSessionMessage
        sessionMessageMap.put(session.getId(),new LbSessionMessage());
        //webSocketBeanMap.put(sessionId, chatGptWebSocketBean);
        log.info("新的客户端连接到当前服务:sessionId:{},clientId:{}", session.getId(), chatGptWebSocketBean.getClientId());
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        webSocketBeanMap.remove(session.getId());
        sessionMessageMap.remove(session.getId());
        log.info("afterConnectionClosed  sessionId:{},连接关闭，从webSocketBean Map中移除session实例", session.getId());
        log.info("afterConnectionClosed  sessionId:{},连接关闭，从sessionMessage Map中移除session实例", session.getId());
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        //传输过程中出现了错误
        if (session.isOpen()) {
            session.close();
        }
        LbSessionMessage lbSessionMessage = sessionMessageMap.get(session.getId());
        if (lbSessionMessage != null) {
            lbSessionMessage.setContent(allContent.toString());
            lbSessionMessageService.updateMassage(lbSessionMessage);
            allContent = new StringBuffer();
            log.info(" handleTransportError  sessionId:{},传输错误连接关闭，更新消息 lbSessionMessage: {}", session.getId(),lbSessionMessage);
        }else {
            log.info(" handleTransportError sessionId 绑定的seesionMessage 不一致 : {}",sessionMessageMap.toString());
        }
        webSocketBeanMap.remove(session.getId());
        sessionMessageMap.remove(session.getId());
        log.info("handleTransportError sessionId:{},传输过程中出现了错误，从Map中移除session实例,错误信息{}", session.getId(),exception.getMessage());
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        String sessionId = session.getId();
        String clientMessage = message.getPayload();

        log.info("接受到客户端:sessionId:{},消息:{}", sessionId, clientMessage);

        LbSessionMessage lbSessionMessage = JSON.parseObject(clientMessage, LbSessionMessage.class);

        List<Map<String, Object>> mapList = Lists.newArrayList();
        JSONObject isNext = new JSONObject();
        isNext.put("isNext", true);
        if (lbSessionMessage.getTopicId() == null) {
            log.info("客户端:sessionId:{},topicId消息为空", sessionId);
            JSONObject messageObj2 = new JSONObject();
            messageObj2.put("type", "word");
            messageObj2.put("errorMsg", "缺少TopicId");
            messageObj2.put("content", "");
            session.sendMessage(new TextMessage(messageObj2.toJSONString()));
            return;
        }
        log.info("before 方法开始执行");
        before(lbSessionMessage, mapList, isNext);  // 业务处理  根据自己需求
        log.info("before 方法执行完毕");

        if (!isNext.getBoolean("isNext")) {
            log.warn("判断为否，不GPT请求数据");
            return;
        }

        int httpReqTimeOut = 1000 * 60;

        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(httpReqTimeOut)
                .setConnectionRequestTimeout(httpReqTimeOut)
                .setSocketTimeout(httpReqTimeOut)
                .build();
        Long userId = lbSessionMessage.getUserId();
        log.info("jedis开始连接");
        Jedis resource = jedisPool.getResource();
        resource.select(3);
        try {
            resource.setex("socket:"+userId,120,"fales");
            log.info("jedis用户key{} 设置完毕",userId);
        }catch (Exception e){
            resource.close();
            log.error("redis异常",e);
        }
        log.info("jedis 初始设置成功");
        String currentDate = new SimpleDateFormat("yyyy年MM月dd日").format( new Date()).toString();
        String messagePayload = message.getPayload();
        JSONObject jsonObject = JSONObject.parseObject(messagePayload);
        String modeltype = jsonObject.getString("modeltype");
        StringBuffer resultContent = new StringBuffer();
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            String url = String.format("http://%s:10008/fission/dashscope/dashscopeChat/stream", chatGPTConfig.getDashscopeGtp());
            log.info("请求的URL:{}", url);
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
            httpPost.setHeader("content-type", "application/json;charset=utf-8");

            if (mapList.isEmpty()) {
                StringEntity stringEntity = new StringEntity(clientMessage, "UTF-8");
                stringEntity.setContentEncoding("UTF-8");
                stringEntity.setContentType("application/json");
                httpPost.setEntity(stringEntity);
            } else {
                StringEntity stringEntity = new StringEntity(JSON.toJSONString(mapList), "UTF-8");
                stringEntity.setContentEncoding("UTF-8");
                stringEntity.setContentType("application/json");
                httpPost.setEntity(stringEntity);
            }

            try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode == 200) {
                    HttpEntity entity = response.getEntity();
                    if (entity != null) {
                        log.info("gpt 返回成功======userId{}",userId);
                        InputStream inputStream = entity.getContent();
                        byte[] buffer = new byte[10240];
                        int bytesRead;
                        //gpt回复的 记录对应的数据库id
                        Long id = null;
                        String responseId = "";
                        JSONObject dataJsonObject = null ;
                        StringBuilder previousContent = new StringBuilder();
                        while ((bytesRead = inputStream.read(buffer)) != -1) {
                            String chunk = new String(buffer, 0, bytesRead, StandardCharsets.UTF_8);
                            if (chunk.contains("data")) {
                                chunk = chunk.replaceAll("\\s+", "");
                                String[] split = chunk.split("data:");
                                try {
                                    if (split.length > 1) {
                                        //System.out.println("打印：  " + split[1]);
                                        dataJsonObject = JSONObject.parseObject(split[1]);
                                    }
                                } catch (Exception e) {
                                    log.info("传输出现异常,{}",e.getMessage());
                                    String s = resource.get("socket:" + userId.toString());
                                    if (s == null || Boolean.parseBoolean(s)) {
                                        resource.close();
                                        lbSessionMessage.setId(id);
                                        lbSessionMessage.setRole("assistant");
                                        lbSessionMessage.setContent(allContent.toString());
                                        lbSessionMessage.setSystemMessage("");
                                        lbSessionMessageService.updateMassage(lbSessionMessage);
                                        return;
                                    }
                                }
                            }
                            if (chunk.contains("id:")) {
                                String[] split = chunk.split(":");
                                responseId = split[1];
                            }
                            if (!chunk.contains("data")) continue;
                            String content = null;
                            String role = null;
                            String finishReason = null;

                            if (dataJsonObject != null) {
                                JSONArray choicesArray = dataJsonObject.getJSONObject("output").getJSONArray("choices");
                                content = choicesArray.getJSONObject(0).getJSONObject("message").getString("content");
                                //System.out.println("content: " + content);
                                role = choicesArray.getJSONObject(0).getJSONObject("message").getString("role");
                                finishReason = choicesArray.getJSONObject(0).getString("finish_reason");
                            } else {
                                continue;
                            }
                            if (StringUtils.isNotBlank(responseId) && "1".equals(responseId)) {
                                if ("assistant".equals(role)) {
                                    //如果接收到的 身份是assistant 就将会话记录存入数据库
                                    LbSessionMessage lbSessionMessageNew = new LbSessionMessage();
                                    lbSessionMessageNew.setTopicId(lbSessionMessage.getTopicId());
                                    lbSessionMessageNew.setMessageType(lbSessionMessage.getMessageType());
                                    lbSessionMessageNew.setRole("assistant");
                                    lbSessionMessageNew.setUserId(lbSessionMessage.getUserId());
                                    lbSessionMessageNew.setContent(" ");
                                    LbSessionMessage lbSessionMessage1 = lbSessionMessageService.addMessageInfoByGpt2(lbSessionMessageNew,id);
                                    id = lbSessionMessage1.getId();
                                    LbSessionMessage lbSessionMessage2 = sessionMessageMap.get(sessionId);
                                    BeanUtils.copyProperties(lbSessionMessage1, lbSessionMessage2);
                                }
                            }
                            if (!content.isEmpty()) {
                                if (StringUtils.isNotBlank(finishReason) && "stop".equals(finishReason)) {
                                    resultContent = new StringBuffer(content);
                                }
                                String currentContent = content;
/**
 * 因为通义千问开启SSE 流式回复之后 是回复的包括老数据的增量数据 根据业务要求只需要增量数据  所以需
 */

                                // 检查是否包含上一个内容
                                if (currentContent.startsWith(String.valueOf(previousContent))) {
                                    // 仅当当前内容以上一个内容开头时才进行替换
                                    currentContent = currentContent.substring(previousContent.length());
                                }
                                previousContent = new StringBuilder(content);
                                allsContent.append(currentContent);
                                String tempContent = allsContent.toString();
                                // 多个换行替换成一个换行
                                tempContent = tempContent.replaceAll("\r\n?", "\n").replaceAll("(\\n)+", "\n");
                                if (StringUtils.isBlank(tempContent))  continue;
                                // 判断是否content包含特殊字符  有特殊字符 进行分割  输出包含特殊子符的部分  另一部分保留到下一次拼接
                                if (tempContent.contains("\n")||";".equals(tempContent)|| tempContent.contains("。") ||"；".equals(tempContent)||"↵".equals(tempContent)) {
                                    tempContent = splitAndProcessContent(tempContent);
                                    JSONObject messageObj = new JSONObject();
                                    messageObj.put("type", "char");
                                    messageObj.put("errorMsg", "ok");
                                    messageObj.put("content", tempContent);
                                    messageObj.put("id", id);
                                    TextMessage textMessage = new TextMessage(messageObj.toJSONString());
                                    try {
                                        allContent.append(tempContent);
                                        session.sendMessage(textMessage);
                                    } catch (Exception e) {
                                        log.info("客户2端链接中断");
                                        String s = resource.get("socket:" + userId.toString());
                                        if (s == null || Boolean.parseBoolean(s)) {
                                            resource.close();
                                            log.info("客户端2 链接中断  返回的内容：{}",allContent.toString());
                                            lbSessionMessage.setId(id);
                                            lbSessionMessage.setRole("assistant");
                                            lbSessionMessage.setContent(allContent.toString());
                                            lbSessionMessage.setSystemMessage("");
                                            lbSessionMessageService.updateMassage(lbSessionMessage);
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                        resource.close();
                        EntityUtils.consume(entity);
                        log.info ("GPT总消息>:{}", resultContent);
                        lbSessionMessage.setId(id);
                        after(lbSessionMessage, resultContent.toString());  // 调用完之后的业务处理

                        JSONObject messageObj = new JSONObject();
                        messageObj.put("type", "text");
                        messageObj.put("errorMsg", "ok");
                        messageObj.put("content", resultContent.toString());
                        TextMessage textMessage = new TextMessage(messageObj.toJSONString());
                        try {
                            session.sendMessage(textMessage);
                        } catch (Exception e) {
                            log.info("客户1端链接中断 返回的内容：{}",resultContent.toString());
                            // 更新
                            String s = resource.get("socket:" + userId.toString());
                            if (s == null || Boolean.parseBoolean(s)) {
                                resource.close();
                                return;
                            }

                        }

                        TextMessage textMessage2 =null;
                        if (StringUtils.isEmpty(resultContent.toString())){
                            JSONObject messageObj2 = new JSONObject();
                            messageObj2.put("type", "word");
                            messageObj2.put("errorMsg", "调用失败");
                            messageObj2.put("content", "");
                            textMessage2= new TextMessage(messageObj2.toJSONString());
                            log.error("回答失败");
                        }else {
                            JSONObject messageObj2 = new JSONObject();
                            messageObj2.put("type", "messageInfo");
                            messageObj2.put("errorMsg", "ok");
                            messageObj2.put("content", JSON.toJSONString(lbSessionMessage));
                            textMessage2= new TextMessage(messageObj2.toJSONString());
                        }

                        try {
                            session.sendMessage(textMessage2);
                        } catch (Exception e) {
                            log.info("客户3端链接中断  返回的内容：{}",resultContent.toString());
                            String s = resource.get("socket:" + userId.toString());
                            if (s == null || Boolean.parseBoolean(s)) {
                                resource.close();
                                return;
                            }
                        }
                    }
                } else {
                    JSONObject messageObj = new JSONObject();
                    messageObj.put("type", "word");
                    messageObj.put("errorMsg", "调用失败");
                    messageObj.put("content", "");
                    TextMessage textMessage = new TextMessage(messageObj.toJSONString());
                    session.sendMessage(textMessage);
                }
            }catch (SocketTimeoutException e){

                log.error("回答超时:{}",e.getMessage());
                JSONObject messageObj = new JSONObject();
                messageObj.put("type", "word");
                messageObj.put("errorMsg", "回答超时");
                messageObj.put("content", "");
                TextMessage textMessage = new TextMessage(messageObj.toJSONString());
                session.sendMessage(textMessage);
            }
        }
    }



    private boolean jsonValidate(String jsonStr) {
        try {
            JSON.parse(jsonStr);
            return true;
        } catch (Exception e) {
            log.error("json字符串校验异常返回False:{}", e.getMessage());
            return false;
        }
    }

    private void before(LbSessionMessage lbSessionMessage, List<Map<String, Object>> mapList, JSONObject isNext) {
        // 调用前业务处理
    }

    private void after(LbSessionMessage lbSessionMessage, String gptResultMsg) {
        // 调用后业务处理
    }
}