SpringAI 会话记忆实现：基于 MySQL 的持久化存储方案

MessageWindowChatMemory 实现

该实现维护一个固定大小的消息窗口，确保内存中存储的消息总数不超过指定上限。当消息数量超出限制时，会自动移除较旧的非系统消息。特殊处理 SystemMessage，确保系统指令始终有效且不被意外丢弃。

package org.springframework.ai.chat.memory;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.util.Assert;

public final class MessageWindowChatMemory implements ChatMemory {
    private static final int DEFAULT_MAX_MESSAGES = 20;
    private final ChatMemoryRepository chatMemoryRepository;
    private final int maxMessages;

    private MessageWindowChatMemory(ChatMemoryRepository chatMemoryRepository, int maxMessages) {
        Assert.notNull(chatMemoryRepository, "chatMemoryRepository cannot be null");
        Assert.isTrue(maxMessages > 0, "maxMessages must be greater than 0");
        this.chatMemoryRepository = chatMemoryRepository;
        this.maxMessages = maxMessages;
    }

    @Override
    public void add(String conversationId, List<Message> messages) {
        Assert.hasText(conversationId, "conversationId cannot be null or empty");
        Assert.notNull(messages, "messages cannot be null");
        List<Message> memoryMessages = this.chatMemoryRepository.findByConversationId(conversationId);
        List<Message> processedMessages = process(memoryMessages, messages);
        this.chatMemoryRepository.saveAll(conversationId, processedMessages);
    }

    // ... 省略部分辅助方法，实际使用时可参考官方文档
    
    public static Builder builder() {
        return new Builder();
    }

    public static final class Builder {
        private ChatMemoryRepository chatMemoryRepository;
        private int maxMessages = DEFAULT_MAX_MESSAGES;

        public Builder chatMemoryRepository(ChatMemoryRepository chatMemoryRepository) {
            this.chatMemoryRepository = chatMemoryRepository;
            return this;
        }

        public Builder maxMessages(int maxMessages) {
            this.maxMessages = maxMessages;
            return this;
        }

        public MessageWindowChatMemory build() {
            if (this.chatMemoryRepository == null) {
                this.chatMemoryRepository = new InMemoryChatMemoryRepository();
            }
            return new MessageWindowChatMemory(this.chatMemoryRepository, this.maxMessages);
        }
    }
}

ChatMemoryRepository 接口

package org.springframework.ai.chat.memory;
import java.util.List;
import org.springframework.ai.chat.messages.Message;

public interface ChatMemoryRepository {
    List<String> findConversationIds();
    List<Message> findByConversationId(String conversationId);
    void saveAll(String conversationId, List<Message> messages);
    void deleteByConversationId(String conversationId);
}

2. 方式 1：默认内存存储

这是 SpringAI 的默认会话记忆存储方式，无需额外依赖，消息直接存在 JVM 内存中，适合开发、测试场景。

2.1 核心实现

存储载体为 JVM 堆内存，依赖的 Repository 是 InMemoryRepository（SpringAI 内置，无需手动配置）。它使用 ConcurrentHashMap 作为底层存储，提供线程安全的对话历史管理。

2.2 快速上手代码

引入 SpringAI 依赖

在 pom.xml 中添加 SpringAI 核心依赖（以阿里模型为例，其他模型同理）：

<!-- Spring AI Alibaba -->
<dependency>
    <groupId>com.alibaba.cloud.ai</groupId>
    <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
</dependency>

实现一个对话的类，基于内存实现记忆

@Component
@Slf4j
public class LoveApp {
    private final ChatClient chatClient;
    private static final String SYSTEM_PROMPT = "扮演深耕恋爱心理领域的专家。开场向用户表明身份...";

    public LoveApp(ChatModel dashscopeChatModel) {
        // 初始化基于内存的对话记忆
        MessageWindowChatMemory chatMemory = MessageWindowChatMemory.builder()
                .chatMemoryRepository(new InMemoryChatMemoryRepository())
                .maxMessages(20)
                .build();
        chatClient = ChatClient.builder(dashscopeChatModel)
                .defaultSystem(SYSTEM_PROMPT)
                .defaultAdvisors(MessageChatMemoryAdvisor.builder(chatMemory).build())
                .build();
    }

    public String doChat(String message, String chatId) {
        ChatResponse chatResponse = chatClient
                .prompt()
                .user(message)
                .advisors(spec -> spec.param(ChatMemory.CONVERSATION_ID, chatId))
                .call()
                .chatResponse();
        String content = chatResponse.getResult().getOutput().getText();
        log.info("content: {}", content);
        return content;
    }
}

编写测试类

@Test
void testChat() {
    String chatId = UUID.randomUUID().toString();
    // 第一轮
    String message = "你好，我是程序员";
    String answer = loveApp.doChat(message, chatId);
    // 第二轮
    message = "我想让另一半更爱我";
    answer = loveApp.doChat(message, chatId);
    Assertions.assertNotNull(answer);
    // 第三轮：测试记忆是否生效
    message = "我的另一半叫什么来着？刚跟你说过，帮我回忆一下";
    answer = loveApp.doChat(message, chatId);
    Assertions.assertNotNull(answer);
}

运行后控制台会输出 AI 的回复，确认多轮对话上下文已正确传递。

2.3 优缺点

• 优点：零配置，直接用；内存操作速度快，适合开发调试。
• 缺点：服务重启后消息丢失；不支持多实例共享会话（内存是进程隔离的）；消息过多会占用 JVM 内存，存在 OOM 风险。

3. 方式 2：JDBC 持久化存储

将会话消息存储到关系型数据库（MySQL、PostgreSQL 等），适合生产环境（数据持久化、支持多实例共享）。

3.1 核心实现

存储载体为关系型数据库，依赖的 Repository 是 JdbcChatMemoryRepository（SpringAI 提供的 JDBC 实现）。其内部会根据配置的数据库类型自动适配 SQL 脚本。

3.2 快速上手代码

引入依赖

在 pom.xml 中添加 SpringJDBC 和数据库驱动（以 MySQL 为例）：

<!-- MySQL 驱动 -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<!-- Spring JDBC -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- Spring AI JDBC Chat Memory Repository -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-chat-memory-repository-jdbc</artifactId>
</dependency>

创建数据库表

在 MySQL 中创建会话消息表（字段包含会话 ID、消息内容、角色、时间戳）：

-- Spring AI JDBC Chat Memory MySQL 表结构
CREATE TABLE IF NOT EXISTS SPRING_AI_CHAT_MEMORY (
    conversation_id VARCHAR(36) NOT NULL COMMENT '对话 ID',
    content LONGTEXT NOT NULL COMMENT '消息内容',
    type VARCHAR(10) NOT NULL COMMENT '消息类型 (USER/ASSISTANT/SYSTEM/TOOL)',
    timestamp DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    CONSTRAINT chk_type CHECK (type IN ('USER', 'ASSISTANT', 'SYSTEM', 'TOOL'))
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='Spring AI 对话记忆表';

-- 创建索引
CREATE INDEX SPRING_AI_CHAT_MEMORY_CONVERSATION_ID_TIMESTAMP_IDX ON SPRING_AI_CHAT_MEMORY(conversation_id, timestamp DESC);

注意：如果你使用 MySQL 是需要手动执行这个 SQL 的，但是有一部分数据库是不需要手动执行这个 SQL 的，因为这个脚本本身就包含在依赖里了。路径通常在 classpath:org/springframework/ai/chat/memory/repository/jdbc。

当然，如果你要自动创建脚本时也需要在 yml 文件中进行配置：

1. 默认值：embedded（推荐开发测试用）

   spring:
     ai:
       chat:
         memory:
           repository:
             jdbc:
               initialize-schema: embedded
   

2. always（仅临时测试非嵌入式数据库用）

   spring:
     ai:
       chat:
         memory:
           repository:
             jdbc:
               initialize-schema: always
   

3. never（生产环境首选，搭配 Flyway/Liquibase）

   spring:
     ai:
       chat:
         memory:
           repository:
             jdbc:
               initialize-schema: never
   

配置数据源

在 application.yml 中配置数据库连接：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/ai_demo?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

配置 JDBC 会话记忆

创建基于 JDBC 的 MessageWindowChatMemory 的 Bean：

package com.example.config;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.ai.chat.memory.repository.jdbc.JdbcChatMemoryRepository;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@Configuration
public class ChatMemoryConfig {
    private static final int DEFAULT_MAX_MESSAGES = 20;

    @Bean
    public ChatMemory chatMemory(JdbcChatMemoryRepository chatMemoryRepository) {
        log.info("Initializing JDBC-based MessageWindowChatMemory with maxMessages={}", DEFAULT_MAX_MESSAGES);
        return MessageWindowChatMemory.builder()
                .chatMemoryRepository(chatMemoryRepository)
                .maxMessages(DEFAULT_MAX_MESSAGES)
                .build();
    }
}

在对话中使用

和内存存储的使用方式完全一致（依赖注入 ChatMemory 即可）：

package com.example.app;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class LoveApp {
    private final ChatClient chatClient;

    public LoveApp(ChatModel dashscopeChatModel, ChatMemory chatMemory) {
        chatClient = ChatClient.builder(dashscopeChatModel)
                .defaultAdvisors(MessageChatMemoryAdvisor.builder(chatMemory).build())
                .build();
    }

    public String doChat(String message, String chatId) {
        ChatResponse response = chatClient
                .prompt()
                .user(message)
                .advisors(spec -> spec.param(ChatMemory.CONVERSATION_ID, chatId))
                .call()
                .chatResponse();
        String content = response.getResult().getOutput().getText();
        log.info("content: {}", content);
        return content;
    }
}

运行后查询数据库表 SPRING_AI_CHAT_MEMORY，可以看到消息记录已持久化保存。

3.3 优缺点

• 优点：数据持久化，服务重启/扩容后消息不丢失；支持多实例共享会话（所有实例连同一个数据库）；可通过数据库做消息的持久化分析。
• 缺点：需要配置数据库，复杂度高于内存存储；数据库 IO 速度比内存慢（可通过连接池优化）。

4. 两种方式对比与选型建议

选型建议：

• 开发/测试阶段：用内存存储，快速验证功能；
• 生产环境：用JDBC 存储，保证会话数据的可靠性和共享性；
• 高并发场景：可结合 Redis 缓存（SpringAI 也支持 Redis 存储），进一步提升性能。

5. 总结

SpringAI 的会话记忆通过'接口分层 + 多实现'的设计，让开发者可以灵活切换存储方式：

• 基础层：ChatMemory 定义会话行为；
• 实现层：MessageWindowChatMemory 管理消息窗口；
• 存储层：ChatMemoryRepository 的不同实现（内存/JDBC）决定数据的存储位置。

根据业务需求选择合适的存储策略，能让你的 AI 应用更加稳健可靠。