首页 > AI教程 >SpringBoot3整合SpringAI实现带记忆的AI助手

SpringBoot3整合SpringAI实现带记忆的AI助手

来源：互联网 2026-07-15 18:43:09
AI资讯合集

基于SpringBoot3与SpringAI整合，利用Redis存储实现具备记忆功能的AI助手，支持用户级会话隔离与30天对话持久化，技术栈包括Java17、MyBatisPlus、MySQL，通过配置消息序列化与仓库接口完成核心功能。

SpringBoot3 整合 SpringAI 实现ai助手（记忆）

最近在做一个智能图片社区项目，用户希望有一个能记住对话上下文的AI助手。经过技术选型，最终敲定了 Spring Boot 3 + Spring AI + Redis 这套方案。下面就把整个实现过程拆开揉碎了讲清楚，从环境准备到核心代码，再到测试验证，一步不落。

1. 项目概述

本教程详细介绍如何使用 Spring Boot 3 整合 Spring AI 实现一个具有记忆功能的 AI 助手。该实现使用 Redis 作为存储介质，支持用户级别的会话隔离和 30 天的对话历史持久化。

长期稳定更新的攒劲资源： >>>点此立即查看<<<

SpringBoot3整合SpringAI实现带记忆的AI助手

技术栈

  • Spring Boot 3.3.0
  • Ja va 17
  • Spring AI
  • Redis 6.0+
  • MyBatis Plus
  • MySQL 8.0
  • Sa-Token（用户认证）

2. 环境准备

2.1 安装必要软件

  • JDK 17+：Oracle JDK 或 OpenJDK
  • Ma ven 3.9+：Ma ven 官网
  • Redis 6.0+：Redis 官网 或使用 Docker
  • MySQL 8.0+：MySQL 官网 或使用 Docker
  • IDE：IntelliJ IDEA 或 Eclipse

2.2 配置环境变量

确保 JA VA_HOME 和 MA VEN_HOME 已正确配置。

3. 项目初始化

3.1 创建 Spring Boot 项目

使用 Spring Initializr 创建项目：

  • 访问 Spring Initializr
  • 选择 Spring Boot 3.3.0
  • 选择 Ja va 17
  • 添加依赖：Spring Web, Spring Data Redis, MyBatis Plus, MySQL Driver, Spring Boot DevTools

3.2 配置 Ma ven 依赖

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


    
    
        org.springframework.boot
        spring-boot-starter-web
    
    
    
        org.springframework.boot
        spring-boot-starter-data-redis
    
    
    
        com.baomidou
        mybatis-plus-boot-starter
        3.5.5
    
    
    
        com.mysql
        mysql-connector-j
        runtime
    
    
    
        org.springframework.ai
        spring-ai-openai
        1.0.0
    
    
    
        cn.dev33
        sa-token-spring-boot-starter
        1.38.1
    
    
    
        com.fasterxml.jackson.core
        jackson-databind
    
    
    
        org.projectlombok
        lombok
        true
    
    
    
        org.springframework.boot
        spring-boot-starter-test
        test

4. 核心配置

4.1 应用配置文件 (application.yml)

创建 src/main/resources/application.yml 文件，配置应用信息：

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
  # 数据库配置
  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.ja va)

创建 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 redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        log.info("开始创建redis模板对象...");
        RedisTemplate redisTemplate = new RedisTemplate<>();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用 StringRedisSerializer 来序列化和反序列化 redis 的 key
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key 采用 String 的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // 使用 Jackson2JsonRedisSerializer 来序列化和反序列化 redis 的 value
        Jackson2JsonRedisSerializer 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. 核心功能实现


5.1 创建模型类


5.1.1 创建 MessageVO.ja va


创建消息视图对象，用于前端展示：


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 对象转换为前端可识别的格式
    • 

  • 根据消息类型设置不同的角色
    • 

  • 提取消息内容用于展示
    • 




5.1.2 创建 SerializableMessage.ja va


创建可序列化的消息对象，用于 Redis 存储：


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

import lombok.Data;
import lombok.NoArgsConstructor;
import ja va.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");
    }
}


功能说明：


    

  • 实现 Serializable 接口，支持 Redis 序列化
    • 

  • 包含角色、内容、消息类型和时间戳字段
    • 

  • 提供多个构造方法，方便使用
    • 




5.2 定义仓库接口 (ChatHistoryRepository.ja va)


创建聊天历史仓库接口：


package com.spc.smartpiccommunitybackend.repository;

import ja va.util.List;
import ja va.util.Map;

public interface ChatHistoryRepository {
    /** 保存会话记录 */
    void sa ve(String type, String chatId, Long userId);
    /** 获取用户的会话ID列表 */
    List getChatIds(Long userId, String type);
    /** 保存聊天消息 */
    void sa veMessage(String chatId, String message, String sender);
    /** 获取聊天消息历史 */
    List getMessages(String chatId);
    /** 删除会话 */
    void deleteChat(Long userId, String type, String chatId);
    /** 获取会话信息 */
    Map getSessionInfo(String chatId);
}



5.3 实现 Redis 聊天历史仓库 (RedisChatHistoryRepository.ja va)


实现基于 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 ja va.util.*;
import ja va.util.concurrent.TimeUnit;
import ja va.util.stream.Collectors;

@Component
@RequiredArgsConstructor
public class RedisChatHistoryRepository implements ChatHistoryRepository {
    private final RedisTemplate redisTemplate;
    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 sa ve(String type, String chatId, Long userId) {
        String sessionKey = CHAT_SESSION_PREFIX + chatId;
        Map 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);
        redisTemplate.expire(sessionKey, 30, TimeUnit.DAYS);
        String historyKey = CHAT_HISTORY_PREFIX + userId + ":" + type;
        redisTemplate.opsForSet().add(historyKey, chatId);
        redisTemplate.expire(historyKey, 30, TimeUnit.DAYS);
    }

    @Override
    public List getChatIds(Long userId, String type) {
        String historyKey = CHAT_HISTORY_PREFIX + userId + ":" + type;
        Set 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 sa veMessage(String chatId, String message, String sender) {
        String messagesKey = CHAT_MESSAGES_PREFIX + chatId;
        Map messageInfo = new HashMap<>();
        messageInfo.put("content", message);
        messageInfo.put("sender", sender);
        messageInfo.put("timestamp", System.currentTimeMillis());
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            String jsonMessage = objectMapper.writeValueAsString(messageInfo);
            redisTemplate.opsForList().rightPush(messagesKey, jsonMessage);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            redisTemplate.opsForList().rightPush(messagesKey, message);
        }
        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 getMessages(String chatId) {
        String messagesKey = CHAT_MESSAGES_PREFIX + chatId;
        List 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 getSessionInfo(String chatId) {
        String sessionKey = CHAT_SESSION_PREFIX + chatId;
        return redisTemplate.opsForHash().entries(sessionKey);
    }
}

这段实现有几个设计要点：


    

  • 使用不同的 Redis key 前缀区分不同类型的数据
    • 

  • 为所有 Redis 键设置过期时间，避免内存泄漏
    • 

  • 处理 JSON 序列化失败的情况，提高系统健壮性
    • 




5.4 实现聊天记忆 (RedisChatMemory.ja va)


实现基于 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 ja va.util.ArrayList;
import ja va.util.List;
import ja va.util.concurrent.TimeUnit;

@Component
public class RedisChatMemory implements ChatMemory {
    private final RedisTemplate redisTemplate;
    private static final String MEMORY_KEY_PREFIX = "chat:memory:";
    private static final long EXPIRATION_DAYS = 30;

    public RedisChatMemory(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void add(String key, List messages) {
        for (Message message : messages) {
            addMessage(key, message);
        }
    }

    @Override
    public List get(String key, int maxCount) {
        List messages = getMessages(key);
        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 getMessages(String chatId) {
        String key = MEMORY_KEY_PREFIX + chatId;
        List objects = redisTemplate.opsForList().range(key, 0, -1);
        List 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);
    }
}

注意：


    

  • 实现 ChatMemory 接口以支持 Spring AI 的消息记忆功能
    • 

  • 为每条消息设置过期时间，确保内存使用合理
    • 

  • 提供批量添加和获取消息的方法，提高性能
    • 




5.5 配置 ChatClient (CommonConfiguration.ja va)


配置 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 用于记录交互日志，方便调试。



5.6 实现聊天控制器 (ChatController.ja va)


实现聊天控制器，处理 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 ja vax.servlet.http.HttpServletRequest;
import ja va.io.IOException;
import ja va.util.ArrayList;
import ja va.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 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.sa ve("chat", chatId, userId);
        List messages = new ArrayList<>();
        SystemMessage systemMessage = new SystemMessage(
            "你是一个智能图片社区的AI助手，名为虹小智。请用友好、专业的语气回答用户问题，" +
            "提供关于图片社区的相关信息和帮助。");
        messages.add(systemMessage);
        List 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.sa veMessage(chatId, prompt, "user");
        return chatClient.stream(messages)
                .doOnNext(response -> {
                    chatHistoryRepository.sa veMessage(chatId, response, "ai");
                });
    }
}


几个值得注意的设计：


    

  • 验证用户登录状态，确保会话隔离
    • 

  • 保存用户消息和 AI 响应到历史记录
    • 

  • 使用 Flux 实现流式响应，提高用户体验
    • 

  • 处理历史消息解析异常，提高系统健壮性
    • 




5.7 实现聊天历史控制器 (ChatHistoryController.ja va)


实现聊天历史控制器，处理聊天历史的获取和删除：


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 ja vax.servlet.http.HttpServletRequest;
import ja va.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;
    }

    @GetMapping("/{type}")
    public List 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;
    }
}


同样，这里验证了用户登录状态，确保只能操作自己的聊天历史。接口设计简洁，方便前端调用。



6. 测试和验证


6.1 启动服务


    

  1. 确保 Redis 和 MySQL 服务已启动
    2. 

  2. 运行 Spring Boot 应用
    3. 

  3. 访问 http://localhost:9527/api/ai/chatprompt=你好&chatId=test123 测试 AI 响应
    4. 




6.2 测试聊天记忆功能


    

  1. 发送第一条消息：http://localhost:9527/api/ai/chatprompt=你好，我叫张三&chatId=test123
    2. 

  2. 发送第二条消息：http://localhost:9527/api/ai/chatprompt=你知道我叫什么名字吗？&chatId=test123
    3. 

  3. 验证 AI 能否正确回答你的名字
    4. 




6.3 测试用户隔离功能


    

  1. 使用不同用户登录
    2. 

  2. 验证不同用户的聊天历史是否相互隔离
    3. 




6.4 测试历史记录持久化


    

  1. 发送多条消息
    2. 

  2. 重启服务
    3. 

  3. 验证聊天历史是否仍然存在
    4. 




6.5 测试历史记录管理


    

  1. 获取用户的聊天历史列表：GET http://localhost:9527/api/ai/history/chat
    2. 

  2. 删除指定聊天历史：DELETE http://localhost:9527/api/ai/history/chat/test123
    3. 

  3. 验证聊天历史是否已删除
    4. 


                
                
                

                    
                    
侠游戏发布此文仅为了传递信息，不代表侠游戏网站认同其观点或证实其描述

                    

                

            

            
            			            
                        

                

                    
                    
同类更新

                    更多
                    

                

                
            

            

                

                    
                    
热游推荐

                    更多
                    

                

                
            

            

                

                    
                    
精彩专题

                    更多
                    

                

                
            

        

        
        
        

  

    

      手游
      专题
      攻略
      App下载
      web3  
      

    

  

  

    

      返回首页
      回到顶部
      

    

  

  

    

      
湘ICP备14008430号-1 湘公网安备 43070302000280号

      
All Rights Reserved 

    

    

      
本站为非盈利网站，不接受任何广告。本站所有软件，都由网友

      
上传，如有侵犯你的版权，请发邮件给xiayx666@163.com

    

    

      
抵制不良色情、反动、暴力游戏。注意自我保护，谨防受骗上当。

      
适度游戏益脑，沉迷游戏伤身。合理安排时间，享受健康生活。