什么？你还没有自己的ChatGPT？搭建ChatGPT使用DDD领域思想对接公众号交互

curl -fsSL https://jpom.top/docs/install.sh | bash -s Server jdk+mvn+node+default

# 下载并安装Docker所需要的软件包
sudo yum install -y yum-utils
# 添加Docker官方的yum仓库地址
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 设置阿里云镜像的yum仓库地址
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 更新yum缓存
sudo yum makecache fast
# 安装新版Docker
sudo yum install -y docker-ce docker-ce-cli containerd.io

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

默认路径：/usr/java/xxxx

版本：1.8

来源：https://mirrors.tuna.tsinghua.edu.cn/Adoptium/

curl -fsSL https://jpom.top/docs/install.sh | bash -s Server jdk+only-module+default

#gcc安装，nginx源码编译需要
yum install -y gcc-c++

#PCRE pcre-devel 安装，nginx 的 http 模块使用 pcre 来解析正则表达式
yum install -y pcre pcre-devel

#zlib安装，nginx 使用zlib对http包的内容进行gzip
yum install -y zlib zlib-devel

#OpenSSL 安装，强大的安全套接字层密码库，nginx 不仅支持 http 协议，还支持 https（即在ssl协议上传输http）
yum install -y openssl openssl-devel

mkdir -p /usr/local/nginx && cd /usr/local/nginx
#下载版本号可根据目前官网最新稳定版自行调整
wget -O nginx-1.20.2.tar.gz https://nginx.org/download/nginx-1.20.2.tar.gz

#根目录使用ls命令可以看到下载的nginx压缩包，然后解压
tar -zxvf nginx-1.20.2.tar.gz

#解压后进入目录
cd nginx-1.20.2

#使用默认配置
./configure

# 编译安装
make
make install

# 启动nginx
cd /usr/local/nginx
./sbin/nginx

 "registry-mirrors": [
    "https://xv6jnj6e.mirror.aliyuncs.com"
]

{
  "bind": "0.0.0.0:8181",
  "tls": {
    "enabled": false,
    "cert_file": "",
    "key_file": ""
  },
  "timeout": 600,
  "proxy_url": "",
  "license_id": "非常重要",
  "public_share": false,
  "site_password": "你的网页访问密码",
  "setup_password": "管理配置的密码",
  "server_tokens": true,
  "proxy_api_prefix": "prox api 请求前缀",
  "isolated_conv_title": "*",
  "disable_signup": false,
  "auto_conv_arkose": false,
  "proxy_file_service": true,
  "custom_doh_host": "",
  "captcha": {
    "provider": "",
    "site_key": "",
    "site_secret": "",
    "site_login": false,
    "setup_login": false,
    "oai_username": false,
    "oai_password": false,
    "oai_signup": false
  },
  "whitelist": null
}

  "license_id": "前面的许可证",
  "site_password": "yangbuyiya123",
  "setup_password": "yangbuyiya123",
  "proxy_api_prefix": "yangbuyiya123",

{
  "token1": {
    // 这里支持多种token还支持账号密码授权(推荐账号密码) 比如 "token": "你的账号&密码"
    "token": "access token / session token / refresh token / share token / username & password",
    "password": "12345"
  }
}

docker pull pengzhile/pandora-next

docker run -d --restart always --name PandoraNext --net=bridge \
            -p 8181:8181 \
            -v ./data:/data \
            -v ./sessions:/root/.cache/PandoraNext \
            pengzhile/pandora-next

curl http://服务器IP:8181/yangbuyiya123/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
     "model": "gpt-3.5-turbo",
     "messages": [{"role": "user", "content": "Say this is a test!"}],
     "temperature": 0.7
   }'

curl http://服务器IP:8181/yangbuyiya123/api/auth/login' \
    -H 'Content-Type: application/x-www-form-urlencoded' \
    -d 'username=user%40mail.com' \
    -d 'password=abc123'

curl 'http://127.0.0.1:8181/yangbuyi123/api/token/register' \
    -H 'Content-Type: application/x-www-form-urlencoded' \
    -d 'unique_name=abcdefg' \
    -d 'access_token=eyxxxx' \
    -d 'site_limit=https%3A%2F%2Fchat.oaifree.com' \
    -d 'expires_in=0' \
    -d 'show_conversations=false' \
    -d 'show_userinfo=false'

<!-- https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp -->
<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>4.12.0</version>
</dependency>
<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>logging-interceptor</artifactId>
  <version>4.12.0</version>
</dependency>

/**
 * 单元测试
 */
@SpringBootTest
class Yby6PandoraChatGptApplicationTests {

    @Test
    void testApi() throws IOException {
        // 日志配置
        HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
        httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.HEADERS);

        // 建造请okhttp客户端
        OkHttpClient client = new OkHttpClient().newBuilder()
        .addInterceptor(httpLoggingInterceptor)
        .build();
        MediaType mediaType = MediaType.parse("application/json");
        String req = "{\n" +
        "    \"model\": \"gpt-3.5-turbo\",\n" +
        "    \"messages\": [\n" +
        "        {\n" +
        "            \"role\": \"user\",\n" +
        "            \"content\": \"你好呀,我是杨不易呀\"\n" +
        "        }\n" +
        "    ],\n" +
        "    \"temperature\": 0.7,\n" +
        "    \"stream\": false\n" +
        "}";
        RequestBody body = RequestBody.create(req, mediaType);
        Request request = new Request.Builder()
        .url("http://IP:8181/前缀/v1/chat/completions")
        .method("POST", body)
        .addHeader("Authorization", "Bearer FK token")
        .addHeader("Content-Type", "application/json")
        .addHeader("Accept", "*/*")
        .addHeader("Host", "IP:8181")
        .addHeader("Connection", "keep-alive")
        .build();
        Response response = client.newCall(request).execute();
        System.out.println(response.body().string());
    }

}

{
    "id": "chatcmpl-OtyWJeU0gQBFhfyA5XHHv37wRLyNx",
    "object": "chat.completion",
    "created": 1705425154,
    "model": "gpt-3.5-turbo",
    "usage": {
        "prompt_tokens": 0,
        "completion_tokens": 0,
        "total_tokens": 0
    },
    "choices": [
        {
            "message": {
                "role": "assistant",
                "content": "你好杨不易！有什么我可以帮助你的吗？"
            },
            "finish_reason": "stop",
            "index": 0
        }
    ]
}

package com.yby6.yby6pandorachatgpt;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * ../
 *
 * @author Yang Shuai
 * Create By 2024/01/17
 */
@Data
public class ChatGPTResponse {

    /**
     * 身份证件
     */
    @JsonProperty("id")
    private String id;
    /**
     * 对象
     */
    @JsonProperty("object")
    private String object;
    /**
     * 创建
     */
    @JsonProperty("created")
    private Integer created;
    /**
     * 模型
     */
    @JsonProperty("model")
    private String model;
    /**
     * token用量
     */
    @JsonProperty("usage")
    private UsageDTO usage;

    /**
     * 回复信息
     */
    @JsonProperty("choices")
    private List<ChoicesDTO> choices;


    @NoArgsConstructor
    @Data
    public static class UsageDTO {
        @JsonProperty("prompt_tokens")
        private Integer promptTokens;
        @JsonProperty("completion_tokens")
        private Integer completionTokens;
        @JsonProperty("total_tokens")
        private Integer totalTokens;
    }

    @NoArgsConstructor
    @Data
    public static class ChoicesDTO {
        @JsonProperty("message")
        private MessageDTO message;
        @JsonProperty("finish_reason")
        private String finishReason;
        @JsonProperty("index")
        private Integer index;

        @NoArgsConstructor
        @Data
        public static class MessageDTO {
            @JsonProperty("role")
            private String role;
            @JsonProperty("content")
            private String content;
        }
    }
}

<!--    强大的Java工具库 -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.25</version>
</dependency>

# 微信公众号配置信息
wx:
  config:
    originalid: 你的原始ID
    token: token

package com.yby6.yby6pandorachatgpt.infrastructure.util.wechat;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * 微信签名util
 *
 * @author Yang Shuai
 * Create By 2024/01/13
 */
public class WechatSignatureUtil {

    private static final Logger logger = LoggerFactory.getLogger(WechatSignatureUtil.class);


    /**
     * 验证签名
     */
    public static boolean check(String token, String signature, String timestamp, String nonce) {
        String[] arr = new String[]{token, timestamp, nonce};
        // 将token、timestamp、nonce三个参数进行字典序排序
        sort(arr);
        StringBuilder content = new StringBuilder();
        for (String s : arr) {
            content.append(s);
        }
        MessageDigest md;
        String tmpStr = null;
        try {
            md = MessageDigest.getInstance("SHA-1");
            // 将三个参数字符串拼接成一个字符串进行sha1加密
            byte[] digest = md.digest(content.toString().getBytes());
            tmpStr = byteToStr(digest);
        } catch (NoSuchAlgorithmException e) {
            logger.error(e.getMessage());
        }
        // 将sha1加密后的字符串可与signature对比，标识该请求来源于微信
        return tmpStr != null && tmpStr.equals(signature.toUpperCase());
    }

    /**
     * 将字节数组转换为十六进制字符串
     */
    private static String byteToStr(byte[] byteArray) {
        StringBuilder strDigest = new StringBuilder();
        for (byte b : byteArray) {
            strDigest.append(byteToHexStr(b));
        }
        return strDigest.toString();
    }

    /**
     * 将字节转换为十六进制字符串
     */
    private static String byteToHexStr(byte mByte) {
        char[] Digit = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        char[] tempArr = new char[2];
        tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
        tempArr[1] = Digit[mByte & 0X0F];
        return new String(tempArr);
    }

    /**
     * 进行字典排序
     */
    private static void sort(String[] str) {
        for (int i = 0; i < str.length - 1; i++) {
            for (int j = i + 1; j < str.length; j++) {
                if (str[j].compareTo(str[i]) < 0) {
                    String temp = str[i];
                    str[i] = str[j];
                    str[j] = temp;
                }
            }
        }
    }
}

# 微信公众号配置信息
wx:
config:
originalid: 原始ID 
token: 服务器配置里面的token 刚刚设置的嗷

package com.yby6.yby6pandorachatgpt.interfaces;

import com.yby6.yby6pandorachatgpt.infrastructure.util.wechat.WechatSignatureUtil;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Yang Shuai
 * Create By 2024/1/18
 */
@RestController
@RequestMapping("/chat-api/wx/portal")
public class WechatController {

    private final Logger logger = LoggerFactory.getLogger(WechatController.class);

    // 服务器 Token 
    @Value("${wx.config.token}")
    private String token;

    /**
     * 处理微信服务器发来的get请求，进行签名的验证
     *
     * <p>
     * appid     微信端AppID
     * signature 微信端发来的签名
     * timestamp 微信端发来的时间戳
     * nonce     微信端发来的随机字符串
     * echostr   微信端发来的验证字符串
     */
    @GetMapping(produces = "text/plain;charset=utf-8")
    public String validate(
            @RequestParam(value = "signature", required = false) String signature,
            @RequestParam(value = "timestamp", required = false) String timestamp,
            @RequestParam(value = "nonce", required = false) String nonce,
            @RequestParam(value = "echostr", required = false) String echostr) {
        try {
            logger.info("微信公众号验签信息{}开始 [{}, {}, {}]", signature, timestamp, nonce, echostr);
            if (StringUtils.isAnyBlank(signature, timestamp, nonce, echostr)) {
                throw new IllegalArgumentException("请求参数非法，请核实!");
            }
            boolean check = WechatSignatureUtil.check(token, signature, timestamp, nonce);
            logger.info("微信公众号验签: {}", check);
            if (!check) {
                return null;
            }
            return echostr;
        } catch (Exception e) {
            logger.error("微信公众号验签信息{}失败 [{}, {}, {}]", signature, timestamp, nonce, echostr, e);
            return null;
        }
    }

}

/**
 * 此处是处理微信服务器的消息转发的
 */
@PostMapping(produces = "application/xml; charset=UTF-8")
public String post(@RequestBody String requestBody) {

    logger.info("接收参数:{}", requestBody);

    return "正在开发中....";
}

<!-- 对接微信公众号，需要解析xml -->
<!-- https://mvnrepository.com/artifact/com.thoughtworks.xstream/xstream -->
<dependency>
    <groupId>com.thoughtworks.xstream</groupId>
    <artifactId>xstream</artifactId>
    <version>1.4.20</version>
</dependency>

package com.yby6.yby6pandorachatgpt.domain.wechat;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import lombok.Getter;

/**
 * 回复消息文本实体
 *
 * @author Yang Shuai
 * Create By 2024/01/18
 */
@Getter
public class MessageTextEntity {

    @XStreamAlias("MsgId")
    private String msgId;
    @XStreamAlias("ToUserName")
    private String toUserName;
    @XStreamAlias("FromUserName")
    private String fromUserName;
    @XStreamAlias("CreateTime")
    private String createTime;
    @XStreamAlias("MsgType")
    private String msgType;
    @XStreamAlias("Content")
    private String content;
    @XStreamAlias("Event")
    private String event;
    @XStreamAlias("EventKey")
    private String eventKey;

    public MessageTextEntity() {
    }

    public void setMsgId(String msgId) {
        this.msgId = msgId;
    }

    public void setToUserName(String toUserName) {
        this.toUserName = toUserName;
    }

    public void setFromUserName(String fromUserName) {
        this.fromUserName = fromUserName;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    public void setMsgType(String msgType) {
        this.msgType = msgType;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public void setEvent(String event) {
        this.event = event;
    }

    public void setEventKey(String eventKey) {
        this.eventKey = eventKey;
    }
}

package com.yby6.yby6pandorachatgpt.infrastructure.util.wechat;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.core.util.QuickWriter;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.thoughtworks.xstream.io.xml.PrettyPrintWriter;
import com.thoughtworks.xstream.io.xml.XppDriver;
import org.apache.commons.lang3.StringUtils;

import java.io.Writer;

/**
 * XmlUtil
 *
 * @author yangbuyiya
 * Create By 2024/01/18
 */
public class XmlUtil {

    /**
     * xstream扩展,bean转xml自动加上![CDATA[]]
     */
    public static XStream getMyXStream() {
        return new XStream(new XppDriver() {
            @Override
            public HierarchicalStreamWriter createWriter(Writer out) {
                return new PrettyPrintWriter(out) {
                    // 对所有xml节点都增加CDATA标记
                    final boolean cdata = true;

                    @Override
                    public void startNode(String name, Class clazz) {
                        super.startNode(name, clazz);
                    }

                    @Override
                    protected void writeText(QuickWriter writer, String text) {
                        if (cdata && !StringUtils.isNumeric(text)) {
                            writer.write("<![CDATA[");
                            writer.write(text);
                            writer.write("]]>");
                        } else {
                            writer.write(text);
                        }
                    }
                };
            }
        });
    }

    /**
     * bean转成微信的xml消息格式
     */
    public static String beanToXml(Object object) {
        XStream xStream = getMyXStream();
        xStream.alias("xml", object.getClass());
        xStream.processAnnotations(object.getClass());
        String xml = xStream.toXML(object);
        if (!StringUtils.isEmpty(xml)) {
            return xml;
        } else {
            return null;
        }
    }

    /**
     * xml转成bean泛型方法
     */
    public static <T> T xmlToBean(String resultXml, Class clazz) {
        // XStream对象设置默认安全防护，同时设置允许的类
        XStream stream = new XStream(new DomDriver());
        XStream.setupDefaultSecurity(stream);
        stream.allowTypes(new Class[]{clazz});
        stream.processAnnotations(new Class[]{clazz});
        stream.setMode(XStream.NO_REFERENCES);
        stream.alias("xml", clazz);
        return (T) stream.fromXML(resultXml);
    }

}

logger.info("接收参数:{}", requestBody);
MessageTextEntity messageTextEntity = XmlUtil.xmlToBean(requestBody, MessageTextEntity.class);
logger.info("解析XML数据:{}", messageTextEntity);

@PostMapping(produces = "application/xml; charset=UTF-8")
public String post(@RequestBody String requestBody) {

    logger.info("接收参数:{}", requestBody);
    MessageTextEntity messageTextEntity = XmlUtil.xmlToBean(requestBody, MessageTextEntity.class);
    logger.info("解析XML数据:{}", messageTextEntity);

    // 组装文本回复
    MessageTextEntity res = new MessageTextEntity();
    // 接收方账号（收到的OpenID） 就是接出来的 FromUserName 这个是接收方的openid
    res.setToUserName(messageTextEntity.getFromUserName());
    // 	开发者微信号  就是解析出来的 ToUserName 这个是开发者微信号(原始ID)
    //  但是为了安全,我们使用我们自己配置文件当中的原始ID
    res.setFromUserName(originalId);
    // 消息创建时间 （整型）
    res.setCreateTime(String.valueOf(System.currentTimeMillis() / 1000L));
    // 消息类型，文本为text
    res.setMsgType("text");
    // 回复的消息内容（换行：在content中能够换行，微信客户端就支持换行显示）
    res.setContent("干嘛干嘛!!!!");
    String result = XmlUtil.beanToXml(res);
    logger.info("接收微信公众号信息请求完成 {}, openid:{}", result, messageTextEntity.getFromUserName());

    return result;
}

 OkHttpClient client = new OkHttpClient().newBuilder().build();

/**
 * OpenAI会话工厂
 *
 * @author yangs
 * @date 2024/01/18
 */
public interface OpenAiSessionFactory {

    /**
     * 开启会话
     *
     * @return {@link OpenAiSession}
     */
    OpenAiSession openSession();

}

package com.yby6.yby6pandorachatgpt.domain.chatgpt;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.*;
import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 * 建造者模式 构建请求信息
 * 请求信息依照；OpenAI官网API构建参数；<a href="https://platform.openai.com/playground">...</a>
 *
 * @author yangs
 * @date 2024/01/18
 */
@Data
@Builder
@Slf4j
@JsonInclude(JsonInclude.Include.NON_NULL)
@NoArgsConstructor
@AllArgsConstructor
public class ChatGPTRequest implements Serializable {

    /**
     * 默认模型
     */
    private String model = Model.GPT_3_5_TURBO.getCode();
    /**
     * 问题描述
     */
    private List<ChatGPTResponse.ChoicesDTO.MessageDTO> messages;
    /**
     * 控制温度【随机性】；0到2之间。较高的值(如0.8)将使输出更加随机，而较低的值(如0.2)将使输出更加集中和确定
     */
    private double temperature = 0.2;
    /**
     * 多样性控制；使用温度采样的替代方法称为核心采样，其中模型考虑具有top_p概率质量的令牌的结果。因此，0.1 意味着只考虑包含前 10% 概率质量的代币
     */
    @JsonProperty("top_p")
    private Double topP = 1d;
    /**
     * 为每个提示生成的完成次数
     */
    private Integer n = 1;
    /**
     * 是否为流式输出；就是一蹦一蹦的，出来结果
     */
    private boolean stream = false;
    /**
     * 停止输出标识
     */
    private List<String> stop;
    /**
     * 输出字符串限制；0 ~ 4096
     */
    @JsonProperty("max_tokens")
    private Integer maxTokens = 2048;
    /**
     * 频率惩罚；降低模型重复同一行的可能性
     */
    @JsonProperty("frequency_penalty")
    private double frequencyPenalty = 0;
    /**
     * 存在惩罚；增强模型谈论新话题的可能性
     */
    @JsonProperty("presence_penalty")
    private double presencePenalty = 0;
    /**
     * 生成多个调用结果，只显示最佳的。这样会更多的消耗你的 api token
     */
    @JsonProperty("logit_bias")
    private Map logitBias;
    /**
     * 调用标识，避免重复调用
     */
    private String user;

    @Getter
    @AllArgsConstructor
    public enum Model {
        /**
         * gpt-3.5-turbo
         */
        GPT_3_5_TURBO("gpt-3.5-turbo"),
        /**
         * GPT4.0
         */
        GPT_4("gpt-4"),
        /**
         * GPT4.0 超长上下文
         */
        GPT_4_32K("gpt-4-32k"),
        ;
        private final String code;
    }

}

package com.yby6.yby6pandorachatgpt.session;


import com.yby6.yby6pandorachatgpt.domain.chatgpt.ChatGPTRequest;
import com.yby6.yby6pandorachatgpt.domain.chatgpt.ChatGPTResponse;

/**
 * OpenAi 会话接口
 *
 * @author yangs
 * @date 2024/01/11
 */
public interface OpenAiSession {

    /**
     * 默认 GPT-3.5 问答模型
     *
     * @param chatGPTRequest 请求信息
     * @return 返回结果
     */
    ChatGPTResponse completions(ChatGPTRequest chatGPTRequest);

}

package com.yby6.yby6pandorachatgpt.infrastructure.interceptor;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.http.ContentType;
import cn.hutool.http.Header;
import okhttp3.HttpUrl;
import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;
import org.jetbrains.annotations.NotNull;

import java.io.IOException;

/**
 * 自定义 OpenAI 拦截器
 *
 * @author yangs
 * @date 2024/01/18
 */
public class OpenAiInterceptor implements Interceptor {

    /**
     * OpenAi apiKey 需要在官网申请
     */
    private final String apiKey;

    public OpenAiInterceptor(String apiKey) {
        this.apiKey = apiKey;
    }

    /**
     * 拦截okhttp请求
     * @param chain 链
     * @return 是否继续执行
     */
    @NotNull
    @Override
    public Response intercept(Chain chain) throws IOException {
        return chain.proceed(this.auth(apiKey, chain.request()));
    }

    /**
     * 构建认证请求对象
     *
     * @param apiKey   api密钥
     * @param original 起初
     * @return {@link Request}
     */
    private Request auth(String apiKey, Request original) {
        HttpUrl.Builder builder = original.url().newBuilder();
        // 构建新的请求地址
        HttpUrl url = builder.build();
        // 创建请求
        return original.newBuilder()
        .url(url.url())
        .header(Header.AUTHORIZATION.getValue(), "Bearer " + apiKey)
        .header(Header.CONTENT_TYPE.getValue(), ContentType.JSON.getValue())
        .method(original.method(), original.body())
        .build();
    }

}

<!--   http api 转 Java 接口     -->
<dependency>
    <groupId>com.squareup.retrofit2</groupId>
    <artifactId>retrofit</artifactId>
    <version>2.9.0</version>
</dependency>
<!--   序列化用     -->
<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>converter-jackson</artifactId>
  <version>2.9.0</version>
</dependency>
<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>adapter-rxjava2</artifactId>
  <version>2.9.0</version>
</dependency>

/**
 * ChatGPT 请求接口 API
 * 官网：<a href="https://platform.openai.com/playground">...</a>
 *
 * @author Yang Shuai
 * Create By 2024/1/19
 */
public interface OpenAiService {

    /**
     * 默认 GPT-3.5 问答模型
     *
     * @param chatGPTRequest 请求信息
     * @return 返回结果
     */
    @POST("v1/chat/completions")
    Call<ChatGPTResponse> completions(@Body ChatGPTRequest chatGPTRequest);


}

/**
 * 开启会话
 *
 * @return {@link OpenAiSession}
 */
@Override
public OpenAiSession openSession() {
    // 1. 日志配置
    HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor();
    httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.NONE);
    logger.info("OpenAi API Client Start");
    // 2. 开启 Http 客户端
    OkHttpClient okHttpClient = new OkHttpClient
    .Builder()
    .addInterceptor(httpLoggingInterceptor)
    .addInterceptor(new OpenAiInterceptor("你的api key"))
    .connectTimeout(450, TimeUnit.SECONDS)
    .writeTimeout(450, TimeUnit.SECONDS)
    .readTimeout(450, TimeUnit.SECONDS)
    .build();

    // 3. 创建 API 服务
    final Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("IP") // 你的潘多拉访问IP
    .client(okHttpClient)
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    .addConverterFactory(JacksonConverterFactory.create())
    .build();
    // 创建对应请求 API
    final OpenAiService openAiService = retrofit.create(OpenAiService.class);

    // 传递给默认实现进行触发请求调用
    return new DefaultOpenAiSession(openAiService);
}

/**
 * 默认的 OpenAI 会话实现OpenAiSession
 *
 * @author Yang Shuai
 * Create By 2024/1/19
 */
@RequiredArgsConstructor
public class DefaultOpenAiSession implements OpenAiSession {

    private final OpenAiService openAiService;

    /**
     * 默认 GPT-3.5 问答模型
     *
     * @param chatGPTRequest 请求信息
     * @return 返回结果
     */
    @Override
    public ChatGPTResponse completions(ChatGPTRequest chatGPTRequest) throws IOException {
        return openAiService.completions(chatGPTRequest).execute().body();
    }
}

/**
 * @author Yang Shuai
 * {@code @create} 2024/1/16:17:48
 * {@code @desc} |
 **/
@Configuration
@RequiredArgsConstructor
public class initializeOpenAISession {
    private final Logger logger = LoggerFactory.getLogger(initializeOpenAISession.class);

    /**
     * 初始化会话工厂
     */
    @Bean("openAiSession")
    public OpenAiSession openAiSession() {
        logger.info("初始化请求配置文件");
        // 2. 会话工厂
        OpenAiSessionFactory factory = new DefaultOpenAiSessionFactory();
        // 3. 开启会话
        logger.info("开启会话 openAiSession");
        return factory.openSession();
    }

}

@NoArgsConstructor
@Data
public static class MessageDTO {
    @JsonProperty("role")
    private String role;
    @JsonProperty("content")
    private String content;

    /**
     * 构造器 构建角色、内容
     */
    private MessageDTO(MessageDTO.Builder builder) {
        this.role = builder.role;
        this.content = builder.content;
    }

    public static MessageDTO.Builder builder() {
        return new MessageDTO.Builder();
    }

    /**
     * 建造者模式
     */
    public static final class Builder {

        private String role;
        private String content;

        public Builder() {
        }

        public MessageDTO.Builder role(Constants.Role role) {
            this.role = role.getCode();
            return this;
        }

        public MessageDTO.Builder content(String content) {
            this.content = content;
            return this;
        }


        public MessageDTO build() {
            return new MessageDTO(this);
        }
    }


}

/**
 * 公用基础用对象
 */
public class Constants {

    /**
     * 角色
     * 官网支持的请求角色类型；system、user、assistant
     * <a href="https://platform.openai.com/docs/guides/chat/introduction">...</a>
     */
    @Getter
    public enum Role {

        /**
         * 系统
         */
        SYSTEM("system"),
        /**
         * 使用者
         */
        USER("user"),
        /**
         * 助理
         */
        ASSISTANT("assistant"),
        ;

        /**
         * 密码
         */
        private final String code;

        /**
         * 角色
         *
         * @param code 密码
         */
        Role(String code) {
            this.code = code;
        }

    }

}