SpringBoot对接OpenAI

小灰灰 2024-03-23 19:36 9阅读 0赞

## SpringBoot对接OpenAI ##

随着人工智能技术的飞速发展，越来越多的开发者希望将智能功能集成到自己的应用中，以提升用户体验和应用的功能。OpenAI作为一家领先的人工智能公司，提供了许多先进的自然语言处理和语言生成模型，其中包括深受欢迎的GPT-3.5模型。本文将介绍如何利用Spring Boot框架与OpenAI进行对接，为你的应用增加强大的智能能力。

### 1、OpenAI概述： ###

OpenAI是一家人工智能研究实验室，致力于构建人类水平通用人工智能。他们的GPT-3.5模型是目前最先进的自然语言处理模型之一，能够理解和生成自然语言文本。通过与OpenAI对接，你可以将这一强大的模型嵌入到你的应用中，实现自动化文本生成、智能问答、机器翻译等功能。

### 2、Spring Boot 简介： ###

Spring Boot是一个用于构建独立的、基于生产级别的Java应用程序的框架。它简化了Spring应用的开发过程，提供了一系列的工具和插件，帮助开发者快速搭建稳健的应用。通过Spring Boot，你可以轻松创建RESTful API，处理HTTP请求，以及管理应用的依赖等。

### 3、搭建Spring Boot项目： ###

1.  环境准备：确保你已经安装了Java开发环境和Maven构建工具。
2.  创建Spring Boot项目：使用Spring Initializr创建一个新的Spring Boot项目，选择所需的依赖，如Web、OpenAI API等。
3.  配置OpenAI API密钥：在application.properties或application.yml文件中，设置OpenAI API的访问密钥，确保可以在项目中调用OpenAI的服务。

#### 3.1、环境准备 ####

这里就不多说了，直接使用maven搭建一个SpringBoot项目

#### 3.2、引入依赖 ####

本次案例比较简单，就是一个干净的SpringBoot项目，再引入Hutool工具包即可，下面是全部的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.2.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.pp.chat</groupId>
        <artifactId>chatgpt-api-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    
    
        <dependencies>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.83</version>
            </dependency>
            
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.8.16</version>
            </dependency>
            
            <dependency>
                <groupId>com.github.xiaoymin</groupId>
                <artifactId>knife4j-openapi2-spring-boot-starter</artifactId>
                <version>4.2.0</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    </project>

#### 3.3、配置文件 ####

knife4j:
      enable: true
    
    ChatGPT:
      connect-timeout: 60000      # HTTP请求连接超时时间
      read-timeout: 60000         # HTTP请求读取超时时间
      variables:                  # 自定义变量:
        apiKey: xxx     # 你的 OpenAI 的 API KEY
        model: gpt-3.5-turbo   # ChartGPT 的模型
        maxTokens: 500             # 最大 Token 数
        temperature: 1         # 该值越大每次返回的结果越随机，即相似度越小

### 4、核心代码 ###

#### 4.1、项目结构 ####

[![pPAtXUU.md.png][]][pPAtXUU.md.png 1]

#### 4.2、实体类 ####

1、GPTChoice

package com.pp.chat.entity;
    
    import lombok.Data;
    /**
     * TODO 文本模型返回内容
     *
     * @author ss_419
     * @version 1.0
     * @date 2023/8/5 15:47
     */
    @Data
    public class GPTChoice {
        
        private String text;
        private Integer index;
        private Message message;
    
    }

2、GPTData

package com.pp.chat.entity;
    
    import lombok.Data;
    
    
    
    /**
     * TODO 图形模型返回内容
     *
     * @author ss_419
     * @version 1.0
     * @date 2023/8/5 11:37
     */
    @Data
    public class GPTData {
        
    
        private String url;
    }

3、GPTRequest

package com.pp.chat.entity;
    
    import lombok.Data;
    
    import java.util.List;
    
    /**
     * TODO 问题请求体
     *
     * @author ss_419
     * @version 1.0
     * @date 2023/8/5 15:47
     */
    @Data
    public class GPTRequest {
        
        /*** 问题*/
        private String askStr;
        /*** 文本回答*/
        private String replyStr;
        /*** 图形回答*/
        private List<GPTData> replyImg;
    }

4、GPTResponse

package com.pp.chat.entity;
    
    import lombok.Data;
    
    import java.util.List;
    /**
     * TODO 文本模型返回响应体
     *
     * @author ss_419
     * @version 1.0
     * @date 2023/8/5 15:47
     */
    @Data
    public class GPTResponse {
        
        private String id;
        private String object;
        private String created;
        private String model;
        private List<GPTChoice> choices;
    
    }

5、GPTImageResponse

package com.pp.chat.entity;
    
    import lombok.Data;
    
    import java.util.List;
    
    /**
     * TODO 图形模型返回响应体
     *
     * @author ss_419
     * @version 1.0
     * @date 2023/8/5 15:47
     */
    @Data
    public class GPTImageResponse {
        
        private String created;
        private List<GPTData> data;
    }

6、Message

package com.pp.chat.entity;
    
    import lombok.Data;
    
    /**
     * TODO 文本模型消息体
     *
     * @author ss_419
     * @version 1.0
     * @date 2023/8/5 10:30
     */
    @Data
    public class Message {
        
        private String role;
        private String content;
    }

#### 4.3、业务类 ####

ChartGPTService

package com.pp.chat.service;
    
    import com.pp.chat.entity.GPTData;
    
    import java.util.List;
    
    public interface ChartGPTService {
        
        /**
         * 调用文本模型ai
         * @param prompt
         * @return
         */
        String send(String prompt);
    
        /**
         * 调用图片模型ai
         * @param prompt
         * @return
         */
        List<GPTData> sendImg(String prompt);
    }

ChartGPTServiceImpl

package com.pp.chat.service.impl;
    
    import cn.hutool.http.Header;
    import cn.hutool.http.HttpResponse;
    import cn.hutool.http.HttpUtil;
    import cn.hutool.json.JSONObject;
    import cn.hutool.json.JSONUtil;
    import com.pp.chat.entity.*;
    import com.pp.chat.service.ChartGPTService;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    @Service("chartGPTService")
    public class ChartGPTServiceImpl implements ChartGPTService {
        
        @Value("${ChatGPT.variables.apiKey}")
        private String apiKey;
        @Value("${ChatGPT.variables.maxTokens}")
        private String maxTokens;
        @Value("${ChatGPT.variables.model}")
        private String model;
        @Value("${ChatGPT.variables.temperature}")
        private String temperature;
    
        @Override
        public String send(String prompt) {
        
            JSONObject bodyJson = new JSONObject();
            Message message = new Message();
            message.setContent(prompt);
            message.setRole("system");
            ArrayList<Message> messages = new ArrayList<>();
            messages.add(message);
            bodyJson.put("messages", messages);
            bodyJson.put("model", model);
            bodyJson.put("max_tokens", Integer.parseInt(maxTokens));
            bodyJson.put("temperature", Double.parseDouble(temperature));
            Map<String, Object> headMap = new HashMap<>();
    //        headMap.put("Authorization", "Bearer " + apiKey);
            HttpResponse httpResponse =
                    // 官网请求，没梯子不能访问
                    // HttpUtil.createPost("https://api.openai.com/v1/chat/completions")
                    // 使用代理地址 https://api.openai-proxy.com/
                    HttpUtil.createPost("https://api.openai-proxy.com/v1/chat/completions")
                            .header(Header.AUTHORIZATION, "Bearer " + apiKey)
                            .header(Header.CONTENT_TYPE, "application/json")
                            .body(JSONUtil.toJsonStr(bodyJson)).execute();
            String resStr = httpResponse.body();
    
            GPTResponse gptResponse = JSONUtil.toBean(resStr, GPTResponse.class);
    
            return gptResponse.getChoices().get(0).getMessage().getContent().replaceAll("\\n", "");
    
        }
    
        @Override
        public List<GPTData> sendImg(String prompt) {
        
            JSONObject bodyJson = new JSONObject();
            bodyJson.put("prompt", prompt);
            bodyJson.put("n", 2);
            bodyJson.put("size", "1024x1024");
            Map<String, Object> headMap = new HashMap<>();
            headMap.put("Authorization", "Bearer " + apiKey);
            HttpResponse httpResponse =
                    // 官网请求，没梯子不能访问
                    // HttpUtil.createPost("https://api.openai.com/v1/chat/completions")
                    // 使用代理地址 https://api.openai-proxy.com/
                    HttpUtil.createPost("https://api.openai-proxy.com/v1/images/generations")
                            .header(Header.AUTHORIZATION, "Bearer " + apiKey)
                            .header(Header.CONTENT_TYPE, "application/json")
                            .body(JSONUtil.toJsonStr(bodyJson)).execute();
            String resStr = httpResponse.body();
    
            GPTImageResponse gptResponse = JSONUtil.toBean(resStr, GPTImageResponse.class);
    
            List<GPTData> data = gptResponse.getData();
    
            return data;
    
        }
    }

#### 4.4、Boot启动类 ####

Main

package com.pp.chat;
    
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    /**
     * @author ss_419
     */
    @SpringBootApplication
    public class Main {
        
        public static void main(String[] args) {
        
            SpringApplication.run(Main.class,args);
            System.out.println("Hello world!");
        }
    }

### 5、测试 ###

启动项目，使用knife4j进行接口测试

接口文档默认地址：http://localhost:8080/doc.html

[![pPANm2d.png][]][pPANm2d.png 1]

#### 5.1、测试文本模型 ####

[![pPANQqP.png][]][pPANQqP.png 1]

#### 5.2、测试图片模型 ####

[![pPANJPg.png][]][pPANJPg.png 1]

gpt生成的图片在链接中

[![pPANdrq.png][]][pPANdrq.png 1]

### 6、总结 ###

通过Spring Boot与OpenAI的对接，我们可以轻松将强大的自然语言处理功能集成到我们的应用中，为用户提供更智能、更便捷的服务。同时，结合Spring Boot强大的开发能力，我们可以快速搭建出高效稳定的智能应用，满足不断变化的市场需求。未来，随着OpenAI技术的不断演进，我们将能够构建更多创新的智能应用，为用户带来更加令人惊喜的体验

[pPAtXUU.md.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7d6d4a940c654e39879a404a5f4d0ae3.png
[pPAtXUU.md.png 1]: https://imgse.com/i/pPAtXUU
[pPANm2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/93512c0c962b47df8f290f486c938139.png
[pPANm2d.png 1]: https://imgse.com/i/pPANm2d
[pPANQqP.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6719860d31054d31802e417ff68791f8.png
[pPANQqP.png 1]: https://imgse.com/i/pPANQqP
[pPANJPg.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8cf47f23eb1f48e2b4a64834caeb1d18.png
[pPANJPg.png 1]: https://imgse.com/i/pPANJPg
[pPANdrq.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/871e564e22804d159595d4203de186db.png
[pPANdrq.png 1]: https://imgse.com/i/pPANdrq