调用chat-gpt

待我称王封你为后i 2024-03-26 22:31 60阅读 0赞

### 调用chat-gpt ###

### 依赖 ###

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-mail</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
    
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.7.10</version>
            </dependency>

### 相关的类 ###

import lombok.Data;
    
    import java.util.ArrayList;
    import java.util.List;
    
     
    @Data
    public class ChatRequest {
        
    
        private String model;
        private List<Message> messages;
        private int n = 3;
        private double temperature = 0.2;
    
        public ChatRequest(String model, String prompt) {
        
            this.model = model;
    
            this.messages = new ArrayList<>();
    //        this.messages.add(new Message("system", "You are a IELTS Teachers."));
            this.messages.add(new Message("system", "You are an IELTS teacher, and your answers are all in JSON string format."));
            this.messages.add(new Message("user", prompt));
        }
    
        public ChatRequest(String model, List<String> prompts) {
        
            this.model = model;
    
            this.messages = new ArrayList<>();
            for (String prompt : prompts) {
        
                this.messages.add(new Message("user", prompt));
            }
        }
    
    }

import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.util.List;
     
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class ChatResponse {
        
    
        private List<Choice> choices;
    
        public static class Choice {
        
    
            private int index;
            private Message message;
    
            public int getIndex() {
        
                return index;
            }
    
            public void setIndex(int index) {
        
                this.index = index;
            }
    
            public Message getMessage() {
        
                return message;
            }
    
            public void setMessage(Message message) {
        
                this.message = message;
            }
        }
    
    }

import cn.hutool.core.util.ArrayUtil;
    import cn.hutool.core.util.StrUtil;
    import cn.hutool.json.JSONUtil;
    import com.fasterxml.jackson.core.type.TypeReference;
    import com.fasterxml.jackson.databind.JsonNode;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
    import lombok.SneakyThrows;
    import lombok.experimental.UtilityClass;
    import lombok.extern.slf4j.Slf4j;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * JSON 工具类
     * 
     */
    @UtilityClass
    @Slf4j
    public class JsonUtils {
        
    
        private static ObjectMapper objectMapper = new ObjectMapper();
    
        static {
        
            objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
            objectMapper.registerModules(new JavaTimeModule()); // 解决 LocalDateTime 的序列化
        }
    
        /**
         * 初始化 objectMapper 属性
         * <p>
         * 通过这样的方式，使用 Spring 创建的 ObjectMapper Bean
         *
         * @param objectMapper ObjectMapper 对象
         */
        public static void init(ObjectMapper objectMapper) {
        
            JsonUtils.objectMapper = objectMapper;
        }
    
        @SneakyThrows
        public static String toJsonString(Object object) {
        
            return objectMapper.writeValueAsString(object);
        }
    
        @SneakyThrows
        public static byte[] toJsonByte(Object object) {
        
            return objectMapper.writeValueAsBytes(object);
        }
    
        @SneakyThrows
        public static String toJsonPrettyString(Object object) {
        
            return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);
        }
    
        public static <T> T parseObject(String text, Class<T> clazz) {
        
            if (StrUtil.isEmpty(text)) {
        
                return null;
            }
            try {
        
                return objectMapper.readValue(text, clazz);
            } catch (IOException e) {
        
                log.error("json parse err,json:{}", text, e);
                throw new RuntimeException(e);
            }
        }
    
        /**
         * 将字符串解析成指定类型的对象
         * 使用 {@link #parseObject(String, Class)} 时，在@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS) 的场景下，
         * 如果 text 没有 class 属性，则会报错。此时，使用这个方法，可以解决。
         *
         * @param text 字符串
         * @param clazz 类型
         * @return 对象
         */
        public static <T> T parseObject2(String text, Class<T> clazz) {
        
            if (StrUtil.isEmpty(text)) {
        
                return null;
            }
            return JSONUtil.toBean(text, clazz);
        }
    
        public static <T> T parseObject(byte[] bytes, Class<T> clazz) {
        
            if (ArrayUtil.isEmpty(bytes)) {
        
                return null;
            }
            try {
        
                return objectMapper.readValue(bytes, clazz);
            } catch (IOException e) {
        
                log.error("json parse err,json:{}", bytes, e);
                throw new RuntimeException(e);
            }
        }
    
        public static <T> T parseObject(String text, TypeReference<T> typeReference) {
        
            try {
        
                return objectMapper.readValue(text, typeReference);
            } catch (IOException e) {
        
                log.error("json parse err,json:{}", text, e);
                throw new RuntimeException(e);
            }
        }
    
        public static <T> List<T> parseArray(String text, Class<T> clazz) {
        
            if (StrUtil.isEmpty(text)) {
        
                return new ArrayList<>();
            }
            try {
        
                return objectMapper.readValue(text, objectMapper.getTypeFactory().constructCollectionType(List.class, clazz));
            } catch (IOException e) {
        
                log.error("json parse err,json:{}", text, e);
                throw new RuntimeException(e);
            }
        }
    
        public static JsonNode parseTree(String text) {
        
            try {
        
                return objectMapper.readTree(text);
            } catch (IOException e) {
        
                log.error("json parse err,json:{}", text, e);
                throw new RuntimeException(e);
            }
        }
    
        public static JsonNode parseTree(byte[] text) {
        
            try {
        
                return objectMapper.readTree(text);
            } catch (IOException e) {
        
                log.error("json parse err,json:{}", text, e);
                throw new RuntimeException(e);
            }
        }
    
    
    }

import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
     
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Message {
        
    
        private String role;
    
        private String content;
    
    }

import cn.hutool.http.HttpRequest;
    import cn.hutool.json.JSONUtil;
    
    
    public class Dome {
        
        public static void main(String[] args) {
        
            String model = "gpt-3.5-turbo";
            String prompt = "你好,说一下女娲补天的故事";
            String openAiApiKey = "sk-rdM1NWB0UjLXv8JcQ9vfT3BlbkFJWE9dVvZV8a37u1TeP11";
            ChatRequest request = new ChatRequest(model, prompt);
            String url = "https://api.openai-proxy.com/v1/chat/completions";
            String json = JsonUtils.toJsonString(request);
            String result = HttpRequest.post(url)
                    .header("Authorization", "Bearer " + openAiApiKey)
                    .header("Content-Type", "application/json")
                    .body(json)
                    .execute()
                    .body();
            System.out.println(result);
            if ( result==null) {
        
                System.out.println("错误");
            }
            ChatResponse response = JSONUtil.toBean(result, ChatResponse.class);
            System.out.println(response);
        }
    }

openAiApiKey 后面+b