chatgpt开发，如何实现智能会话

naturalwish

已于 2023-03-20 20:09:29 修改

阅读量553

点赞数

分类专栏： Chatgpt 文章标签： java 自然语言处理语言模型 Powered by 金山文档

于 2023-03-20 18:08:39 首次发布

本文链接：https://blog.csdn.net/naturalwish/article/details/129672482

版权

Chatgpt 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

ChatGPT AI API：ChatGPT AI 提供了 API，您可以使用该 API 将 ChatGPT AI 集成到您的 Java 代码中。API 可以通过 HTTP 请求和响应进行访问，因此您需要使用 Java 的网络库进行访问。ChatGPT AI API 的细节可以在 OpenAI 的文档中找到。

Java 网络编程：Java 提供了许多网络编程 API，您可以使用这些 API 与远程服务器通信。在与 ChatGPT AI API 进行通信时，您需要使用 Java 的网络编程 API 将 HTTP 请求发送到 ChatGPT AI API，并解析响应以获取 ChatGPT AI 的结果。

Java 应用程序设计：Java 应用程序可以使用许多不同的框架和库进行设计。您需要选择适合您项目需求的框架和库。在与 ChatGPT AI 进行集成时，您需要确保您的 Java 应用程序能够在用户与 ChatGPT AI 进行交互时展示 ChatGPT AI 的响应。

下面是一些可能有用的步骤，以帮助您开始使用 ChatGPT AI API 进行开发：

创建 Java 项目：接下来，您需要创建一个 Java 项目，并使用 Maven 或 Gradle 等依赖管理工具添加所需的依赖项。您需要添加 Java 网络编程库和 JSON 解析库等依赖项。

编写 Java 代码：在 Java 项目中编写代码，以使用 ChatGPT AI API。您需要构建 HTTP 请求，并使用 Java 网络库将请求发送到 ChatGPT AI API。然后，您需要解析响应以获取 ChatGPT AI 的结果。最后，您需要在 Java 应用程序中展示 ChatGPT AI 的响应。

package com.unfbx.chatgptsteamoutput.controller;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.unfbx.chatgpt.OpenAiClient;
import com.unfbx.chatgpt.OpenAiStreamClient;
import com.unfbx.chatgpt.entity.chat.Message;
import com.unfbx.chatgpt.exception.BaseException;
import com.unfbx.chatgpt.exception.CommonError;
import com.unfbx.chatgptsteamoutput.config.LocalCache;
import com.unfbx.chatgptsteamoutput.listener.OpenAIEventSourceListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 描述：
 *
 * @author 
 * @date 2023-03-01
 */
@Controller
@Slf4j
public class ChatController {

@Value("${chatgpt.apiKey}")
private String apiKey;
@Value("${chatgpt.apiHost}")

private String apiHost;
private OpenAiStreamClient openAiStreamClient;
private static Map<String, OpenAiStreamClient> clientMap = new ConcurrentHashMap<>();
private static Map<String, String> lastChatMap = new ConcurrentHashMap<>();

public ChatController(OpenAiStreamClient openAiStreamClient) {
    this.openAiStreamClient = openAiStreamClient;
}

@GetMapping("/chat")
@CrossOrigin
public SseEmitter chat(@RequestParam("message") String msg, @RequestHeader Map<String, String> headers) throws IOException {
    SseEmitter sseEmitter = new SseEmitter(0L);
    String uid = headers.get("uid");
    if (StrUtil.isBlank(uid)) {
        throw new BaseException(CommonError.SYS_ERROR);
    }
    String messageContext = (String) LocalCache.CACHE.get(uid);
    List<Message> messages = new ArrayList<>();
    if (StrUtil.isNotBlank(messageContext)) {
        messages = JSONUtil.toList(messageContext, Message.class);
        if (messages.size() >= 10) {
            messages = messages.subList(1, 10);
        }
        Message currentMessage = Message.builder().content(msg).role(Message.Role.USER).build();
        messages.add(currentMessage);
     } else {
        Message currentMessage = Message.builder().content(msg).role(Message.Role.USER).build();
        messages.add(currentMessage);
     }
    sseEmitter.send(SseEmitter.event().id(uid).name("连接成功！！！！").data(LocalDateTime.now()).reconnectTime(3000));
    sseEmitter.onCompletion(() -> {
        log.info(LocalDateTime.now() + ", uid#" + uid + ", on completion");
    });
sseEmitter.onTimeout(() -> log.info(LocalDateTime.now() + ", uid#" + uid + ", on timeout#" + sseEmitter.getTimeout()));
sseEmitter.onError(
        throwable -> {
        try {
        log.info(LocalDateTime.now() + ", uid#" + "765431" + ", on error#" + throwable.toString());
        sseEmitter.send(SseEmitter.event().id("765431").name("发生异常！").data(throwable.getMessage()).reconnectTime(3000));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
);
OpenAIEventSourceListener openAIEventSourceListener = new OpenAIEventSourceListener(sseEmitter);
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("*.*.*.*", 1221));
openAiStreamClient = clientMap.get(uid);
if(ObjectUtil.isNull(openAiStreamClient)){
    openAiStreamClient = OpenAiStreamClient.builder()
            .connectTimeout(50)
            .readTimeout(50)
            .writeTimeout(50)
            .apiKey(apiKey)
            .proxy(proxy)
            .apiHost(apiHost).build();
}
openAiStreamClient.streamChatCompletion(messages, openAIEventSourceListener);
LocalCache.CACHE.put(uid, JSONUtil.toJsonStr(messages), LocalCache.TIMEOUT);
return sseEmitter;
    }
}