• 超级详细Spring AI+ChatGPT（java接入OpenAI大模型）

    Spring AI

    对接各种AI大模型（AI工程领域的应用程序框架）

    前期准备

    API-Key:sk-3sfER03LDLG3SDFsdlwe283JSdw023lkrmrHDND32fmREKFD

    （格式长这样，这个不可用）

    免费使用

    • 🚀申请领取内测免费API Key
    • 免费版支持gpt-3.5-turbo, embedding, gpt-4。其中gpt-4由于价格过高，每24小时限制10次调用，且不支持流式传输。需要更稳定快速的gpt-4请使用付费版。
    • 转发Host1: https://api.chatanywhere.tech (国内中转，延时更低，host1和host2二选一)
    • 转发Host2: https://api.chatanywhere.com.cn (国内中转，延时更低，host1和host2二选一)
    • 转发Host3: https://api.chatanywhere.cn (国外使用,国内需要全局代理)

    创建项目

    ​

    ​

    pom文件配置

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0modelVersion>
    5.     <parent>
    6.         <groupId>org.springframework.bootgroupId>
    7.         <artifactId>spring-boot-starter-parentartifactId>
    8.         <version>3.2.5version>
    9.         <relativePath/> 
    10.     parent>
    11.     <groupId>com.zzqgroupId>
    12.     <artifactId>spring-ai-chat01artifactId>
    13.     
    14.     <version>1.0.1-SNAPSHOTversion>
    15.     <name>spring-ai-chat01name>
    16.     <description>spring-ai-chat01description>
    17.     <properties>
    18.         <java.version>17java.version>
    19.         <spring-ai.version>1.0.0-SNAPSHOTspring-ai.version>
    20.     properties>
    21.     <dependencies>
    22.         <dependency>
    23.             <groupId>org.springframework.bootgroupId>
    24.             <artifactId>spring-boot-starter-webartifactId>
    25.         dependency>
    27.         <dependency>
    28.             <groupId>org.springframework.aigroupId>
    29.             <artifactId>spring-ai-openai-spring-boot-starterartifactId>
    30.         dependency>
    31.  
    32.         <dependency>
    33.             <groupId>org.springframework.bootgroupId>
    34.             <artifactId>spring-boot-devtoolsartifactId>
    35.             <scope>runtimescope>
    36.             <optional>trueoptional>
    37.         dependency>
    38.         <dependency>
    39.             <groupId>org.projectlombokgroupId>
    40.             <artifactId>lombokartifactId>
    41.             <optional>trueoptional>
    42.         dependency>
    43.         <dependency>
    44.             <groupId>org.springframework.bootgroupId>
    45.             <artifactId>spring-boot-starter-testartifactId>
    46.             <scope>testscope>
    47.         dependency>
    48.     dependencies>
    50.     <dependencyManagement>
    51.         <dependencies>
    52.             <dependency>
    53.                 <groupId>org.springframework.aigroupId>
    54.                 <artifactId>spring-ai-bomartifactId>
    55.                 <version>${spring-ai.version}version>
    56.                 <type>pomtype>
    57.                 <scope>importscope>
    58.             dependency>
    59.         dependencies>
    60.     dependencyManagement>
    61.  
    62.     <build>
    63.         <plugins>
    64.             <plugin>
    65.                 <groupId>org.springframework.bootgroupId>
    66.                 <artifactId>spring-boot-maven-pluginartifactId>
    67.                 <configuration>
    68.                     <excludes>
    69.                         <exclude>
    70.                             <groupId>org.projectlombokgroupId>
    71.                             <artifactId>lombokartifactId>
    72.                         exclude>
    73.                     excludes>
    74.                 configuration>
    75.             plugin>
    76.         plugins>
    77.     build>
    80.     
    90.  
    92.     <repositories>
    93.         <repository>
    94.             <id>spring-snapshotid>
    95.             <name>Spring Snapshotsname>
    96.             <url>https://repo.spring.io/snapshoturl>
    97.             <releases>
    98.                 <enabled>falseenabled>
    99.             releases>
    100.         repository>
    101.     repositories>
    102. project>

    ​

    配置application文件

    文件内容： 

    1. spring:
    2.   application:
    3.      name:spring-ai-01-chat
    4.   ai:
    5.     openai:
    6.      api-key: ${OPENAI_API_KEY}
    7.      base-url: ${OPENAI_API_URL}
    8.      chat:
    9.        option:
    10.          #model:gpt-4-32k
    11.          model:gpt-3.5-turbo
    12.          temperature:0.3F

    http://t.csdnimg.cn/32fqr小白如何设置openai api key的环境变量

    controller文件内容：

    生成文字

    1. package com.zzq.controller;
    2.  
    3. import jakarta.annotation.Resource;
    4. import org.springframework.ai.chat.ChatResponse;
    5. import org.springframework.ai.chat.prompt.Prompt;
    6. import org.springframework.ai.openai.OpenAiChatClient;
    7. import org.springframework.ai.openai.OpenAiChatOptions;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.RequestParam;
    10. import org.springframework.web.bind.annotation.RestController;
    11. import reactor.core.publisher.Flux;
    12.  
    13. @RestController
    14. public class ChatController {
    15.     /**
    16.      * OpenAi自动装配，可以直接注入使用
    17.      */
    18.     @Resource
    19.     private OpenAiChatClient openAiChatClient;
    20.  
    21.     /**
    22.      * 调用OpenAi的接口,call方法为同步的api
    23.      * @param msg 你要问的问题
    24.      * @return
    25.      */
    26.     @RequestMapping("/ai/chat")
    27.     public String chat(@RequestParam("msg") String msg) {
    28.         String called = openAiChatClient.call(msg);
    29.         return called;
    30.     }
    31.  
    32.     /**
    33.      * 调用OpenAi的接口
    34.      * @param msg 你要问的问题
    35.      * @return  Object--json对象
    36.      */
    37.     @RequestMapping ("/ai/chat1")
    38.     public Object chat1(@RequestParam("msg") String msg) {
    39.         ChatResponse response = openAiChatClient.call(new Prompt(msg));
    40.         return response;
    41. //        return response.getResult().getOutput().getContent();//只拿到内容
    42.     }
    43.  
    44.     /**
    45.      * 调用OpenAi的接口
    46.      * @param msg 你要问的问题
    47.      * @return
    48.      */
    49.     @RequestMapping ("/ai/chat3")
    50.     public String chat3(@RequestParam("msg") String msg) {
    51.         //可选参数在yml配置，同时在代码中也配置，那么会以代码为准
    52.         ChatResponse response = openAiChatClient.call(new Prompt(msg, OpenAiChatOptions.builder()
    53. //                .withModel("gpt-4-32k")//使用的模型,32k是参数量//参数量越高，准确率越高
    54.                 .withTemperature(0.3F)//温度越高回答越慢，温度越低回答越快
    55.                 .build()));
    56.         return response.getResult().getOutput().getContent();
    57.     }
    58.  
    59.     /**
    60.      * 调用OpenAi的接口 stream是流式的api
    61.      * @param msg 你要问的问题
    62.      * @return
    63.      */
    64.     @RequestMapping ("/ai/chat4")
    65.     public Object chat4(@RequestParam("msg") String msg) {
    66.         //可选参数在yml配置，同时在代码中也配置，那么会以代码为准
    67.         Flux flux = openAiChatClient.stream(new Prompt(msg, OpenAiChatOptions.builder()
    68. //                .withModel("gpt-3.5")//使用的模型
    69.                 .withTemperature(0.3F)//温度越高回答越慢，温度越低回答越快
    70.                 .build()));
    71.         flux.toStream().forEach(chatResponse ->{
    72.             System.out.println(chatResponse.getResult().getOutput().getContent());
    73.         });
    74.         return flux.collectList();//数据的序列,一序列的数据，一个一个的数据返回
    75.     }
    76. }

    spring-ai-02-image

    application文件内容(代码配置的会覆盖yml文件中的)

    更改可以生成image的api-key

    画图模型版本

    n:1(生成图片两张)

    height:1024(高度)

    width:1024(宽度)

    quality:hd(高清)

    1. spring:
    2.   application:
    3.      name:spring-ai-02-image
    4.   ai:
    5.     openai:
    6.      api-key: ${OPENAI_API_KEY}
    7.      base-url: ${OPENAI_API_URL}
    8.      image:
    9.         options:
    10.            model:gpt-4-dalle

    controller内容：

    生成图片

    图片无法使用流式api

    1. package com.zzq.controller;
    2. import jakarta.annotation.Resource;
    3. import org.springframework.ai.image.ImageOptionsBuilder;
    4. import org.springframework.ai.image.ImagePrompt;
    5. import org.springframework.ai.image.ImageResponse;
    6. import org.springframework.ai.openai.OpenAiImageClient;
    7. import org.springframework.web.bind.annotation.GetMapping;
    8. import org.springframework.web.bind.annotation.RequestParam;
    9. import org.springframework.web.bind.annotation.RestController;
    10.  
    11. @RestController
    12. public class ImageController {
    13.     @Resource
    14.     private OpenAiImageClient openAiImageClient;
    15.  
    16.     @RequestMapping("/ai/image")
    17.     private Object image(@RequestParam(value="msg")String msg){
    18.         ImageResponse imageResponse=openAiImageClient.call(new ImagePrompt(msg));
    19.         System.out.println(imageResonse);
    20. //把图片进行业务处理
    21.         String imageUrl=return response.getResult().getOutput().getUrl();
    22.  
    23.      return response.getResult().getOutput().getUrl();
    24.  
    25.   /*  @GetMapping("/ai/draw")
    26.     public String drawImage(@RequestParam(value = "msg") String msg){
    27.         ImageResponse response = openAiImageClient.call(new ImagePrompt(msg,
    28.                 ImageOptionsBuilder
    29.                         .builder()
    30.                         .withQuality("hd")//高清图像
    31.                         .withModel("dall-e-3") //绘画模型
    32.                         .withN(1) //生成图像的个数
    33.                         .withWidth(1024) //图像宽度 默认值
    34.                         .withHeight(1024) //图像高度 默认值
    35.                         .build()
    36.                 )
    37.         );
    38.         //返回结果图片的地址
    39.         return response.getResult().getOutput().getUrl();
    40. */
    41.     }
    42. }

    生成语音

    Ai音频转文本

    spring-ai-03-transcription

    更改可以生成声音的api-key

    声音模型版本

    application文件内容

    1. spring:
    2.   application:
    3.      name:spring-ai-03-trascription
    4.   ai:
    5.     openai:
    6.      api-key: ${OPENAI_API_KEY}
    7.      base-url: ${OPENAI_API_URL}
    1. import jakarta.annotation.Resource;
    2. import org.springframework.ai.openai.OpenAiAudioSpeechClient;
    3. import org.springframework.ai.openai.OpenAiAudioTranscriptionClient;
    4. import org.springframework.core.io.ClassPathResource;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RestController;
    7. import static com.ysl.utisl.save2File.save2File;
    8.  
    9.  
    10. @RestController
    11. public class TranscriptionController {
    12.     @Resource
    13.     private OpenAiudioTranscriptionClient openAiAudioTranscriptionClient;
    14.     @RequestMapping(value="/ai/transcription")
    15.     public Object transcription(){
    16.           org,springframework.core.io.Resourse audioFile = new ClassPathResourse("文件名jfk.mp3")
    17.     String called = openAiAudioTranscriptiomClient.call(audioFile)
    18.     System.out.println(called);
    19.     return called;
    20. }
    21.  
    22. /*
    23. @RestController
    24. public class TranscriptionController {
    25.     //将音频转文字时使用
    26.     @Resource
    27.     private OpenAiAudioTranscriptionClient transcriptionClient;
    28.     //将文字转语音时使用
    29.     @Resource
    30.     private OpenAiAudioSpeechClient speechClient;
    32.     /**
    33.      * 将音频转文字
    34.      * @return
    35.      */
    36.    /* @RequestMapping("/ai/transcription")
    37.     public Object transcription() {
    38.     //读取的是磁盘的路径
    39.     //FileSystemResource audioFile = new FileSystemResource("C:\\Users\\DELL\\Desktop\\luyin.m4a");
    40.         //读取的是classpath静态资源下的文件
    41.         ClassPathResource audioFile = new ClassPathResource("luyin.m4a");
    42.         String call = transcriptionClient.call(audioFile);
    43.         System.out.println(call);
    44.         return call;
    45.     }
    47.     /**
    48.      * 将文字转音频
    49.      * @return
    50.      */
    51.    /* @RequestMapping("/ai/tts")
    52.     public Object tts() {
    53.         String text = "Spring AI 是 AI 工程的应用框架。其目标是将 Spring 生态系统设计原则（如可移植性和模块化设计）应用于 AI，并推广使用 POJO 作为 AI 领域应用程序的构建块。 跨 AI 提供商的可移植 API 支持，适用于聊天、文本到图像和嵌入模型。支持同步和流 API 选项。还支持下拉以访问特定于模型的功能";
    54.         byte[] bytes = speechClient.call(text);
    55.         save2File("C:\\Users\\DELL\\Desktop\\test.mp3",bytes);
    56.         return "OK";
    57.     }
    58. */
    59. /*
    61. @RequestMapping("/ai/tts")
    62.     public Object tts() {
    63.         String text = "Spring AI 是 AI 工程的应用框架。其目标是将 Spring 生态系统设计原则（如可移植性和模块化设计）应用于 AI，并推广使用 POJO 作为 AI 领域应用程序的构建块。 跨 AI 提供商的可移植 API 支持，适用于聊天、文本到图像和嵌入模型。支持同步和流 API 选项。还支持下拉以访问特定于模型的功能";
    64.         byte[] bytes = openAiAudioSpeechClient..call(text);
    65.         FileUtilssave2File("C:\\Users\\DELL\\Desktop\\test.mp3",bytes);
    66.         return "OK";
    67. }
    68. */
    69.  
    70. }

    Spring Ai---多模态

    多模态API

    多模态是指模型同时理解和处理来自各种来源信息的能力，包括文本、图像、音频和其他数据格式

    多模型大语言（LLM）特征使模型能够结合其他模态（如图像、音频或视频）来处理和生成文本

    spring-ai-05-multimodel

    1. package com.zzq.controller;
    2.  
    3. import jakarta.annotation.Resource;
    4. import org.springframework.ai.chat.ChatClient;
    5. import org.springframework.ai.chat.ChatResponse;
    6. import org.springframework.ai.chat.messages.Media;
    7. import org.springframework.ai.chat.messages.UserMessage;
    8. import org.springframework.ai.chat.prompt.Prompt;
    9. import org.springframework.ai.openai.OpenAiChatOptions;
    10. import org.springframework.ai.openai.api.OpenAiApi;
    11. import org.springframework.util.MimeTypeUtils;
    12. import org.springframework.web.bind.annotation.RequestMapping;
    13. import org.springframework.web.bind.annotation.RestController;
    14.  
    15. import java.util.List;
    16.  
    17. @RestController
    18. public class MultiModelController {
    19. @Resource
    20.     private ChatClient chatClient;
    21. @RequestMapping(value = "/ai/multi")
    22.     public  Object multi(String msg,String imageUrl){
    23.     UserMessage userMessage=new UserMessage(msg,
    24.             List.of(new Media(MimeTypeUtils.IMAGE_PNG,imageUrl))
    25.             );
    26.     ChatResponse response=chatClient.call(new Prompt(List.of(userMessage),
    27.             OpenAiChatOptions.builder()
    28.                     .withModel(OpenAiApi.ChatModel.GPT_4_VISION_PREVIEW.getValue())
    29.                     .build()
    30.             ));
    31.     return response.getResult().getOutput().getContent();
    32. }
    33. }
  • 相关阅读:
    【网络安全】网络攻击的类型有哪些？
    小白学爬虫：通过商品ID或商品链接封装接口获取淘宝商品销量数据接口|淘宝商品销量接口|淘宝月销量接口|淘宝总销量接口
    【任务调度框架】「分析技术指南」带你一同盘点一下常用的任务调度框架的方案和原理开发指南
    【音视频播放器测试】确保卓越的媒体体验
    数控加工题，每个图片能做一道就好，help同学吧
    ​LeetCode解法汇总2605. 从两个数字数组里生成最小数字
    19、Python单元测试基础：unittest模块的基本使用
    如何开家有品味的咖啡馆
    汇编书摘抄
    Day42-43
  • 原文地址：https://blog.csdn.net/qq_73735007/article/details/139039494