使用SpringBoot3整合Spring AI實現(xiàn)具有記憶功能的AI助手

更新時間：2026年04月12日 15:16:52 作者：Nhuanuary

本文介紹了使用SpringBoot3整合SpringAI和Redis實現(xiàn)一個具有記憶功能的AI助手,項目使用Redis作為存儲介質(zhì),支持用戶級別的會話隔離和30天的對話歷史持久化,詳細介紹了環(huán)境準備、項目初始化、核心配置、功能實現(xiàn)及測試驗證步驟,需要的朋友可以參考下

1. 項目概述

本教程詳細介紹如何使用 Spring Boot 3 整合 Spring AI 實現(xiàn)一個具有記憶功能的 AI 助手。該實現(xiàn)使用 Redis 作為存儲介質(zhì)，支持用戶級別的會話隔離和 30 天的對話歷史持久化。

技術(shù)棧

Spring Boot 3.3.0
Java 17
Spring AI
Redis 6.0+
MyBatis Plus
MySQL 8.0
Sa-Token（用戶認證）

2. 環(huán)境準備

2.1 安裝必要軟件

JDK 17+：Oracle JDK 或 OpenJDK
Maven 3.9+：Maven 官網(wǎng)
Redis 6.0+：Redis 官網(wǎng) 或使用 Docker
MySQL 8.0+：MySQL 官網(wǎng) 或使用 Docker
IDE：IntelliJ IDEA 或 Eclipse

2.2 配置環(huán)境變量

確保 JAVA_HOME 和 MAVEN_HOME 已正確配置。

3. 項目初始化

3.1 創(chuàng)建 Spring Boot 項目

使用 Spring Initializr 創(chuàng)建項目：

訪問 Spring Initializr
選擇 Spring Boot 3.3.0
選擇 Java 17
添加依賴：Spring Web, Spring Data Redis, MyBatis Plus, MySQL Driver, Spring Boot DevTools

3.2 配置 Maven 依賴

在 pom.xml 文件中添加以下依賴：

<dependencies>
    <!-- Spring Boot 核心依賴 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- MyBatis Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.5</version>
    </dependency>
    <!-- MySQL 驅(qū)動 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Spring AI -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai</artifactId>
        <version>1.0.0</version>
    </dependency>
    <!-- Sa-Token 認證 -->
    <dependency>
        <groupId>cn.dev33</groupId>
        <artifactId>sa-token-spring-boot-starter</artifactId>
        <version>1.38.1</version>
    </dependency>
    <!-- Jackson 序列化 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- Spring Boot 測試 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

4. 核心配置

4.1 應(yīng)用配置文件 (application.yml)

創(chuàng)建 src/main/resources/application.yml 文件，配置應(yīng)用信息：

server:
  port: 9527
  servlet:
    context-path: /api
spring:
  application:
    name: smart-pic-community-backend
  # Redis 配置
  data:
    redis:
      database: 2
      host: localhost
      port: 6379
      timeout: 5000
  # 數(shù)據(jù)庫配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/smart_pic_community
    username: root
    password: your_password
  # Spring AI 配置
  ai:
    openai:
      base-url: https://api.deepseek.com/  # 使用 DeepSeek API
      api-key: your_api_key
      chat:
        options:
          model: deepseek-chat

4.2 Redis 配置 (RedisConfiguration.java)

創(chuàng)建 Redis 配置類，確保正確序列化對象：

package com.spc.smartpiccommunitybackend.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
@Slf4j
public class RedisConfiguration {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        log.info("開始創(chuàng)建redis模板對象...");
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 設(shè)置連接工廠
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用 StringRedisSerializer 來序列化和反序列化 redis 的 key
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key 采用 String 的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // 使用 Jackson2JsonRedisSerializer 來序列化和反序列化 redis 的 value
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // value 采用 JSON 的序列化方式
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

注意事項：

使用 Jackson2JsonRedisSerializer 而不是 StringRedisSerializer 可以避免 ClassCastException
啟用默認類型可以確保反序列化時能正確識別對象類型

5. 核心功能實現(xiàn)

5.1 創(chuàng)建模型類

5.1.1 創(chuàng)建 MessageVO.java

創(chuàng)建消息視圖對象，用于前端展示：

package com.spc.smartpiccommunitybackend.model.vo.ai;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.ai.chat.messages.Message;

@NoArgsConstructor
@Data
public class MessageVO {
    private String role;
    private String content;

    public MessageVO(Message message) {
        this.role = switch (message.getMessageType()) {
            case USER -> "user";
            case ASSISTANT -> "assistant";
            case SYSTEM -> "system";
            default -> "";
        };
        this.content = message.getText();
    }
}

功能說明：

將 Spring AI 的 Message 對象轉(zhuǎn)換為前端可識別的格式
根據(jù)消息類型設(shè)置不同的角色
提取消息內(nèi)容用于展示

5.1.2 創(chuàng)建 SerializableMessage.java

創(chuàng)建可序列化的消息對象，用于 Redis 存儲：

package com.spc.smartpiccommunitybackend.model.entity.ai;

import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;

@Data
@NoArgsConstructor
public class SerializableMessage implements Serializable {
    private static final long serialVersionUID = 1L;

    private String role;
    private String content;
    private String messageType;
    private Long timestamp;

    public SerializableMessage(String role, String content, String messageType) {
        this.role = role;
        this.content = content;
        this.messageType = messageType;
        this.timestamp = System.currentTimeMillis();
    }

    public SerializableMessage(String role, String content) {
        this(role, content, "user");
    }
}

功能說明：

實現(xiàn) Serializable 接口，支持 Redis 序列化
包含角色、內(nèi)容、消息類型和時間戳字段
提供多個構(gòu)造方法，方便使用

5.2 定義倉庫接口 (ChatHistoryRepository.java)

創(chuàng)建聊天歷史倉庫接口：

package com.spc.smartpiccommunitybackend.repository;

import java.util.List;
import java.util.Map;

public interface ChatHistoryRepository {
    /**
     * 保存會話記錄
     */
    void save(String type, String chatId, Long userId);
    
    /**
     * 獲取用戶的會話ID列表
     */
    List<String> getChatIds(Long userId, String type);
    
    /**
     * 保存聊天消息
     */
    void saveMessage(String chatId, String message, String sender);
    
    /**
     * 獲取聊天消息歷史
     */
    List<String> getMessages(String chatId);
    
    /**
     * 刪除會話
     */
    void deleteChat(Long userId, String type, String chatId);
    
    /**
     * 獲取會話信息
     */
    Map<Object, Object> getSessionInfo(String chatId);
}

5.3 實現(xiàn) Redis 聊天歷史倉庫 (RedisChatHistoryRepository.java)

實現(xiàn)基于 Redis 的聊天歷史倉庫：

package com.spc.smartpiccommunitybackend.repository;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonProcessingException;
import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Component
@RequiredArgsConstructor
public class RedisChatHistoryRepository implements ChatHistoryRepository {

    private final RedisTemplate<String, Object> redisTemplate;

    // Redis key前綴
    private static final String CHAT_HISTORY_PREFIX = "chat:history:";
    private static final String CHAT_SESSION_PREFIX = "chat:session:";
    private static final String CHAT_MESSAGES_PREFIX = "chat:messages:";

    /**
     * 保存會話記錄
     */
    @Override
    public void save(String type, String chatId, Long userId) {
        // 保存會話信息
        String sessionKey = CHAT_SESSION_PREFIX + chatId;
        Map<String, Object> sessionInfo = new HashMap<>();
        sessionInfo.put("userId", String.valueOf(userId));
        sessionInfo.put("type", type);
        sessionInfo.put("createTime", System.currentTimeMillis());
        sessionInfo.put("lastUpdateTime", System.currentTimeMillis());
        redisTemplate.opsForHash().putAll(sessionKey, sessionInfo);
        // 設(shè)置過期時間為30天
        redisTemplate.expire(sessionKey, 30, TimeUnit.DAYS);

        // 將chatId添加到用戶的聊天歷史列表中
        String historyKey = CHAT_HISTORY_PREFIX + userId + ":" + type;
        redisTemplate.opsForSet().add(historyKey, chatId);
        // 設(shè)置過期時間為30天
        redisTemplate.expire(historyKey, 30, TimeUnit.DAYS);
    }

    /**
     * 獲取用戶的會話ID列表
     */
    @Override
    public List<String> getChatIds(Long userId, String type) {
        String historyKey = CHAT_HISTORY_PREFIX + userId + ":" + type;
        Set<Object> chatIds = redisTemplate.opsForSet().members(historyKey);
        if (chatIds == null || chatIds.isEmpty()) {
            return Collections.emptyList();
        }
        return chatIds.stream()
                .map(Object::toString)
                .collect(Collectors.toList());
    }

    /**
     * 保存聊天消息
     */
    @Override
    public void saveMessage(String chatId, String message, String sender) {
        String messagesKey = CHAT_MESSAGES_PREFIX + chatId;
        // 創(chuàng)建消息對象
        Map<String, Object> messageInfo = new HashMap<>();
        messageInfo.put("content", message);
        messageInfo.put("sender", sender);
        messageInfo.put("timestamp", System.currentTimeMillis());
        // 使用JSON格式保存消息
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            String jsonMessage = objectMapper.writeValueAsString(messageInfo);
            redisTemplate.opsForList().rightPush(messagesKey, jsonMessage);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            // 如果JSON序列化失敗，使用原始消息
            redisTemplate.opsForList().rightPush(messagesKey, message);
        }
        // 設(shè)置過期時間為30天
        redisTemplate.expire(messagesKey, 30, TimeUnit.DAYS);

        // 更新會話的最后更新時間
        String sessionKey = CHAT_SESSION_PREFIX + chatId;
        redisTemplate.opsForHash().put(sessionKey, "lastUpdateTime", System.currentTimeMillis());
        // 確保會話信息也有過期時間
        redisTemplate.expire(sessionKey, 30, TimeUnit.DAYS);
    }

    /**
     * 獲取聊天消息歷史
     */
    @Override
    public List<String> getMessages(String chatId) {
        String messagesKey = CHAT_MESSAGES_PREFIX + chatId;
        List<Object> messages = redisTemplate.opsForList().range(messagesKey, 0, -1);
        if (messages == null || messages.isEmpty()) {
            return Collections.emptyList();
        }
        return messages.stream()
                .map(Object::toString)
                .collect(Collectors.toList());
    }

    /**
     * 刪除會話
     */
    @Override
    public void deleteChat(Long userId, String type, String chatId) {
        // 從用戶的聊天歷史列表中刪除
        String historyKey = CHAT_HISTORY_PREFIX + userId + ":" + type;
        redisTemplate.opsForSet().remove(historyKey, chatId);

        // 刪除會話信息
        String sessionKey = CHAT_SESSION_PREFIX + chatId;
        redisTemplate.delete(sessionKey);

        // 刪除聊天消息
        String messagesKey = CHAT_MESSAGES_PREFIX + chatId;
        redisTemplate.delete(messagesKey);
    }

    /**
     * 獲取會話信息
     */
    @Override
    public Map<Object, Object> getSessionInfo(String chatId) {
        String sessionKey = CHAT_SESSION_PREFIX + chatId;
        return redisTemplate.opsForHash().entries(sessionKey);
    }
}

注意事項：

使用不同的 Redis key 前綴區(qū)分不同類型的數(shù)據(jù)
為所有 Redis 鍵設(shè)置過期時間，避免內(nèi)存泄漏
處理 JSON 序列化失敗的情況，提高系統(tǒng)健壯性

5.4 實現(xiàn)聊天記憶 (RedisChatMemory.java)

實現(xiàn)基于 Redis 的聊天記憶，支持 Spring AI 的 ChatMemory 接口：

package com.spc.smartpiccommunitybackend.config;

import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Component
public class RedisChatMemory implements ChatMemory {

    private final RedisTemplate<String, Object> redisTemplate;
    private static final String MEMORY_KEY_PREFIX = "chat:memory:";
    private static final long EXPIRATION_DAYS = 30;

    public RedisChatMemory(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void add(String key, List<Message> messages) {
        // 為特定會話添加多條消息
        for (Message message : messages) {
            addMessage(key, message);
        }
    }

    @Override
    public List<Message> get(String key, int maxCount) {
        // 實現(xiàn) get 方法，根據(jù) key 獲取消息
        List<Message> messages = getMessages(key);
        // 如果指定了最大數(shù)量，返回不超過該數(shù)量的消息
        if (maxCount > 0 && messages.size() > maxCount) {
            return messages.subList(messages.size() - maxCount, messages.size());
        }
        return messages;
    }

    @Override
    public void clear() {
        // 清理所有會話記憶
        // 注意：這個操作會刪除所有聊天記憶，謹慎使用
    }

    /**
     * 為特定會話添加消息
     */
    public void addMessage(String chatId, Message message) {
        String key = MEMORY_KEY_PREFIX + chatId;
        redisTemplate.opsForList().rightPush(key, message);
        redisTemplate.expire(key, EXPIRATION_DAYS, TimeUnit.DAYS);
    }

    /**
     * 獲取特定會話的消息
     */
    public List<Message> getMessages(String chatId) {
        String key = MEMORY_KEY_PREFIX + chatId;
        List<Object> objects = redisTemplate.opsForList().range(key, 0, -1);
        List<Message> messages = new ArrayList<>();
        if (objects != null) {
            for (Object obj : objects) {
                if (obj instanceof Message) {
                    messages.add((Message) obj);
                }
            }
        }
        return messages;
    }

    /**
     * 清理特定會話的記憶
     */
    public void clear(String chatId) {
        String key = MEMORY_KEY_PREFIX + chatId;
        redisTemplate.delete(key);
    }
}

注意事項：

實現(xiàn) ChatMemory 接口以支持 Spring AI 的消息記憶功能
為每條消息設(shè)置過期時間，確保內(nèi)存使用合理
提供批量添加和獲取消息的方法，提高性能

5.5 配置 ChatClient (CommonConfiguration.java)

配置 Spring AI 的 ChatClient：

package com.spc.smartpiccommunitybackend.config;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.client.advisor.SimpleLoggerAdvisor;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.openai.OpenAiChatModel;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CommonConfiguration {

    @Bean
    public ChatClient chatClient(OpenAiChatModel openAiChatModel, ChatMemory chatMemory) {
        return ChatClient.builder(openAiChatModel)
                .defaultAdvisors(
                        new SimpleLoggerAdvisor(),
                        new MessageChatMemoryAdvisor(chatMemory)
                )
                .build();
    }
}

注意事項：

使用 MessageChatMemoryAdvisor 來啟用聊天記憶功能
使用 SimpleLoggerAdvisor 來記錄聊天交互，方便調(diào)試

5.6 實現(xiàn)聊天控制器 (ChatController.java)

實現(xiàn)聊天控制器，處理 AI 對話請求：

package com.spc.smartpiccommunitybackend.controller;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.spc.smartpiccommunitybackend.repository.RedisChatHistoryRepository;
import com.spc.smartpiccommunitybackend.service.UserService;
import com.spc.smartpiccommunitybackend.utils.ErrorCode;
import com.spc.smartpiccommunitybackend.utils.ThrowUtils;
import com.spc.smartpiccommunitybackend.pojo.User;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.beans.factory.annotation.Resource;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/ai")
public class ChatController {

    private final ChatClient chatClient;
    private final RedisChatHistoryRepository chatHistoryRepository;
    @Resource
    private UserService userService;

    public ChatController(ChatClient chatClient, RedisChatHistoryRepository chatHistoryRepository) {
        this.chatClient = chatClient;
        this.chatHistoryRepository = chatHistoryRepository;
    }

    @RequestMapping(value = "/chat", produces = "text/html;charset=UTF-8")
    public Flux<String> chat(@RequestParam(defaultValue = "講個笑話") String prompt,
                             String chatId,
                             HttpServletRequest request) {
        User loginUser = userService.getLoginUser(request);
        // 校驗登錄用戶是否為空
        ThrowUtils.throwIf(loginUser == null, ErrorCode.NOT_LOGIN_ERROR);
        Long userId = loginUser.getId();
        
        // 保存會話信息
        chatHistoryRepository.save("chat", chatId, userId);

        // 獲取歷史對話消息作為上下文
        List<Message> messages = new ArrayList<>();
        
        // 添加系統(tǒng)消息
        SystemMessage systemMessage = new SystemMessage(
            "你是一個智能圖片社區(qū)的AI助手，名為虹小智。請用友好、專業(yè)的語氣回答用戶問題，" +
            "提供關(guān)于圖片社區(qū)的相關(guān)信息和幫助。"
        );
        messages.add(systemMessage);
        
        // 獲取并解析歷史消息
        List<String> historyMessages = chatHistoryRepository.getMessages(chatId);
        ObjectMapper objectMapper = new ObjectMapper();
        
        for (String messageStr : historyMessages) {
            try {
                JsonNode node = objectMapper.readTree(messageStr);
                String sender = node.get("sender").asText();
                String content = node.get("content").asText();
                
                if ("user".equals(sender)) {
                    messages.add(new UserMessage(content));
                } else if ("ai".equals(sender)) {
                    messages.add(new AssistantMessage(content));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        // 添加用戶當前消息
        messages.add(new UserMessage(prompt));
        
        // 保存用戶消息到歷史記錄
        chatHistoryRepository.saveMessage(chatId, prompt, "user");
        
        // 調(diào)用AI模型獲取響應(yīng)
        return chatClient.stream(messages)
                .doOnNext(response -> {
                    // 保存AI響應(yīng)到歷史記錄
                    chatHistoryRepository.saveMessage(chatId, response, "ai");
                });
    }
}

注意事項：

驗證用戶登錄狀態(tài)，確保會話隔離
保存用戶消息和 AI 響應(yīng)到歷史記錄
使用 Flux 實現(xiàn)流式響應(yīng)，提高用戶體驗
處理歷史消息解析異常，提高系統(tǒng)健壯性

5.7 實現(xiàn)聊天歷史控制器 (ChatHistoryController.java)

實現(xiàn)聊天歷史控制器，處理聊天歷史的獲取和刪除：

package com.spc.smartpiccommunitybackend.controller;

import com.spc.smartpiccommunitybackend.repository.RedisChatHistoryRepository;
import com.spc.smartpiccommunitybackend.service.UserService;
import com.spc.smartpiccommunitybackend.utils.ErrorCode;
import com.spc.smartpiccommunitybackend.utils.ThrowUtils;
import com.spc.smartpiccommunitybackend.pojo.User;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

@RestController
@RequestMapping("/ai/history")
public class ChatHistoryController {

    private final RedisChatHistoryRepository chatHistoryRepository;
    private final UserService userService;

    public ChatHistoryController(RedisChatHistoryRepository chatHistoryRepository, UserService userService) {
        this.chatHistoryRepository = chatHistoryRepository;
        this.userService = userService;
    }

    /**
     * 獲取用戶的聊天歷史ID列表
     */
    @GetMapping("/{type}")
    public List<String> getChatHistory(@PathVariable String type, HttpServletRequest request) {
        User loginUser = userService.getLoginUser(request);
        ThrowUtils.throwIf(loginUser == null, ErrorCode.NOT_LOGIN_ERROR);
        Long userId = loginUser.getId();
        
        return chatHistoryRepository.getChatIds(userId, type);
    }

    /**
     * 刪除指定聊天歷史
     */
    @DeleteMapping("/{type}/{chatId}")
    public boolean deleteChatHistory(@PathVariable String type, 
                                    @PathVariable String chatId, 
                                    HttpServletRequest request) {
        User loginUser = userService.getLoginUser(request);
        ThrowUtils.throwIf(loginUser == null, ErrorCode.NOT_LOGIN_ERROR);
        Long userId = loginUser.getId();
        
        chatHistoryRepository.deleteChat(userId, type, chatId);
        return true;
    }
}

注意事項：

驗證用戶登錄狀態(tài)，確保只能操作自己的聊天歷史
提供獲取和刪除聊天歷史的接口，方便前端管理

6. 測試和驗證

6.1 啟動服務(wù)

確保 Redis 和 MySQL 服務(wù)已啟動
運行 Spring Boot 應(yīng)用
訪問 http://localhost:9527/api/ai/chat?prompt=你好&chatId=test123 測試 AI 響應(yīng)

6.2 測試聊天記憶功能

發(fā)送第一條消息：http://localhost:9527/api/ai/chat?prompt=你好，我叫張三&chatId=test123
發(fā)送第二條消息：http://localhost:9527/api/ai/chat?prompt=你知道我叫什么名字嗎？&chatId=test123
驗證 AI 能否正確回答你的名字

6.3 測試用戶隔離功能

使用不同用戶登錄
驗證不同用戶的聊天歷史是否相互隔離

6.4 測試歷史記錄持久化

發(fā)送多條消息
重啟服務(wù)
驗證聊天歷史是否仍然存在

6.5 測試歷史記錄管理

獲取用戶的聊天歷史列表：GET http://localhost:9527/api/ai/history/chat
刪除指定聊天歷史：DELETE http://localhost:9527/api/ai/history/chat/test123
驗證聊天歷史是否已刪除

以上就是使用SpringBoot3整合Spring AI實現(xiàn)具有記憶功能的AI助手的詳細內(nèi)容，更多關(guān)于SpringBoot3 Spring AI實現(xiàn)AI助手的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章:

最新国产好看的视频,伊人天堂AV在线,国产Aaaaaa视频,蜜臀视频在线观看一区,人妻av色图,密臀久久久精品影片,青青视频免费观看毛片,久草在线观看视,国产三级精品色情在线

使用SpringBoot3整合Spring AI實現(xiàn)具有記憶功能的AI助手

目錄

1. 項目概述

技術(shù)棧

2. 環(huán)境準備

2.1 安裝必要軟件

2.2 配置環(huán)境變量

3. 項目初始化

3.1 創(chuàng)建 Spring Boot 項目

3.2 配置 Maven 依賴

4. 核心配置

4.1 應(yīng)用配置文件 (application.yml)

4.2 Redis 配置 (RedisConfiguration.java)

5. 核心功能實現(xiàn)

5.1 創(chuàng)建模型類

5.1.1 創(chuàng)建 MessageVO.java

5.1.2 創(chuàng)建 SerializableMessage.java

5.2 定義倉庫接口 (ChatHistoryRepository.java)

5.3 實現(xiàn) Redis 聊天歷史倉庫 (RedisChatHistoryRepository.java)

5.4 實現(xiàn)聊天記憶 (RedisChatMemory.java)

5.5 配置 ChatClient (CommonConfiguration.java)

5.6 實現(xiàn)聊天控制器 (ChatController.java)

5.7 實現(xiàn)聊天歷史控制器 (ChatHistoryController.java)

6. 測試和驗證

6.1 啟動服務(wù)

6.2 測試聊天記憶功能

6.3 測試用戶隔離功能

6.4 測試歷史記錄持久化

6.5 測試歷史記錄管理

相關(guān)文章

最新評論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具