Java 对接 ChatGPT

sunshine-sm

已于 2024-02-29 08:17:24 修改

阅读量1k

点赞数 25

分类专栏： ChatGPT 文章标签： java chatgpt AI写作 AI作画

于 2024-02-27 11:19:13 首次发布

本文链接：https://blog.csdn.net/SunBoy_1409/article/details/136317750

版权

ChatGPT 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细介绍了如何在Java项目中通过第三方SDK如`chatgpt-java`版本4.3.0集成ChatGPT，包括Maven和Gradle的依赖管理，YAML配置文件中的服务器设置，以及如何处理代理和API密钥。还涉及了将应用部署到线上环境，如使用Nginx进行域名代理的配置。

摘要由CSDN通过智能技术生成

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>

gradle

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

直接在项目中引入依赖。

话不多说，直接上代码：

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/

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;
    }
}

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();
    }

}

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;
    }

}

Question 请求参数类

@Data
public class Question {
    private String content;
}

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/;
   }
}