【Spring boot实战】Springboot+对话ai模型整体框架+高并发线程机制处理优化+提示词工程效果展示(按照框架自己修改可对接市面上百分之99的模型)

Spring Boot + Spring AI快速体验 Spring AI是Spring的一个子项目,是Spring专门面向于AI的应用框架。Spring AI 项目旨在简化整合人工智能功能的应用程序开发,避免不必要的复杂性。汲取了著名的 Python 项目 LangChain 和 LlamaIndex 的灵感,但 Spring AI 并不是这些项目的直接移植。该项目的成立的信念:下一波生成式人工智能应用程序不仅将面向Python开发人员,而且将在许多编程语言中无处不在。@Bean。 阅读详情
AI摘要

博主分享从0搭建Spring Boot后台程序对接AI对话API的过程。先介绍搭建项目的准备,如安装JDK、创建项目、添加依赖等,接着阐述构建常量、处理历史记录、获取AI回答等功能实现,还提及线程优化和鉴权方法,最后介绍提示词工程的优势。

 🎉🎉欢迎光临🎉🎉

🏅我是苏泽,一位对技术充满热情的探索者和分享者。🚀🚀

🌟特别推荐给大家我的最新专栏《Spring 狂野之旅:底层原理高级进阶》 🚀

本专栏纯属为爱发电永久免费!!!

这是苏泽的个人主页可以看到我其他的内容哦👇👇

努力的苏泽icon-default.png?t=N7T8http://suzee.blog.youkuaiyun.com/

大家好这里还是苏泽,关于我的Spring狂野之旅已经出了5期,基本都是从Spring的底层源码去读它,不仅能学会使用方法又能理解其工作机制以及原理,我认为这是非常美妙的一件事,这几期反响都还行,

于是这一章专门出一期运用前面所讲过的知识  自己从0开始搭建一个后台程序  能够对接市面上绝大多数的ai对话api(不同公司的具体的鉴权方法你们找官网文档copy就行了)

那么正片开始

目录

大家好这里还是苏泽,关于我的Spring狂野之旅已经出了5期,基本都是从Spring的底层源码去读它,不仅能学会使用方法又能理解其工作机制以及原理,我认为这是非常美妙的一件事,这几期反响都还行,

于是这一章专门出一期运用前面所讲过的知识  自己从0开始搭建一个后台程序  能够对接市面上绝大多数的ai对话api(不同公司的具体的鉴权方法你们找官网文档copy就行了)

从零开始 搭建一个Spring boot程序

确保你已经安装了Java开发工具(JDK)。你可以在命令行中输入java -version来验证是否已安装Java,并确保版本符合Spring Boot的要求。​编辑安装的部分我就不演示了默认大家已经装好配置好环境

创建一个新的Spring Boot项目。你可以使用​编辑新建一个Springboot项目​编辑

手动添加的依赖:

统一封装一下返回结果

开干:

1.构建好机器人需要的常量:

下面的部分就是存放对应模型的url和Serverid以及秘钥 这些是根据你们要选定的模型去改的

存历史记录 以及查询历史记录的方法:

下面是获取ai对话的回答内容的部分 (这里是有线程优化的处理的)

这段代码实现了一个基于Spring和WebSocket的异步问答系统。主要的逻辑如下:

在并发场景下,这样优化的优势在于:

这一段代码是可以应用在其他使用WebSocket连接ai的业务上的

是基于WebSocket的与远程服务进行问答的功能。主要的逻辑如下:

最后 就是鉴权方法 这个内容 作为api的调用者  我们是不需要理解的(并不影响使用),当然如果对网络协议以及加密感兴趣的伙伴可以细看 我就直接放上来了,因为每家公司的鉴权方法都不一样,而且文档中会直接给出鉴权方法 直接复制到代码里面就可以的

实现效果 

如果朋友对定向提示词工程有兴趣的话可以专门出一期这个模块的博客

提示词工程主要的优势在于以下:


从零开始 搭建一个Spring boot程序

  1. 确保你已经安装了Java开发工具(JDK)。你可以在命令行中输入java -version来验证是否已安装Java,并确保版本符合Spring Boot的要求。



    安装的部分我就不演示了默认大家已经装好配置好环境
     

  2. 创建一个新的Spring Boot项目。你可以使用


    新建一个Springboot项目

我这里选了Springboot版本2.6.13  这个倒是不会有太大问题根据自己项目来就行 

旁边这些依赖自己有需要的就加 我这边不用这里的东西就不选了 

然后出来  他就帮我们建立好了 这些依赖跟框架了 可以在pom文件里看到

手动添加的依赖:

在Maven里输入:

<!-- Hutool -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-json</artifactId>
    <version>5.7.10</version>
</dependency>

<!-- Alibaba FastJSON -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>

<!-- Google Gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.9</version>
</dependency>

<!-- OkHttp -->
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.1</version>
</dependency>

<!-- Spring Data Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.5.4</version>
</dependency>

<!-- Spring Web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.5.4</version>
</dependency>

然后我们新建一个class文件
在里面加入导包:
 

import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.Gson;
import okhttp3.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;

配置了那么多。终于可以开始项目了...

统一封装一下返回结果

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;
/*/**
 *@author suze
 *@date 2023-10-25
 *@time 15:19
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result {
    private Boolean success;
    private String errorMsg;
    private Object data;
    private Long total;

    public static Result ok(){
        return new Result(true, null, null, null);
    }
    public static Result ok(Object data){
        return new Result(true, null, data, null);
    }
    public static Result ok(List<?> data, Long total){
        return new Result(true, null, data, total);
    }
    public static Result fail(String errorMsg){
        return new Result(false, errorMsg, null, null);
    }
//    public static Result fail(int  errorCode, String errorMsg){
//        return new Result(false, errorMsg, null, null);
//    }
}

然后用到的地方就导入Result的包即可

import TopOne.dto.Result;

 

开干:

为了方便演示我把Controller和Server放在一个文件里 大家根据自己需要去调整

1.构建好机器人需要的常量:

public static final Gson gson = new Gson();

    // 个性化参数
    private String userId;
    private Boolean wsCloseFlag;

    private static Boolean totalFlag=true; // 控制提示用户是否输入

    public  List<RoleContent> historyList=new ArrayList<>(); // 这个是临时的 每次用完在线程中要注销他


    //写一个结构专门来存机器的回答
    public static class BotText{
        String content=" ";
    }
    public static BotText botText=new BotText();


    //告诉控制器输出完没有
    public static Boolean outputFlag=true;
    private String botContent = "";

    //返回的json结果拆解
    class JsonParse {
        Header header;
        Payload payload;
    }

    class Header {
        int code;
        int status;
        String sid;
    }

    class Payload {
        Choices choices;
    }

    class Choices {
        List<Text> text;
    }

    class Text {
        String role;
        String content;
    }
    class RoleContent{

        String role;
        String content;

        public String getRole() {
            return role;
        }

        public void setRole(String role) {
            this.role = role;
        }

        public String getContent() {
            return content;
        }

        public void setContent(String content) {
            this.content = content;
        }
    }

下面的部分就是存放对应模型的url和Serverid以及秘钥 这些是根据你们要选定的模型去改的

public static final String hostUrl = "";
    public static final String appid = "";
    public static final String apiSecret = "";
    public static final String apiKey = "";

存历史记录 以及查询历史记录的方法:

我这里做的缓存是2h  用的是Redis,一开始构建项目的时候可以用一个简单的Map来代替Redis  自行替换掉Redis部分代码即可

// 将对话历史存储到 Redis
    public void saveHistory(String  history,String id) {
        // 设置有效期为 2 小时
        stringRedisTemplate.opsForValue().set("id:" + id + ":history", history, 2, TimeUnit.HOURS);
    }
    @RequestMapping("/SaveHistory")
    public Result SaveHistory(@RequestParam("userId") String id, @RequestBody String history)  {
        saveHistory(history,id);
        return Result.ok("保存历史记录成功有效时间:2h");
    }
    // 从 Redis 中获取对话历史
    public List<RoleContent> getHistory(String userId) {
        String historyStr = stringRedisTemplate.opsForValue().get("id:" + userId + ":history");
        if (historyStr==null){
            return null;
        }
        return JSONUtil.toList(JSONUtil.parseArray(historyStr), RoleContent.class);
    }
    //用于获取历史聊天记录
    @RequestMapping("/history")
    public Result history(@RequestParam("userId") String id)  {

        String history = stringRedisTemplate.opsForValue().get("id:" + id + ":history");
        if (history == null) {
            return Result.fail("没有找到历史记录");
        }

        JSONArray jsonObject = JSON.parseArray(history);
//        String jsonString = JSON.toJSONString(jsonObject);
        return Result.ok(jsonObject);
    }

下面是获取ai对话的回答内容的部分 (这里是有线程优化的处理的)

public static String totalAnswer=""; // 大模型的答案汇总

    // 可以写原始问题
    public static  String NewQuestion = "";
    public WordUtils wordUtils=new WordUtils();
    //线程池
    public ThreadPoolExecutor pool = new ThreadPoolExecutor(13, 13, 1,
            TimeUnit.MINUTES, new ArrayBlockingQueue<>(6),
            Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
    @RequestMapping("/get")
    public DeferredResult<Result> get(@RequestParam("question") String question, @RequestParam("id") String id) {
        //创建了一个DeferredResult<Result>对象,并将其返回给前端。在异步任务执行完毕后,
        // 通过调用deferredResult.setResult(result)方法将结果设置到DeferredResult对象中,从而实现异步返回结果给前端。
        DeferredResult<Result> deferredResult = new DeferredResult<>();
        CompletableFuture.supplyAsync(() -> {
            try {
                callable callable = new callable(question, id);
                String answer = callable.call();
                Result result = Result.ok(answer);
                
                return result;
            } catch (Exception e) {
                Result result = Result.fail(e.getMessage());
                return result;
            }
        }, pool).whenComplete((result, throwable) -> {
            if (throwable != null) {
                result = Result.fail(throwable.getMessage());
                deferredResult.setResult(result);

            } else {
                deferredResult.setResult(result);

            }
        });
        return deferredResult;
    }
    public class callable implements Callable<String>{
        private  String  id;
        private String question;
        public callable(String question,String id) {
            //这里处理一下userId的长度 因为讯飞那边限制了
            if (id.length() >= 30) {
                id= id.substring(0, 30);
            }
            this.question = question;
            this.id=id;
        }
        @Override
        public String call() throws Exception {
            String answer =main(question,id);
            //System.out.println(answer);
            answer = JSONUtil.toJsonStr(answer);
            System.out.println("call");
            botText.content="";//清空
            //缓存历史对话  时效两小时
            //String historyStr = JSONUtil.toJsonStr();
            //stringRedisTemplate.opsForValue().set("id:"+id+":history", historyStr,2,TimeUnit.HOURS);
            return answer;
        }
    }
    // 主函数
    public String main(String newQuestion,String userid) throws Exception {
        // 个性化参数入口,如果是并发使用,可以在这里模拟
        System.out.println(totalFlag);
        if(totalFlag){
            totalFlag=false;
            NewQuestion=newQuestion;
            // 构建鉴权url
            String authUrl = getAuthUrl(hostUrl, apiKey, apiSecret);
            OkHttpClient client = new OkHttpClient.Builder().build();
            String url = authUrl.toString().replace("http://", "ws://").replace("https://", "wss://");
         
            Request request = new Request.Builder().url(url).build();
            totalAnswer="";
//                    WebSocket webSocket = client.newWebSocket(request, new BigModelNew(i + "",false));
            //这里创建了大模型的新对象  实际上那些发送请求获取答案的操作都是在这个线程中做的

            BigModelNew bigModelNew = null;
            if (getHistory(userid)!=null){
                bigModelNew=new BigModelNew(userid, false,getHistory(userid),stringRedisTemplate);
            }
            else {
                bigModelNew=new BigModelNew(userid, false,historyList,stringRedisTemplate);
            }
            // 等待 WebSocket 的 run() 方法执行完毕
            int maxWaitTime = 10000; // 最大等待时间,单位:毫秒
            int currentWaitTime = 0; // 当前已等待的时间,单位:毫秒
            int waitInterval = 1000;// 每次等待的时间间隔,单位:毫秒
            WebSocket webSocket = client.newWebSocket(request, bigModelNew);
            System.out.println(maxWaitTime);
            while (currentWaitTime < maxWaitTime) {
                if (bigModelNew.getBotContent().equals("")) {
                    // run() 方法还未执行完毕,可以进行一些其他操作或等待一段时间
                    Thread.sleep(waitInterval);
                    System.out.println("正在执行线程"+Thread.currentThread().getName()+"...等待时间还剩:"+(maxWaitTime-currentWaitTime));
                    currentWaitTime += waitInterval;
                } else {
                    // run() 方法已执行完毕,获取 bot.content 值并进行后续操作
                    //System.out.println("run执行完毕");
                    return bigModelNew.getBotContent();
                    //System.out.println(botText.content);
                    // ...
                }
            }
        }
        totalFlag=true;
        return "网络开了点小差 试试重新发送你的消息吧";
    }
    // 构造函数
    public BigModelNew(@Value("${userId}") String userId
            ,@Value("${wsCloseFlag}") Boolean wsCloseFlag
            ,@Value("${HistoryList}")List<RoleContent> HistoryList
            ,@Value("${stringRedisTemplate}") StringRedisTemplate stringRedisTemplate) {
        this.userId = userId;
        this.wsCloseFlag = wsCloseFlag;
        this.historyList=HistoryList;
        this.stringRedisTemplate = stringRedisTemplate;
    }

这段代码实现了一个基于Spring和WebSocket的异步问答系统。主要的逻辑如下:

  1. 在get()方法中,接收前端传递的问题和id参数,并创建一个DeferredResult<Result>对象,用于异步返回结果给前端。

  2. 通过CompletableFuture.supplyAsync()方法创建一个异步任务,该任务会在一个线程池中执行。

  3. 异步任务的具体逻辑在callable类的call()方法中实现。在该方法中,调用main()方法进行问题回答,并将结果转换为JSON格式。

  4. 异步任务执行完毕后,通过deferredResult.setResult(result)方法将结果设置到DeferredResult对象中,实现异步返回结果给前端。

  5. 在main()方法中,判断是否是并发场景下的第一个请求。如果是第一个请求,则创建一个WebSocket连接,并等待run()方法执行完毕。

  6. 在run()方法中,通过WebSocket与远程服务进行通信,获取问题的回答。

  7. 在并发场景下,如果有多个请求同时到达,只有第一个请求会创建WebSocket连接,后续的请求会等待第一个请求的回答结果,并共享同一个totalAnswer。

在并发场景下,这样优化的优势在于:

  1. 使用线程池和异步任务可以提高并发处理能力,减少请求的等待时间。通过异步任务,可以将耗时的操作(如远程服务调用)放在后台线程中执行,而不会阻塞主线程。

  2. 使用DeferredResult对象可以实现异步返回结果给前端。每个请求都会得到一个独立的DeferredResult对象,通过设置结果到该对象中,可以实现异步返回给前端。

  3. 在并发场景下,只有第一个请求会创建WebSocket连接,后续的请求会等待第一个请求的回答结果。这样可以减少对远程服务的重复请求,节省资源和提高性能。

然后我们把外面的调用的功能构建好了 接下来就是WebSocket内部当中 重写的具体方法 下面是重写部分的方法:
 

//一个很关键的函数 用于得到botContent
    public String getBotContent() {
        return botContent;
    }


    public boolean canAddHistory(){  // 由于历史记录最大上线1.2W左右,需要判断是能能加入历史

        int history_length=0;
        for(RoleContent temp:historyList){
            history_length=history_length+temp.content.length();
        }
        if(history_length>12000){
            historyList=new ArrayList<>();
            return false;
        }else{
            return true;
        }

    }

    // 线程来发送音频与参数
    class MyThread extends Thread {
        private WebSocket webSocket;
        private  String newAnswer;
        public MyThread(WebSocket webSocket) {
            this.webSocket = webSocket;
        }

        public void run() {
            try {
                JSONObject requestJson=new JSONObject();
                JSONObject header=new JSONObject();  // header参数
                header.put("app_id",appid);
                header.put("uid",userId);//这里放userId
                JSONObject parameter=new JSONObject(); // parameter参数
                JSONObject chat=new JSONObject();
                chat.put("domain","generalv3");
                chat.put("temperature",0.6);
                chat.put("max_tokens",8192);
                parameter.put("chat",chat);
                JSONObject payload=new JSONObject(); // payload参数
                JSONObject message=new JSONObject();
                JSONArray text=new JSONArray();
                // 历史问题获取
                if(historyList.size()>0){
                    for(RoleContent tempRoleContent:historyList){
                        text.add(JSON.toJSON(tempRoleContent));
                    }
                }
                // 最新问题
                RoleContent roleContent=new RoleContent();
                roleContent.role="user";
                roleContent.content=NewQuestion;
                text.add(JSON.toJSON(roleContent));
//                System.err.println("text:");
                historyList.add(roleContent);
//                historyList.forEach(System.out::println);
                //saveHistory(historyList);//在这里就把历史记录存到Redis了 就可以清空该线程的历史记录List了
                //historyList.clear();
                message.put("text",text);
                payload.put("message",message);
                requestJson.put("header",header);
                requestJson.put("parameter",parameter);
                requestJson.put("payload",payload);
//                  System.err.println(requestJson); // 可以打印看每次的传参明细
                webSocket.send(requestJson.toString());
                // 等待服务端返回完毕后关闭
                while (true) {
                    // System.err.println(wsCloseFlag + "---");
                    Thread.sleep(200);
                    if (wsCloseFlag) {
                        break;
                    }
                }
                webSocket.close(1000, "");
//                System.out.println("answer"+botText.content);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                botContent=botText.content;
            }
        }
    }

    @Override
    public void onOpen(WebSocket webSocket, Response response) {
        super.onOpen(webSocket, response);
        //System.out.print("AI:");
        MyThread myThread = new MyThread(webSocket);
        myThread.start();
    }

    @Override
    public void onMessage(WebSocket webSocket, String text) {
        // System.out.println(userId + "用来区分那个用户的结果" + text);
        JsonParse myJsonParse = gson.fromJson(text, JsonParse.class);
        //System.out.println("AI:" + gson.toJson(myJsonParse.payload));
        if (myJsonParse.header.code != 0) {
            System.out.println("发生错误,错误码为:" + myJsonParse.header.code);
            System.out.println("本次请求的sid为:" + myJsonParse.header.sid);
            webSocket.close(1000, "");
        }
        List<Text> textList = myJsonParse.payload.choices.text;

        for (Text temp : textList) {
            //System.out.println("这里存了机器的话"+temp.content);
            botText.content=botText.content+temp.content;//这里存机器的话
            totalAnswer=totalAnswer+temp.content;
        }
        //System.out.println("answeraaaa:"+botText.content);//这里能够打印 但是打印很多次说明他调用了很多次
//        botText.content=totalAnswer;
        if (myJsonParse.header.status == 2) {
            // 可以关闭连接,释放资源
//            System.out.println();
//            System.out.println("*************************************************************************************");
            if(canAddHistory()){
                RoleContent roleContent=new RoleContent();
                roleContent.setRole("assistant");
                roleContent.setContent(totalAnswer);
                historyList.add(roleContent);
                //System.out.println("OnMessage:"+historyList.toString());
                //String jsonString = JSON.toJSONString(historyList, SerializerFeature.PrettyFormat);
                //history.text=jsonString;//这里已经把历史记录给保存了
                //在这里答案已经输出完了,就应该outputFinished = true;
//                output=botText.content;
//                myHistory=history.text;
                outputFlag=true;
                System.out.println("AI:answer"+botText.content);
            }else{
                RoleContent roleContent=new RoleContent();
                roleContent.setRole("assistant");
                roleContent.setContent(totalAnswer);
                historyList.add(roleContent);
            }
            //saveHistory(historyList);//在这里就把历史记录存到Redis了 就可以清空该线程的历史记录List了
            historyList.clear();
            wsCloseFlag = true;//只有等消息传过来了  才能够结束
            totalFlag=true;
        }

    }

    @Override
    public void onFailure(WebSocket webSocket, Throwable t, Response response) {
        super.onFailure(webSocket, t, response);
        if (null != response) {
            int code = response.code();
                System.out.println("onFailure code:" + code);
            try {
                System.out.println("onFailure body:" + response.body().string());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            if (101 != code) {
                System.out.println("connection failed");
                System.exit(0);
            }
        }
    }

这一段代码是可以应用在其他使用WebSocket连接ai的业务上的

是基于WebSocket的与远程服务进行问答的功能。主要的逻辑如下:

  1. MyThread类是一个继承自Thread的线程类,用于发送问答请求和接收回答。在run()方法中,首先构建请求的JSON对象,包括头部参数、参数和载荷参数。然后通过WebSocket发送该JSON对象。接着,在一个循环中等待服务端返回结果,并将返回的结果拼接到botText.content和totalAnswer中。最后,关闭WebSocket连接,并将botText.content赋值给botContent。

  2. onOpen()方法在WebSocket连接建立时被调用。在该方法中,创建一个MyThread对象并启动线程。

  3. onMessage()方法在接收到WebSocket消息时被调用。该方法首先解析收到的消息,并判断是否存在错误。如果没有错误,则将回答文本拼接到botText.content和totalAnswer中,并根据返回的状态码进行相应的处理。如果状态码为2,表示回答已经完整返回,此时可以关闭连接并进行一些后续处理,如将回答文本添加到历史记录中。

  4. onFailure()方法在WebSocket连接失败时被调用。在该方法中,可以根据失败的原因进行相应的处理。

最后 就是鉴权方法 这个内容 作为api的调用者  我们是不需要理解的(并不影响使用),当然如果对网络协议以及加密感兴趣的伙伴可以细看 我就直接放上来了,因为每家公司的鉴权方法都不一样,而且文档中会直接给出鉴权方法 直接复制到代码里面就可以的

// 鉴权方法
    public static String getAuthUrl(String hostUrl, String apiKey, String apiSecret) throws Exception {
        URL url = new URL(hostUrl);
        // 时间
        SimpleDateFormat format = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
        format.setTimeZone(TimeZone.getTimeZone("GMT"));
        String date = format.format(new Date());
        // 拼接
        String preStr = "host: " + url.getHost() + "\n" +
                "date: " + date + "\n" +
                "GET " + url.getPath() + " HTTP/1.1";
//        System.err.println(preStr);
        // SHA256加密
        Mac mac = Mac.getInstance("hmacsha256");
        SecretKeySpec spec = new SecretKeySpec(apiSecret.getBytes(StandardCharsets.UTF_8), "hmacsha256");
        mac.init(spec);
        byte[] hexDigits = mac.doFinal(preStr.getBytes(StandardCharsets.UTF_8));

        // Base64加密
        String sha = Base64.getEncoder().encodeToString(hexDigits);
//        System.err.println(sha);
        // 拼接
        String authorization = String.format("api_key=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"", apiKey, "hmac-sha256", "host date request-line", sha);
        // 拼接地址
        HttpUrl httpUrl = Objects.requireNonNull(HttpUrl.parse("https://" + url.getHost() + url.getPath())).newBuilder().//
                addQueryParameter("authorization", Base64.getEncoder().encodeToString(authorization.getBytes(StandardCharsets.UTF_8))).//
                addQueryParameter("date", date).//
                addQueryParameter("host", url.getHost()).//
                build();

//        System.err.println(httpUrl.toString());
        return httpUrl.toString();
    }

实现效果 

跟一个搞小程序的朋友借了个模板 套了一下前端 目前在小程序端实现了

响应的内容:

这是获取聊天记录的响应:

具体的业务我还做了提示词工程,让ai具备一点定向场景的倾向了,就像如下

具体的业务截图回应效果

如果朋友对定向提示词工程有兴趣的话可以专门出一期这个模块的博客

提示词工程主要的优势在于以下:

  1. 提高问答准确性:通过给用户提供定向场景的提示词,可以引导用户在特定领域或场景下提问。这样做可以减少模糊或不相关的问题,从而提高问答的准确性。提示词可以限制用户的问题范围,使得AI能够更好地理解用户的意图并给出相关的回答。

  2. 加速问题解决:定向场景的提示词工程可以帮助用户快速定位到他们感兴趣的领域或问题类型,并提供相关的问题模板或关键词。这样可以节省用户在描述问题上的时间和精力,使得问题能够更快地得到解答,提高问题解决的效率。

  3. 提升用户体验:通过为用户提供定向场景的提示词,可以使用户感到更加舒适和自信。用户知道他们在与AI进行交互时所处的场景,并且可以根据提示词的指引进行提问。这种引导性的交互方式可以减少用户的迷茫和犹豫,提升用户与AI的交互体验。

  4. 简化系统配置:定向场景的提示词工程可以帮助系统管理员或开发人员更好地配置和管理问答系统。通过定义和组织不同的场景和相关的提示词,可以使系统的配置更加直观和可控。管理员可以根据实际需求进行提示词的调整和更新,以适应不同的应用场景。

有兴趣的小伙伴可以先关注一下我  下一期出的话我会发粉丝通告哦

YOLOv8/v10/v11野外监测实战:SpringBoot构建可落地的野生动物AI检测系统 YOLO目标检测是计算机视觉中面向真实场景的通用技术,其核心在于模型轻量化、小目标识别与低光照鲁棒性等工程化能力;SpringBoot作为主流Java后端框架,不仅提供Web服务,更承担AI工作流编排、多源数据融合与任务状态管理等关键职责。在野生动物监测这类标注稀缺、边缘部署、长时无人值守的典型弱监督工业场景中,YOLOv8提供稳定基线,YOLOv10优化训练收敛,YOLOv11增强遮挡与低光适应——三者协同构成分层检测体系;而SpringBoot通过智能调度、模型热切换与WebSocket实时反馈,将算法 阅读详情

相关推荐

SpringBoot智慧高校学术报告系统开发实践

学术报告系统作为高校信息化建设的重要组成部分,其核心价值在于提升科研工作效率。基于SpringBoot框架开发的系统天然具备自动配置、快速部署等优势,结合MyBatis-Plus实现高效数据持久化操作。在AI技术应用层面,通过LangChain框架集成多模型能力,实现智能写作辅助与文献处理。该系统典型应用场景包括:自动生成符合学术规范的报告框架、多语言互译、实时协作评审等。特别在高校环境中,系统与Elasticsearch的深度整合,为研究人员提供了强大的文献检索能力。采用分层架构设计,前端Vue3+后端S

weixin_34242819的博客 460

探索Spring AI:将人工智能与软件开发无缝融合

现在,随着Spring AI的崭露头角,我们看到了两者之间的令人兴奋的交汇点。通过利用Spring AI提供的丰富功能和工具,开发人员可以更快地开发出功能强大、智能化的应用程序,从而提高用户体验,推动业务发展。我们可以使用Spring AI提供的自然语言处理工具来处理用户输入的文本,然后利用机器学习模型来预测用户问题的意图,最终给出相应的回答。通过利用Spring AI提供的自然语言处理、机器学习、图像识别等功能,开发人员可以为他们的应用程序增加更多的智能,提升用户体验。

威哥爱编程,华为 HDE,鸿蒙极客、优快云博客专家、《鸿蒙 HarmonyOS 5/6 开发之路》系列图书第一作者 3556

大模型选型实战指南:Gemini、ChatGPT、Grok、Claude、Deepseek场景适配对比

大模型不是越‘大’越好,而是越‘对’越强。理解不同模型的底层架构差异(如注意力机制、训练语料分布、多模态能力)是工程落地的前提;其技术价值在于将抽象能力转化为可量化的业务指标——如合同审查的法律条文引用准确率、客服响应的字段提取完整率、长文档摘要的关键信息保留率;典型应用场景包括金融合规审核、中文政务公文处理、海外社媒舆情分析、多模态财报解读及Z世代内容生成;本文基于47个生产环境API实测案例,聚焦Gemini-1.5-Pro、ChatGPT-4o、Claude-3.5-Sonnet、Grok-2和Dee

WGH100817的博客 490

2026 后端 AI 集成工程化:Spring AI 2.0、MCP 协议与 Agent 内嵌的三条落地路径拆解

先收口,再协议化,最后才是内嵌。Spring AI 2.0 解决的是"用统一编程模型接住多厂商与 RAG",MCP 解决的是"工具与资源跨框架复用的契约",Agent 内嵌解决的是"多轮任务在你的服务体系里如何长期运行"。三者各司其职,任何一个都不能替代另两个。最后再次强调本文的核验纪律:Spring AI 2.0、Spring Boot 4、Java 25 与 MCP 的具体版本、API 与兼容矩阵,以官方文档与 release notes 为准;所有性能与成本数字,以团队自己的压测与账单为准;

m0_74899094的博客 455

2. 快速在Spring Boot中集成Spring AI

而Spring AI作为Spring生态的一部分,提供了与人工智能技术结合的能力,可以帮助开发者轻松将AI能力集成到Spring Boot项目中。本篇文章,我们展示了如何在Spring Boot项目中快速集成Spring AI,并结合OpenAI API构建一个简单的智能对话系统。通过几步简单的配置和代码实现,开发者可以快速将AI能力集成到现有的Spring Boot项目中。本篇文章将引导你如何在Spring Boot中快速集成Spring AI,并通过简单的示例实现AI功能。这里选用硅基流动API密钥。

有一只柴犬的专栏 6465

【AI大模型】SpringBoot整合Spring AI 核心组件使用详解

SpringBoot整合Spring AI 核心组件使用详解

congge 1万+

Java AI编程工具四层架构选型指南:从IDE插件到本地模型

AI编程工具的本质不是模型参数大小或响应速度,而是其在真实开发流程中的嵌入深度。理解代码补全、语义搜索、离线推理、AST级重构等基础能力的技术原理,才能评估其在Java工程中的实际价值。尤其在Spring Boot 3.x、Lombok、MyBatis-Plus等主流生态下,工具对配置感知、注解兼容、私有代码学习等关键能力,直接决定是否具备生产可用性。本文基于JDK17+Spring Boot 3.2真实环境,系统梳理IDE插件层、AI原生IDE层、CLI本地模型层与文档智能层的协同逻辑,聚焦通义灵码、Cu

367

第 19 篇:从零搭一个可写进简历的企业级智能客服项目|Java+AI完整实战 > Java+AI 落地实战系列 | 全流程整合 | 大厂标准 | 可直接落地写进简历

本文是 Java+AI 落地实战系列第 19 篇,整合前序所有知识点,从零到一拆解企业内部智能客服完整项目,覆盖需求分析、技术选型、分层架构、核心表设计、全链路流程、落地节奏与简历写法,符合大厂生产标准,可直接落地或写进简历。

qq_55253420的博客 22

AI Agent量产落地:2026技术成熟窗口下的市场分析与实战指南

AI Agent(智能体)是具备感知、规划、工具调用与记忆管理能力的自主系统,其核心理念并非取代人类,而是将复杂任务拆解为可执行、可校验的闭环流程。随着大模型推理成本下降、工程配套成熟,Agent正从概念验证快速走向生产环境,成为企业降本增效与个人效率提升的关键技术。从企业内部的流程自动化、Java与Spring Boot体系的无缝集成,到个人用Obsidian搭建本地知识库,再到垂直行业的深度应用,Agent的落地场景正在全面扩展。2026年被称为技术成熟窗口期,需求侧从“聊天问答”转向“结果交付”,供给

weixin_34175509的博客 313

SpringBoot+Vue校园考勤与教学一体化系统实战

校园考勤系统是教育数字化转型的基础能力,其核心在于实时定位校验、多源数据融合与业务闭环驱动。基于SpringBoot的高并发事务处理与Vue的响应式状态管理,可构建低延迟、强一致、易运维的教学一体化平台。技术价值体现在三重定位(GPS+Wi-Fi+蓝牙)精准识别课堂在场状态,以及以学生ID为枢纽的全域数据模型,支撑选课、排课、考勤、成绩全链路自动流转。典型应用场景覆盖高校日常教学管理、教务决策分析与区域教育信息化部署。本文聚焦SpringBoot与Vue协同落地的工程实践,涵盖三级定位实现、事件驱动闭环设计

weixin_33831196的博客 474

Spring Boot 微服务 API 网关实战:Spring Cloud Gateway 整合,搞定路由转发 + 统一认证 + 限流熔断(企业级落地)

摘要:本文详细介绍了SpringCloud Gateway在微服务架构中的核心作用与实现方案。作为API网关,它解决了服务入口分散、认证冗余、流量失控等痛点,提供路由转发、统一认证、限流熔断等能力。文章通过图书管理系统案例,演示了SpringBoot整合Gateway的全流程,包括基础路由配置、JWT全局认证、局部参数校验、Sentinel限流熔断以及Nacos动态路由等核心功能实现。特别强调了企业级落地中的关键注意事项,如路由顺序、过滤器执行顺序、HTTPS配置等。该方案能有效构建统一、安全、高效的微服务

lamehsl的专栏 1382

基于YOLOv8/v10/v11/v12/26的森林野外火灾火焰烟雾检测系统(Spring Boot+Vue+Flask+DeepSeek+千问大模型)完整实现与模型对比分析

基于YOLOv8/v10/v11/v12/26的森林野外火灾火焰烟雾检测系统(Spring Boot+Vue+Flask+DeepSeek+千问大模型)完整实现与模型对比分析

斌擎科技 484

newman的使用

Newman是一个基于Node.js的postman命令行工具,用于运行和测试PostmanAPI 请求的集合。它允许用户在命令行环境中执行Postman的JSON文件,从而实现接口自动化测试和持续集成,同时支持用户进行自动化测试、批量执行请求、生成报告等操作。

m0_62825058的博客 1617

YOLO多版本工程化实践:SpringBoot构建农业目标检测闭环系统

目标检测是计算机视觉基础任务,其核心在于在图像中准确定位并识别各类物体。YOLO系列作为单阶段检测器代表,以速度与精度平衡著称,原理上通过网格划分、边界框回归与置信度分类实现端到端预测。其技术价值体现在实时性、轻量化与部署友好性,广泛应用于工业质检、智能交通及智慧农业等场景。在农业智能化落地中,模型选型需兼顾边缘算力约束与小目标(如青果、斑点)检测精度,而工程化挑战更集中于模型热更新、GPU资源调度与多AI模块协同。本文聚焦苹果成熟度检测这一典型任务,结合YOLOv8与YOLOv10的实测对比,详解Spri

weixin_34060299的博客 562

谐振电路原理与应用场景全解析

本文全面解析了谐振电路的原理、类型及其核心应用。详细阐述了串联谐振与并联谐振的工作特性,并重点介绍了其在无线通信调谐、音频处理分频以及电力系统滤波与无功补偿等关键场景中的实际作用。通过公式推导与实例分析,帮助读者深入理解LC谐振的选频与能量交换机制。

t1u2v的博客 841

【Docker】完美解决拉取镜像超时报错:ERROR: Get https://registry-1.docker.io/v2/

因为我们下载的镜像是外网的镜像资源,所以下载的速度会非常的慢,甚至大概率下载时会报错,所以需要我们配置一个国内的服务器镜像地址,国内服务器镜像地址有很多,这里咱们就说一下阿里镜像加速器的配置方法。

liu_chen_yang的博客 12万+

基于springboot冀域特色水产品销售小程序-计算机毕设 【课程设计】 02742

利用Spring Boot框架,系统构建了高效、稳定的后端服务,实现了用户注册登录、商品展示、购物车管理、订单处理等功能。同时,结合前端技术,打造了直观易用的用户界面,提升了用户体验。 在特色水产品方面,系统深入分析冀域水产品资源,通过小程序进行精准营销,将优质产品推向更广阔的市场。营销小程序不仅提供了便捷的购物体验,还通过新闻资讯、网站公告等模块,增强了用户与产品的互动,提升了品牌忠诚度。 此外,系统还注重数据分析,通过收集用户行为数据,分析用户偏好与需求,为产品优化与营销策略调整提供了有力支持。 综上所

WeiXin_DZbishe的博客 1926

【日志】Prometheus/Loki+Alertmanager+Grafana监控告警

参考文章:匹配写法:https://blog.ossq.cn/2674.html。

CN_Eden 1325

LLM应用设计不是加AI按钮,而是系统工程重构

大语言模型(LLM)应用并非传统软件的简单功能叠加,其本质是计算范式从确定性逻辑向概率性语义推理的根本转变。这一转变要求重新设计输入解析、提示工程、模型编排与输出治理等核心环节,尤其在RAG检索增强、意图识别、动态重排序和安全沙箱等关键技术上需深度工程化。面向Java/Spring Boot等企业级技术栈的LLM系统,必须兼顾语义准确性、上下文感知能力与生产级稳定性,典型落地场景包括工程师知识助手、智能代码补全与错误诊断平台。本文聚焦真实项目中可复用的架构决策与避坑实践。

diaohuyi6830的博客 368

解决:请求的资源[/xxx/]不可用 描述 源服务器未能找到目标资源的表示或者是不愿公开一个已经存在的资源表示。

解决:请求的资源[/xxx/]不可用 描述 源服务器未能找到目标资源的表示或者是不愿公开一个已经存在的资源表示。

念兮为美 1万+

AI Agent在医疗诊断中的智能应用研究

本文探讨了AIAgent在医疗诊断中的智能应用,分析了其技术原理、实际案例及发展挑战。AIAgent通过机器学习算法处理医疗数据,提升诊断准确性和效率,市场规模预计2025年达200亿美元。核心技术包括数据预处理、深度学习模型和隐私保护方法。应用案例涵盖肺癌筛查、阿尔茨海默病预测等,但面临数据偏差、伦理责任等挑战。未来趋势包括多模态学习、个性化医疗和量子计算融合。随着技术优化和伦理完善,AIAgent将成为医疗体系的重要组成部分。

郑伟强dev的专栏 98

【课程设计】springboot在线知识答题系统-计算机毕业设计源码29058

该系统不仅支持用户注册登录、首页推荐、考试答题、通知公告、考试资讯、反馈建议、知识学习和个人中心等功能,还为管理员提供了强大的后台管理功能,包括用户信息管理、角色管理、知识学习管理、轮播图管理、留言管理、通知公告管理、新闻管理和考试管理等。

Biye_Design的博客 1697

飞牛NAS打造成童年经典游戏机

这篇文章介绍如何使用飞牛NAS搭建经典游戏模拟器。首先需开启Docker并下载RetroArch-web镜像,随后创建容器并设置端口映射。启动后上传游戏ROM文件(如NES格式),在模拟器中加载即可游玩。文章以修改版坦克大战为例,详细说明按键配置方法。同时还提到公网访问需配置DDNS或使用ZeroTier内网穿透。通过这套方案,用户可以在NAS上重温红白机等经典游戏体验。

dgnankai的专栏 889

【课程设计】基于Spring Boot的公益众筹爱心捐赠系统的设计与实现 计算机毕业设计源码74868

系统实现了包括志愿者用户端和管理员后台在内的多种功能模块。志愿者用户可以浏览首页、通知公告、公益资讯、参与公益项目及培训活动等;管理员则负责审核物品和资金捐赠、管理公益类型与项目、维护系统资源等。系统采用Spring Boot作为后端框架,结合Java语言的强大功能以及MySQL数据库的支持,确保系统的稳定性和数据的安全性。 本系统的建立不仅有助于提高公益项目的管理和执行效率,还能够增强公众对公益事业的信任感,促进更多人参与到爱心捐赠中来。其创新之处在于将现代信息技术与传统公益活动相结合,提供了一个开放..

Biye_Design的博客 1118

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

Java打造同城羽毛球馆线上预约平台,一键预订超轻松

基于Java技术栈开发的同城羽毛球馆线上预约平台解决方案。通过SpringBoot微服务架构实现系统高可用,结合Redis缓存、分布式锁和消息队列处理高并发场景,采用Vue.js+UniApp实现跨平台覆盖。平台核心功能包括智能选场、一键预约、动态定价和全流程自动化,通过AI算法提升资源利用率30%以上。在用户体验方面,通过手势操作、骨架屏技术等优化交互流程,首屏加载时间控制在1秒以内。典型案例显示,平台可将用户预约耗时从8分钟降至1.2分钟,场馆使用率提升45%,展现了Java技术在现代运动预约场景中的强

小马总的博客 1528

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

上一篇: 【Spring原理高级进阶】有Redis为啥不用?深入剖析 Spring Cache:缓存的工作原理、缓存注解的使用方法与最佳实践
下一篇: 【Redis实战】有MQ为啥不用?用Redis作消息队列!?Redis作消息队列使用方法及底层原理高级进阶
苏泽SuZe
苏泽SuZe 新星创作者: Java技术领域 新星创作者: Java技术领域
博客等级 码龄4年 7800粉丝 113原创
评论 30
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苏泽SuZe

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值