Java 对接 ChatGPT_java对接chatgpt

Java 对接 ChatGPT 样例

本样例采用第三方SDK对接：chatgpt-java，在此感谢作者：PlexPt。

当前最新版本 4.3.0 。

maven

<dependency>
    <groupId>com.github.plexpt</groupId>
    <artifactId>chatgpt</artifactId>
    <version>4.3.0</version>
</dependency>
1
2
3
4
5

gradle

implementation group: 'com.github.plexpt', name: 'chatgpt', version: '4.3.0'
1

直接在项目中引入依赖。

话不多说，直接上代码：

1. yml配置

   server:
     port: 9000
     servlet:
       context-path: /api
   
   # chatgpt 配置
   chatgpt:
     # 代理配置
     proxy:
       # 开启：true false
       enable: true
       # 代理方式：http socks5
       type: socks5
       # 代理主机地址
       host: 127.0.0.1
       # 代理端口
       port: 10808
     # OpenAI key 可配置多个key
     apiKeys:
       - sk-axjXpCP4mvQexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxOrlRi1
       - sk-axjXpCP4mvQexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxOrlRi2
     # OpenAI 请求地址
     apiHost: https://api.openai.com/
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23

2. chatgpt 配置映射类

   import lombok.Data;
   import org.springframework.boot.context.properties.ConfigurationProperties;
   import org.springframework.stereotype.Component;
   
   import java.util.List;
   
   @Data
   @Component
   @ConfigurationProperties(prefix = "chatgpt")
   public class ChatGPTProp {
       // 代理配置
       private ProxyConfig proxy;
       // apiKey
       private List<String> apiKeys;
       // apiHost
       private String apiHost;
   
       @Data
       static class ProxyConfig {
           private boolean enable;
           private String type;
           private String host;
           private int port;
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25

3. ChatGPTConfig 配置类

   import com.plexpt.chatgpt.ChatGPT;
   import com.plexpt.chatgpt.ChatGPTStream;
   import com.plexpt.chatgpt.util.Proxys;
   import jakarta.annotation.PostConstruct;
   import lombok.extern.slf4j.Slf4j;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.context.annotation.Bean;
   import org.springframework.stereotype.Component;
   
   import java.net.Proxy;
   
   @Slf4j
   @Component
   public class ChatGPTConfig {
   
       @Autowired
       private ChatGPTProp chatGPTProp;
   
       private Proxy proxy;
   
       @PostConstruct
       private void initProxy() {
           ChatGPTProp.ProxyConfig pdata = chatGPTProp.getProxy();
           if (!pdata.isEnable()) {
               proxy = null;
           }
   
           log.info("开启代理，代理类型：{}，代理服务器：{}，代理端口：{}。", pdata.getType(), pdata.getHost(), pdata.getPort());
           if ("http".equals(pdata.getType())) {
               proxy = Proxys.http(pdata.getHost(), pdata.getPort());
           } else {
               proxy = Proxys.socks5(pdata.getHost(), pdata.getPort());
           }
       }
   
       @Bean
       public ChatGPT chatGPT() {
           // 初始化 ChatGPT 对象
           return ChatGPT.builder()
                   .apiKeyList(chatGPTProp.getApiKeys())
                   .timeout(900)
                   .proxy(proxy)
                   .apiHost(chatGPTProp.getApiHost())
                   .build()
                   .init();
       }
   
       @Bean
       public ChatGPTStream chatGPTStream() {
           // 初始化 ChatGPTStream 对象
           return ChatGPTStream.builder()
                   .timeout(600)
                   .apiKeyList(chatGPTProp.getApiKeys())
                   .proxy(proxy)
                   .apiHost(chatGPTProp.getApiHost())
                   .build()
                   .init();
       }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60

4. Controller 类

   import com.plexpt.chatgpt.ChatGPT;
   import com.plexpt.chatgpt.ChatGPTStream;
   import com.plexpt.chatgpt.entity.chat.Message;
   import com.plexpt.chatgpt.listener.SseStreamListener;
   import com.sm.chatgptdemo.model.Question;
   import lombok.extern.slf4j.Slf4j;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.*;
   import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
   
   import java.util.List;
   
   @Slf4j
   @Controller
   @RequestMapping("/chat")
   public class ChatController {
   
       @Autowired
       private ChatGPT chatGPT;
   
       @Autowired
       private ChatGPTStream chatGPTStream;
   
       /**
        * 普通文本会话
        *
        * @param question 问题
        */
       @ResponseBody
       @PostMapping("/text")
       public String text(@RequestBody Question question) {
           String answer = chatGPT.chat(question.getContent());
           return answer;
       }
   
       /**
        * SSE 会话
        *
        * @param question 问题
        */
       @CrossOrigin
       @PostMapping("/sse")
       public SseEmitter sseEmitter(@RequestBody Question question) {
           // 封装消息体
           Message message = Message.of(question.getContent());
   
           // 创建SseEmitter
           SseEmitter sseEmitter = new SseEmitter(-1L);
   
           // 创建监听器
           SseStreamListener listener = new SseStreamListener(sseEmitter);
   
           // 监听回答完成
           listener.setOnComplate(msg -> {
               // 回答完成，可以做一些事情
               log.info("回答完成：{}", msg);
               // 完成后关闭会话
               sseEmitter.complete();
           });
   
           // 发起SSE会话请求
           chatGPTStream.streamChatCompletion(List.of(message), listener);
   
           // 流式响应
           return sseEmitter;
       }
   
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69

5. Question 请求参数类

   @Data
   public class Question {
       private String content;
   }
   1
   2
   3
   4

6. Nginx 代理

   敲黑板划重点：若要部署到线上，使用nginx配置域名代理，在nginx中需加如下配置：

   server {
      # HTTP默认端口
      listen 80; 
   
      # 域名
      server_name chat.example.com; 
   
      location /api/ {
         # ************ 重点配置 ************ #
         # SSE 连接时的超时时间
         proxy_read_timeout 86400s;
         # 取消缓冲
         proxy_buffering off;
         # 关闭代理缓存
         proxy_cache off;
         # ************ 重点配置 ************ #
         
         proxy_set_header Host $http_host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header REMOTE-HOST $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_pass http://localhost:9000/api/;
      }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24

获取 ChatGPT API key

1. 前提你需要一个可用的ChatGPT账号（账号需自行去购买）

2. 登录 ChatGPT官网
   
   

3. 创建 key