AI 健身教练对话历史模块的实现

库表设计

根据方案设计出对话历史表的结构，为了避免与 AI 库的 ChatMessage 冲突，表名采用 chat_history：

▼
mysql
复制代码
-- 对话历史表
create table if not exists keep_report
(
    id         bigint auto_increment comment 'id' primary key,
    chatId     varchar(255)                       not null comment '对话id',
    userId     bigint                             not null comment '创建用户id',
    messages   text                               not null comment '对话记录（JSON格式存储）',
    lastMessage text                              null comment '最后一条消息内容（用于列表展示）',
    createTime datetime default CURRENT_TIMESTAMP not null comment '创建时间',
    editTime   datetime default CURRENT_TIMESTAMP not null comment '编辑时间',
    updateTime datetime default CURRENT_TIMESTAMP not null on update CURRENT_TIMESTAMP comment '更新时间',
    isDelete   tinyint  default 0                 not null comment '是否删除',
    INDEX idx_user_chat (chatId, userId),  -- 新增索引，优化查询效率
    INDEX idx_user_time (userId, updateTime)  -- 按用户和时间查询的索引
) comment '上下文对话表' collate = utf8mb4_unicode_ci;

使用代码生成器

后端代码生成 - Vibe Coding

参考 Prompt （AI 的随机性真的“一时生成一时爽，改改 Bug 到半夜”，所以 Prompt 尽量写得详细，不然真的改到崩溃！！！）:

▼
markdown
复制代码
系统描述：

现在我的项目里通过实现 Chat⁢Memory 接口自定义 MySQL 的存储‎，使用 MySQL 来保存对话上下文功能，在 messages 字段里记录了对话记录（JSON格式存储）经给JSON工具转换后如下：

```json
[
    {
        "messageType": "USER",
        "message": "我是LMQ，我想通过健身来增肌，请你给我一些健身的建议"
    },
    {
        "messageType": "ASSISTANT",
        "message": "嗨 LMQ，很高兴你选择通过健身来增肌，这是一个很棒的目标！在我们开始前，xxxxxxxxx"
    }
]
```

需求：

现在我想增加上下文对话表的功能来实现历史对话的功能，因为目前 messages 字段里已经存贮了用户对话内容和AI响应内容，那么是不是可以在对话记录中添加一个用户id，当前端点击对话历史后根据用户id和对话id从数据库查找到对应的用户内容和AI响应的内容，如果我说的不能实现历史对话功能，那请你给我想其他可以实现历史对话功能的办法来实现

分析：

1、存储逻辑调整：

保存对话时，需要同时写入`userId`和`chatId`：

- `chatId`：唯一标识一个对话（建议用UUID生成，确保唯一性）。
- 每次用户与AI的新交互（发送消息/接收响应），都需要更新该`chatId`对应的`messages`字段（在JSON数组中追加新消息）。

示例：用户`user123`的一个对话`chat456`，首次交互后`messages`是初始JSON，当用户发送第二条消息后，`messages`会追加新的`USER`和`ASSISTANT`消息：

```json
[
    {"messageType": "USER", "message": "首次消息"},
    {"messageType": "ASSISTANT", "message": "首次响应"},
    {"messageType": "USER", "message": "第二条消息"},
    {"messageType": "ASSISTANT", "message": "第二条响应"}
]
```

2、核心接口设计（实现历史对话功能）：

需要两个关键接口，配合前端实现“历史对话列表展示”和“对话详情加载”：

（1）获取用户的历史对话列表

**用途**：前端展示用户的所有历史对话（类似聊天软件的会话列表）。 
**请求参数**：`userId`（当前用户id）。 
**返回数据**：包含每个对话的基本信息（不需要完整消息，只需缩略信息）：

```json
{
  "code": 200,
  "data": [
    {
      "chatId": "chat456",
      "lastMessage": "第二条响应",  // 对话最后一条消息（用于列表展示）
      "createTime": "2023-10-01 09:00:00",  // 对话创建时间
      "updateTime": "2023-10-01 09:30:00"   // 最后更新时间（用于排序）
    },
    // 更多对话...
  ]
}
```

实现逻辑：  

- 根据`userId`查询`keep_report`表（过滤`isDelete=0`）。  
- 对每个对话，解析`messages`的JSON数组，取最后一条消息作为`lastMessage`（为了效率，可在表中新增`last_message`字段直接存储，避免每次解析JSON）。  

（2）获取单个对话的完整消息

用途：用户点击某个历史对话时，加载该对话的完整聊天记录。 
请求参数：`userId`、`chatId`。 
返回数据：该对话的完整`messages`数组：

```json
{
  "code": 200,
  "data": {
    "chatId": "chat456",
    "messages": [
      {"messageType": "USER", "message": "首次消息"},
      {"messageType": "ASSISTANT", "message": "首次响应"},
      // ... 更多消息
    ]
  }
}
```

实现逻辑：  

- 根据`userId`和`chatId`查询`keep_report`表，返回`messages`字段的JSON内容。  

总结：

核心是通过添加`userId`字段关联用户，再配合两个接口（获取对话列表、获取对话详情），即可实现历史对话功能。现有`messages`字段已存储完整的对话内容（包含用户和 AI 消息），无需修改 JSON 结构，只需确保`chatId`唯一标识一个对话，`userId`正确关联用户即可。

3、优化建议

1. 新增`last_message`字段： 
   为了避免每次查询历史对话列表时都解析`messages` JSON（影响性能），可以在表中新增`last_message`字段，每次更新对话时同步更新该字段（存储最后一条消息内容）。

2. 分页查询： 
   当用户历史对话较多时，“获取历史对话列表”接口需要支持分页（传入`pageNum`、`pageSize`参数）。

3. 删除对话功能： 
   新增“删除历史对话”接口，通过`user_id`和`chatId`将`isDelete`设为1（逻辑删除），前端不再展示已删除的对话。

1）实体类

▼
java
复制代码
/**
 * 健身报告记录表
 * 
 * @TableName keep_report
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "keep_report")
public class KeepReport implements Serializable {
    /**
     * id
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 对话id
     */
    @TableField(value = "chatId")
    private String chatId;

    /**
     * 创建用户id
     */
    @TableField(value = "userId")
    private Long userId;

    /**
     * 对话记录（JSON格式存储）
     */
    @TableField(value = "messages")
    private String messages;

    /**
     * 最后一条消息内容（用于列表展示）
     */
    @TableField(value = "lastMessage")
    private String lastMessage;

    /**
     * 创建时间
     */
    private Date createTime;

    /**
     * 编辑时间
     */
    private Date editTime;

    /**
     * 更新时间
     */
    private Date updateTime;

    /**
     * 是否删除
     */
    private Integer isDelete;

    @TableField(exist = false)
    private static final long serialVersionUID = 1L;
}

2）聊天历史详情 DTO 类

▼
java
复制代码
/**
 * 聊天历史详情DTO
 * 
 * @author MQQQ
 * @create 2025-08-07
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ChatHistoryDetailDTO {

    /**
     * 对话ID
     */
    private String chatId;

    /**
     * 消息列表
     */
    private List<ChatMessageDTO> messages;

    /**
     * 单条消息DTO
     */
    @Data
    @Builder
    @AllArgsConstructor
    @NoArgsConstructor
    public static class ChatMessageDTO {
        
        /**
         * 消息类型：USER/ASSISTANT
         */
        private String messageType;
        
        /**
         * 消息内容
         */
        private String message;
    }
}

3）聊天历史列表 DTO 类

▼
java
复制代码
/**
 * 聊天历史列表DTO
 * 
 * @author MQQQ
 * @create 2025-08-07
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ChatHistoryListDTO {

    /**
     * 对话ID
     */
    private String chatId;

    /**
     * 最后一条消息内容
     */
    private String lastMessage;

    /**
     * 对话创建时间
     */
    private Date createTime;

    /**
     * 最后更新时间
     */
    private Date updateTime;
}

4）聊天历史服务接口

▼
java
复制代码
/**
 * 聊天历史服务接口
 * 
 * @author MQQQ
 * @create 2025-08-07
 */
public interface ChatHistoryService {

    /**
     * 获取用户的历史对话列表
     *
     * @param userId 用户ID
     * @return 历史对话列表
     */
    List<ChatHistoryListDTO> getChatHistoryList(Long userId);

    /**
     * 获取单个对话的完整消息
     *
     * @param userId 用户ID
     * @param chatId 对话ID
     * @return 对话详情
     */
    ChatHistoryDetailDTO getChatHistoryDetail(Long userId, String chatId);

    /**
     * 删除用户的某个对话
     *
     * @param userId 用户ID
     * @param chatId 对话ID
     * @return 是否删除成功
     */
    boolean deleteChatHistory(Long userId, String chatId);
}

5）聊天历史服务实现类

▼
java
复制代码
/**
 * 聊天历史服务实现类
 * 
 * @author MQQQ
 * @create 2025-08-07
 */
@Service
@Slf4j
public class ChatHistoryServiceImpl implements ChatHistoryService {

    @Resource
    private KeepReportMapper keepReportMapper;

    @Override
    public List<ChatHistoryListDTO> getChatHistoryList(Long userId) {
        try {
            // 构建查询条件：根据用户ID查询，按更新时间倒序排列
            LambdaQueryWrapper<KeepReport> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(KeepReport::getUserId, userId)
                        .eq(KeepReport::getIsDelete, 0)
                        .orderByDesc(KeepReport::getUpdateTime);

            // 查询数据库
            List<KeepReport> keepReports = keepReportMapper.selectList(queryWrapper);

            // 转换为DTO
            return keepReports.stream()
                    .map(report -> ChatHistoryListDTO.builder()
                            .chatId(report.getChatId())
                            .lastMessage(report.getLastMessage())
                            .createTime(report.getCreateTime())
                            .updateTime(report.getUpdateTime())
                            .build())
                    .collect(Collectors.toList());

        } catch (Exception e) {
            log.error("获取用户历史对话列表失败，用户ID: {}, 错误: {}", userId, e.getMessage(), e);
            return new ArrayList<>();
        }
    }

    @Override
    public ChatHistoryDetailDTO getChatHistoryDetail(Long userId, String chatId) {
        try {
            // 构建查询条件
            LambdaQueryWrapper<KeepReport> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(KeepReport::getUserId, userId)
                        .eq(KeepReport::getChatId, chatId)
                        .eq(KeepReport::getIsDelete, 0);

            // 查询数据库
            KeepReport keepReport = keepReportMapper.selectOne(queryWrapper);

            if (keepReport == null || keepReport.getMessages() == null || keepReport.getMessages().isBlank()) {
                log.warn("未找到对话记录或消息为空，用户ID: {}, 对话ID: {}", userId, chatId);
                return null;
            }

            // 解析消息JSON
            List<ChatHistoryDetailDTO.ChatMessageDTO> messages = parseMessages(keepReport.getMessages());

            return ChatHistoryDetailDTO.builder()
                    .chatId(chatId)
                    .messages(messages)
                    .build();

        } catch (Exception e) {
            log.error("获取对话详情失败，用户ID: {}, 对话ID: {}, 错误: {}", userId, chatId, e.getMessage(), e);
            return null;
        }
    }

    @Override
    public boolean deleteChatHistory(Long userId, String chatId) {
        try {
            // 构建更新条件：逻辑删除
            LambdaUpdateWrapper<KeepReport> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(KeepReport::getUserId, userId)
                        .eq(KeepReport::getChatId, chatId)
                        .set(KeepReport::getIsDelete, 1);

            // 执行逻辑删除
            int updatedRows = keepReportMapper.update(null, updateWrapper);
            
            if (updatedRows > 0) {
                log.info("成功删除对话记录，用户ID: {}, 对话ID: {}", userId, chatId);
                return true;
            } else {
                log.warn("删除对话记录失败，记录不存在，用户ID: {}, 对话ID: {}", userId, chatId);
                return false;
            }

        } catch (Exception e) {
            log.error("删除对话记录失败，用户ID: {}, 对话ID: {}, 错误: {}", userId, chatId, e.getMessage(), e);
            return false;
        }
    }

    /**
     * 解析消息JSON为DTO列表
     *
     * @param messagesJson 消息JSON字符串
     * @return 消息DTO列表
     */
    private List<ChatHistoryDetailDTO.ChatMessageDTO> parseMessages(String messagesJson) {
        List<ChatHistoryDetailDTO.ChatMessageDTO> messages = new ArrayList<>();
        
        try {
            JSONArray jsonArray = JSON.parseArray(messagesJson);
            
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject = jsonArray.getJSONObject(i);
                String messageType = jsonObject.getString("messageType");
                
                // 处理消息内容
                Object messageObj = jsonObject.get("message");
                String messageContent;
                
                if (messageObj instanceof JSONObject) {
                    // 如果是JSON对象，转换为字符串
                    messageContent = messageObj.toString();
                } else {
                    // 否则直接使用字符串值
                    messageContent = jsonObject.getString("message");
                }
                
                messages.add(ChatHistoryDetailDTO.ChatMessageDTO.builder()
                        .messageType(messageType)
                        .message(messageContent)
                        .build());
            }
            
        } catch (Exception e) {
            log.error("解析消息JSON失败: {}", e.getMessage(), e);
        }
        
        return messages;
    }
}

6）聊天历史接口

▼
java
复制代码
/**
 * 聊天历史接口
 * 
 * @author MQQQ
 * @create 2025-08-07
 */
@RestController
@RequestMapping("/chat/history")
@Slf4j
public class ChatHistoryController {

    @Resource
    private ChatHistoryService chatHistoryService;

    @Resource
    private UserService userService;

    /**
     * 获取用户的历史对话列表
     *
     * @param request HTTP请求对象
     * @return 历史对话列表
     */
    @GetMapping("/list")
    public BaseResponse<List<ChatHistoryListDTO>> getChatHistoryList(HttpServletRequest request) {
        try {
            // 获取当前登录用户
            User currentUser = userService.getLoginUser(request);
            
            // 获取历史对话列表
            List<ChatHistoryListDTO> historyList = chatHistoryService.getChatHistoryList(currentUser.getId());
            
            return ResultUtils.success(historyList);
            
        } catch (BusinessException e) {
            log.warn("获取历史对话列表失败: {}", e.getMessage());
            return ResultUtils.error(e.getCode(), e.getMessage());
        } catch (Exception e) {
            log.error("获取历史对话列表异常: {}", e.getMessage(), e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "系统异常");
        }
    }

    /**
     * 获取单个对话的完整消息
     *
     * @param chatId  对话ID
     * @param request HTTP请求对象
     * @return 对话详情
     */
    @GetMapping("/detail")
    public BaseResponse<ChatHistoryDetailDTO> getChatHistoryDetail(@RequestParam String chatId, 
                                                                   HttpServletRequest request) {
        try {
            // 参数校验
            if (chatId == null || chatId.trim().isEmpty()) {
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "对话ID不能为空");
            }
            
            // 获取当前登录用户
            User currentUser = userService.getLoginUser(request);
            
            // 获取对话详情
            ChatHistoryDetailDTO historyDetail = chatHistoryService.getChatHistoryDetail(currentUser.getId(), chatId);
            
            if (historyDetail == null) {
                return ResultUtils.error(ErrorCode.NOT_FOUND_ERROR, "对话记录不存在");
            }
            
            return ResultUtils.success(historyDetail);
            
        } catch (BusinessException e) {
            log.warn("获取对话详情失败: {}", e.getMessage());
            return ResultUtils.error(e.getCode(), e.getMessage());
        } catch (Exception e) {
            log.error("获取对话详情异常: {}", e.getMessage(), e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "系统异常");
        }
    }

    /**
     * 删除用户的某个对话
     *
     * @param chatId  对话ID
     * @param request HTTP请求对象
     * @return 是否删除成功
     */
    @DeleteMapping("/delete")
    public BaseResponse<Boolean> deleteChatHistory(@RequestParam String chatId, 
                                                   HttpServletRequest request) {
        try {
            // 参数校验
            if (chatId == null || chatId.trim().isEmpty()) {
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "对话ID不能为空");
            }
            
            // 获取当前登录用户
            User currentUser = userService.getLoginUser(request);
            
            // 删除对话
            boolean success = chatHistoryService.deleteChatHistory(currentUser.getId(), chatId);
            
            if (success) {
                return ResultUtils.success(true);
            } else {
                return ResultUtils.error(ErrorCode.OPERATION_ERROR, "删除失败，对话记录不存在");
            }
            
        } catch (BusinessException e) {
            log.warn("删除对话失败: {}", e.getMessage());
            return ResultUtils.error(e.getCode(), e.getMessage());
        } catch (Exception e) {
            log.error("删除对话异常: {}", e.getMessage(), e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "系统异常");
        }
    }
}

7）DatabaseChatMemory 支持用户ID参数

▼
java
复制代码
/**
 * ClassName：DatabaseChatMemory
 * Package:com.mq.mqaiagent.chatmemory
 * Description: 持久化对话到 MySQL
 * Author：MQQQ
 *
 * @Create:2025/6/19 - 18:51
 * @Version:v1.0
 */
@Slf4j
public class DatabaseChatMemory implements ChatMemory {

    private final com.mq.mqaiagent.mapper.KeepReportMapper KeepReportMapper;
    private Long currentUserId; // 当前用户ID

    /**
     * 构造函数，初始化 KeepReportMapper。
     *
     * @param KeepReportMapper 健身报告数据库操作 Mapper
     */
    public DatabaseChatMemory(com.mq.mqaiagent.mapper.KeepReportMapper KeepReportMapper) {
        this.KeepReportMapper = KeepReportMapper;
    }

    /**
     * 设置当前用户ID
     *
     * @param userId 用户ID
     */
    public void setCurrentUserId(Long userId) {
        this.currentUserId = userId;
    }

    /**
     * 向指定对话 ID 的记忆中添加消息列表。
     * 会将新消息追加到现有消息列表末尾，并持久化到数据库。
     *
     * @param conversationId 对话的唯一标识符。
     * @param messages       要添加的消息列表。
     */
    @Override
    public void add(String conversationId, List<Message> messages) {
        if (currentUserId != null) {
            // 如果设置了用户ID，使用支持用户ID的方法
            add(conversationId, currentUserId, messages);
        } else {
            // 获取当前对话的完整历史记录
            List<Message> conversationMessages = getOrCreateConversation(conversationId);
            // 将新消息添加到历史记录末尾
            conversationMessages.addAll(messages);
            // 保存更新后的完整对话历史
            saveConversation(conversationId, conversationMessages);
        }
    }

    /**
     * 向指定对话 ID 的记忆中添加消息列表（支持用户ID）。
     * 会将新消息追加到现有消息列表末尾，并持久化到数据库。
     *
     * @param conversationId 对话的唯一标识符。
     * @param userId         用户ID。
     * @param messages       要添加的消息列表。
     */
    public void add(String conversationId, Long userId, List<Message> messages) {
        // 获取当前对话的完整历史记录
        List<Message> conversationMessages = getOrCreateConversation(conversationId, userId);
        // 将新消息添加到历史记录末尾
        conversationMessages.addAll(messages);
        // 保存更新后的完整对话历史
        saveConversation(conversationId, userId, conversationMessages);
    }

    /**
     * 获取指定对话 ID 的最近 N 条消息。
     * 如果请求的消息数量 N 大于等于实际消息总数，则返回所有消息。
     * 如果对话不存在或为空，则返回空列表。
     *
     * @param conversationId 对话的唯一标识符。
     * @param lastN          要获取的最近消息的数量。
     * @return 包含最近 N 条消息的列表，按时间顺序排列（旧 -> 新）。
     */
    @Override
    public List<Message> get(String conversationId, int lastN) {
        if (currentUserId != null) {
            // 如果设置了用户ID，使用支持用户ID的方法
            return get(conversationId, currentUserId, lastN);
        } else {
            // 获取完整的对话历史
            List<Message> allMessages = getOrCreateConversation(conversationId);
            if (allMessages.isEmpty()) {
                // 对话为空，返回空列表
                return allMessages;
            }
            // 计算需要跳过的消息数量
            int skipCount = Math.max(0, allMessages.size() - lastN);
            return allMessages.stream()
                    // 跳过前面的消息
                    .skip(skipCount)
                    // 返回最后 N 条消息
                    .toList();
        }
    }

    /**
     * 获取指定对话 ID 的最近 N 条消息（支持用户ID）。
     * 如果请求的消息数量 N 大于等于实际消息总数，则返回所有消息。
     * 如果对话不存在或为空，则返回空列表。
     *
     * @param conversationId 对话的唯一标识符。
     * @param userId         用户ID。
     * @param lastN          要获取的最近消息的数量。
     * @return 包含最近 N 条消息的列表，按时间顺序排列（旧 -> 新）。
     */
    public List<Message> get(String conversationId, Long userId, int lastN) {
        // 获取完整的对话历史
        List<Message> allMessages = getOrCreateConversation(conversationId, userId);
        if (allMessages.isEmpty()) {
            // 对话为空，返回空列表
            return allMessages;
        }
        // 计算需要跳过的消息数量
        int skipCount = Math.max(0, allMessages.size() - lastN);
        return allMessages.stream()
                // 跳过前面的消息
                .skip(skipCount)
                // 返回最后 N 条消息
                .toList();
    }

    /**
     * 清除指定对话 ID 的所有记忆（删除对应的数据库记录）。
     *
     * @param conversationId 对话的唯一标识符。
     */
    @Override
    public void clear(String conversationId) {
        try {
            // 构建查询条件
            LambdaQueryWrapper<KeepReport> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(KeepReport::getChatId, getSafeConversationId(conversationId));

            // 删除对应的记录
            int deletedRows = KeepReportMapper.delete(queryWrapper);
            if (deletedRows > 0) {
                log.info("成功清除对话记录: {}", conversationId);
            } else {
                log.warn("尝试清除不存在的对话记录: {}", conversationId);
            }
        } catch (Exception e) {
            log.error("清除对话记录失败: {}", conversationId, e);
        }
    }

    /**
     * 获取或创建指定对话 ID 的消息列表。
     * 如果对应的记录存在，则从中反序列化消息列表；否则，返回一个新的空列表。
     *
     * @param conversationId 对话的唯一标识符。
     * @return 对话的消息列表。如果反序列化失败或记录不存在，则返回空列表。
     */
    private List<Message> getOrCreateConversation(String conversationId) {
        String safeConversationId = getSafeConversationId(conversationId);
        try {
            // 构建查询条件
            LambdaQueryWrapper<KeepReport> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(KeepReport::getChatId, safeConversationId);

            // 查询数据库
            KeepReport loveReport = KeepReportMapper.selectOne(queryWrapper);

            if (loveReport != null && loveReport.getMessages() != null && !loveReport.getMessages().isBlank()) {
                // 从数据库记录中反序列化完整的消息列表
                try {
                    // 解析存储的简化消息格式
                    return deserializeMessages(loveReport.getMessages());
                } catch (Exception e) {
                    log.error("反序列化对话消息失败，对话ID: {}, 错误: {}", safeConversationId, e.getMessage(), e);
                    // 反序列化失败，可能数据已损坏，返回空列表
                    return new ArrayList<>();
                }
            } else {
                log.debug("未找到对话记录或消息为空，对话ID: {}", safeConversationId);
            }
        } catch (Exception e) {
            log.error("获取对话记录失败，对话ID: {}, 错误: {}", safeConversationId, e.getMessage(), e);
        }

        // 如果记录不存在或发生异常，返回新的空列表
        return new ArrayList<>();
    }

    /**
     * 获取或创建指定对话 ID 的消息列表（支持用户ID）。
     * 如果对应的记录存在，则从中反序列化消息列表；否则，返回一个新的空列表。
     *
     * @param conversationId 对话的唯一标识符。
     * @param userId         用户ID。
     * @return 对话的消息列表。如果反序列化失败或记录不存在，则返回空列表。
     */
    private List<Message> getOrCreateConversation(String conversationId, Long userId) {
        String safeConversationId = getSafeConversationId(conversationId);
        try {
            // 构建查询条件
            LambdaQueryWrapper<KeepReport> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(KeepReport::getChatId, safeConversationId)
                    .eq(KeepReport::getUserId, userId);

            // 查询数据库
            KeepReport keepReport = KeepReportMapper.selectOne(queryWrapper);

            if (keepReport != null && keepReport.getMessages() != null && !keepReport.getMessages().isBlank()) {
                // 从数据库记录中反序列化完整的消息列表
                try {
                    // 解析存储的简化消息格式
                    return deserializeMessages(keepReport.getMessages());
                } catch (Exception e) {
                    log.error("反序列化对话消息失败，对话ID: {}, 用户ID: {}, 错误: {}", safeConversationId, userId, e.getMessage(), e);
                    // 反序列化失败，可能数据已损坏，返回空列表
                    return new ArrayList<>();
                }
            } else {
                log.debug("未找到对话记录或消息为空，对话ID: {}, 用户ID: {}", safeConversationId, userId);
            }
        } catch (Exception e) {
            log.error("获取对话记录失败，对话ID: {}, 用户ID: {}, 错误: {}", safeConversationId, userId, e.getMessage(), e);
        }

        // 如果记录不存在或发生异常，返回新的空列表
        return new ArrayList<>();
    }

    /**
     * 将指定对话的完整消息列表序列化并保存到数据库。
     * 会覆盖之前的记录。
     *
     * @param conversationId 对话的唯一标识符。
     * @param messages       要保存的完整消息列表。
     */
    private void saveConversation(String conversationId, List<Message> messages) {
        String safeConversationId = getSafeConversationId(conversationId);
        try {
            // 将消息列表转换为简化的JSON格式
            String messagesJson = serializeMessages(messages);

            // 构建查询条件
            LambdaQueryWrapper<KeepReport> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(KeepReport::getChatId, safeConversationId);

            // 查询数据库中是否已存在该对话的记录
            KeepReport existingReport = KeepReportMapper.selectOne(queryWrapper);

            if (existingReport != null) {
                // 更新现有记录的 messages 字段
                existingReport.setMessages(messagesJson);
                int updatedRows = KeepReportMapper.updateById(existingReport);
                if (updatedRows > 0) {
                    log.debug("成功更新对话记录: {}", safeConversationId);
                } else {
                    log.warn("更新对话记录失败（可能已被删除）: {}", safeConversationId);
                }
            } else {
                // 创建新记录
                KeepReport newReport = KeepReport.builder()
                        .chatId(safeConversationId)
                        .createTime(new Date())
                        .updateTime(new Date())
                        // 存储序列化后的完整消息列表
                        .messages(messagesJson)
                        .build();
                int insertedRows = KeepReportMapper.insert(newReport);
                if (insertedRows > 0) {
                    log.debug("成功插入新对话记录: {}", safeConversationId);
                } else {
                    log.error("插入新对话记录失败: {}", safeConversationId);
                }
            }
        } catch (Exception e) {
            log.error("保存对话记录失败，对话ID: {}, 错误: {}", safeConversationId, e.getMessage(), e);
        }
    }

    /**
     * 将指定对话的完整消息列表序列化并保存到数据库（支持用户ID）。
     * 会覆盖之前的记录。
     *
     * @param conversationId 对话的唯一标识符。
     * @param userId         用户ID。
     * @param messages       要保存的完整消息列表。
     */
    private void saveConversation(String conversationId, Long userId, List<Message> messages) {
        String safeConversationId = getSafeConversationId(conversationId);
        try {
            // 将消息列表转换为简化的JSON格式
            String messagesJson = serializeMessages(messages);

            // 获取最后一条消息内容用于列表展示
            String lastMessage = getLastMessageContent(messages);

            // 构建查询条件
            LambdaQueryWrapper<KeepReport> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(KeepReport::getChatId, safeConversationId)
                    .eq(KeepReport::getUserId, userId);

            // 查询数据库中是否已存在该对话的记录
            KeepReport existingReport = KeepReportMapper.selectOne(queryWrapper);

            if (existingReport != null) {
                // 更新现有记录的 messages 和 lastMessage 字段
                existingReport.setMessages(messagesJson);
                existingReport.setLastMessage(lastMessage);
                int updatedRows = KeepReportMapper.updateById(existingReport);
                if (updatedRows > 0) {
                    log.debug("成功更新对话记录: {}, 用户ID: {}", safeConversationId, userId);
                } else {
                    log.warn("更新对话记录失败（可能已被删除）: {}, 用户ID: {}", safeConversationId, userId);
                }
            } else {
                // 创建新记录
                KeepReport newReport = KeepReport.builder()
                        .chatId(safeConversationId)
                        .userId(userId)
                        .createTime(new Date())
                        .updateTime(new Date())
                        // 存储序列化后的完整消息列表
                        .messages(messagesJson)
                        .lastMessage(lastMessage)
                        .build();
                int insertedRows = KeepReportMapper.insert(newReport);
                if (insertedRows > 0) {
                    log.debug("成功插入新对话记录: {}, 用户ID: {}", safeConversationId, userId);
                } else {
                    log.error("插入新对话记录失败: {}, 用户ID: {}", safeConversationId, userId);
                }
            }
        } catch (Exception e) {
            log.error("保存对话记录失败，对话ID: {}, 用户ID: {}, 错误: {}", safeConversationId, userId, e.getMessage(), e);
        }
    }

    /**
     * 获取最后一条消息的内容用于列表展示
     *
     * @param messages 消息列表
     * @return 最后一条消息的内容，如果为空则返回默认文本
     */
    private String getLastMessageContent(List<Message> messages) {
        if (messages == null || messages.isEmpty()) {
            return "暂无消息";
        }

        Message lastMessage = messages.get(messages.size() - 1);
        String content = lastMessage.getText();

        // 如果内容过长，截取前200个字符
        if (content != null && content.length() > 200) {
            return content.substring(0, 200) + "...";
        }

        return content != null ? content : "暂无消息";
    }

    /**
     * 处理对话 ID，确保其可以安全地用作数据库记录的聊天ID。
     *
     * @param conversationId 原始对话的唯一标识符。
     * @return 处理后的安全对话 ID，例如 "chat_your_conversation_id"。
     */
    private String getSafeConversationId(String conversationId) {
        // 确保 conversationId 不为 null 或空
        if (conversationId == null || conversationId.isBlank()) {
            log.warn("接收到空的 conversationId，将使用默认值 'default_chat'");
            conversationId = "default_chat";
        }

        // 替换掉不安全的字符，保留字母、数字、下划线和连字符
        String sanitizedId = conversationId.replaceAll("[^a-zA-Z0-9\\-_]", "_");

        // 检查是否已经以 "chat_" 开头，如果是则直接返回，避免重复添加前缀
        if (sanitizedId.startsWith("chat_")) {
            return sanitizedId;
        }

        // 添加前缀以避免潜在的冲突或保留字问题
        return "chat_" + sanitizedId;
    }

    /**
     * 将消息列表序列化为简化的JSON格式。
     * 格式为：[
     * {
     * "messageType": "USER",
     * "message": "用户消息内容"
     * },
     * {
     * "messageType": "ASSISTANT",
     * "message": { ... JSON对象 ... }
     * }
     * ]
     *
     * @param messages 要序列化的消息列表
     * @return 序列化后的JSON字符串
     */
    private String serializeMessages(List<Message> messages) {
        JSONArray jsonArray = new JSONArray();

        for (Message message : messages) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("messageType", message.getMessageType().toString());

            if (message instanceof UserMessage) {
                // 用户消息直接存储文本内容
                jsonObject.put("message", message.getText());
            } else if (message instanceof AssistantMessage) {
                // 助手消息可能包含JSON格式的内容，尝试解析
                String content = message.getText();
                try {
                    // 尝试将内容解析为JSON对象
                    JSONObject contentJson = JSON.parseObject(content);
                    jsonObject.put("message", contentJson);
                } catch (Exception e) {
                    // 如果解析失败，则直接存储文本内容
                    jsonObject.put("message", content);
                }
            } else {
                // 其他类型的消息直接存储文本内容
                jsonObject.put("message", message.getText());
            }

            jsonArray.add(jsonObject);
        }

        return jsonArray.toString();
    }

    /**
     * 将简化的JSON格式反序列化为消息列表。
     *
     * @param json 要反序列化的JSON字符串
     * @return 反序列化后的消息列表
     */
    private List<Message> deserializeMessages(String json) {
        List<Message> messages = new ArrayList<>();
        JSONArray jsonArray = JSON.parseArray(json);

        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            String messageTypeStr = jsonObject.getString("messageType");
            MessageType messageType = MessageType.valueOf(messageTypeStr);

            if (messageType == MessageType.USER) {
                // 用户消息
                String content = jsonObject.getString("message");
                messages.add(new UserMessage(content));
            } else if (messageType == MessageType.ASSISTANT) {
                // 助手消息
                Object messageObj = jsonObject.get("message");
                String content;

                if (messageObj instanceof JSONObject) {
                    // 如果是JSON对象，转换为字符串
                    content = messageObj.toString();
                } else {
                    // 否则直接使用字符串值
                    content = jsonObject.getString("message");
                }

                // 创建助手消息，使用空的元数据
                Map<String, Object> metadata = new HashMap<>();
                messages.add(new AssistantMessage(content, metadata));
            } else {
                // 其他类型的消息（暂不支持）
                log.warn("不支持的消息类型: {}", messageType);
            }
        }
        return messages;
    }
}

8）MqManus 添加对话记忆支持

移除 @Component 注解避免构造函数冲突：

▼
java
复制代码
/**
 * ClassName：MqManus
 * Package:com.mq.mqaiagent.agent
 * Description: MqManus 实例
 * Author：MQQQ
 *
 * @Create:2025/7/2 - 16:15
 * @Version:v1.0
 */
public class MqManus extends ToolCallAgent {

        public MqManus(ToolCallback[] allTools, ChatModel dashscopeChatModel) {
                super(allTools);
                this.setName("mqmanus");
                String SYSTEM_PROMPT = """
                                You are MqManus, an all-capable AI assistant, aimed at solving any task presented by the user.
                                You have various tools at your disposal that you can call upon to efficiently complete complex requests.
                                """;
                this.setSystemPrompt(SYSTEM_PROMPT);
                String NEXT_STEP_PROMPT = """
                                Based on user needs, proactively select the most appropriate tool or combination of tools.
                                For complex tasks, you can break down the problem and use different tools step by step to solve it.
                                After using each tool, clearly explain the execution results and suggest the next steps.
                                If you want to stop the interaction at any point, use the `terminate` tool/function call.
                                """;
                this.setNextStepPrompt(NEXT_STEP_PROMPT);
                this.setMaxSteps(20);
                // 初始化客户端
                ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
                                .defaultAdvisors(new MyLoggerAdvisor())
                                .build();
                this.setChatClient(chatClient);
        }

        /**
         * 支持对话记忆和用户ID的构造函数
         *
         * @param allTools           工具数组
         * @param dashscopeChatModel 聊天模型
         * @param chatMemory         对话记忆
         */
        public MqManus(ToolCallback[] allTools, ChatModel dashscopeChatModel, DatabaseChatMemory chatMemory) {
                super(allTools);
                this.setName("mqmanus");
                String SYSTEM_PROMPT = """
                                You are MqManus, an all-capable AI assistant, aimed at solving any task presented by the user.
                                You have various tools at your disposal that you can call upon to efficiently complete complex requests.
                                """;
                this.setSystemPrompt(SYSTEM_PROMPT);
                String NEXT_STEP_PROMPT = """
                                Based on user needs, proactively select the most appropriate tool or combination of tools.
                                For complex tasks, you can break down the problem and use different tools step by step to solve it.
                                After using each tool, clearly explain the execution results and suggest the next steps.
                                If you want to stop the interaction at any point, use the `terminate` tool/function call.
                                """;
                this.setNextStepPrompt(NEXT_STEP_PROMPT);
                this.setMaxSteps(20);
                // 初始化带对话记忆的客户端
                ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
                                .defaultAdvisors(
                                                new MessageChatMemoryAdvisor(chatMemory),
                                                new MyLoggerAdvisor())
                                .build();
                this.setChatClient(chatClient);
        }
}

9）KeepApp 新增支持用户ID的流式对话方法

▼
java
复制代码
		private final ChatModel dashscopeChatModel;
        private final KeepReportMapper keepReportMapper;

		/**
         * KeepApp 使用流式对话（支持用户ID）
         *
         * @param message 用户消息
         * @param chatId  对话ID
         * @param userId  用户ID
         * @return 流式响应
         */
        public Flux<String> doChatByStream(String message, String chatId, Long userId) {
                // 使用支持userId的DatabaseChatMemory
                DatabaseChatMemory chatMemory = new DatabaseChatMemory(keepReportMapper);
                // 设置当前用户ID
                chatMemory.setCurrentUserId(userId);

                ChatClient userChatClient = ChatClient.builder(dashscopeChatModel)
                                .defaultSystem(SYSTEM_PROMPT)
                                .defaultAdvisors(
                                                new MessageChatMemoryAdvisor(chatMemory),
                                                new MyLoggerAdvisor())
                                .build();

                return userChatClient
                                .prompt()
                                .user(message)
                                .advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, chatId)
                                                .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))
                                .stream()
                                .content();
        }

10）API接口扩展

• /ai/keep_app/chat/sse/user: 流式对话(支持用户认证)
• /ai/manus/chat/user: Manus智能体(支持用户认证和对话记忆)

▼
java
复制代码
    @Resource
    private UserService userService;

    @Resource
    private KeepReportMapper keepReportMapper;

    /**
     * KeepApp 使用流式对话（支持用户认证）
     *
     * @param message
     * @param chatId
     * @param request
     * @return
     */
    @GetMapping(value = "/keep_app/chat/sse/user", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> doChatWithKeepAppSSEUser(String message, String chatId, HttpServletRequest request) {
        // 获取当前登录用户
        User currentUser = userService.getLoginUser(request);
        return keepApp.doChatByStream(message, chatId, currentUser.getId());
    }

    /**
     * 流式调用 Manus 超级智能体（支持用户认证和对话记忆）
     *
     * @param message
     * @param chatId
     * @param request
     * @return
     */
    @GetMapping("/manus/chat/user")
    public SseEmitter doChatWithManusUser(String message, String chatId, HttpServletRequest request) {
        // 获取当前登录用户
        User currentUser = userService.getLoginUser(request);

        // 创建支持用户ID的DatabaseChatMemory
        DatabaseChatMemory chatMemory = new DatabaseChatMemory(keepReportMapper);
        chatMemory.setCurrentUserId(currentUser.getId());

        // 创建带对话记忆的MqManus实例
        MqManus mqManus = new MqManus(allTools, dashscopeChatModel, chatMemory);

        return mqManus.runStream(message);
    }

11）commit 信息

▼
markdown
复制代码
feat: 实现用户历史对话功能

✨ 新增功能:
- 添加用户历史对话存储和查询功能
- 支持用户认证的AI对话接口
- 实现对话记录的用户隔离和权限控制

🗄️ 数据库更新:
- keep_report表新增userId和lastMessage字段
- 添加复合索引优化查询性能
- 支持用户级别的对话记录管理

🔧 核心组件修改:
- DatabaseChatMemory: 支持用户ID参数，修复chatId重复前缀问题
- KeepApp: 新增支持用户ID的流式对话方法
- MqManus: 添加对话记忆支持，移除@Component注解避免构造函数冲突

🌐 API接口扩展:
- /ai/keep_app/chat/sse/user: 流式对话(支持用户认证)
- /ai/manus/chat/user: Manus智能体(支持用户认证和对话记忆)
- /chat/history/list: 获取用户历史对话列表
- /chat/history/detail: 获取单个对话详情
- /chat/history/delete: 删除用户对话记录

📦 新增文件:
- ChatHistoryController: 历史对话REST API控制器
- ChatHistoryService: 历史对话业务逻辑接口
- ChatHistoryServiceImpl: 历史对话服务实现
- ChatHistoryListDTO/DetailDTO: 数据传输对象

🐛 问题修复:
- 修复chatId存储时重复添加前缀的问题
- 确保前端传递的chatId与数据库存储格式一致feat: 实现用户历史对话功能

✨ 新增功能:
- 添加用户历史对话存储和查询功能
- 支持用户认证的AI对话接口
- 实现对话记录的用户隔离和权限控制

🗄️ 数据库更新:
- keep_report表新增userId和lastMessage字段
- 添加复合索引优化查询性能
- 支持用户级别的对话记录管理

🔧 核心组件修改:
- DatabaseChatMemory: 支持用户ID参数，修复chatId重复前缀问题
- KeepApp: 新增支持用户ID的流式对话方法
- MqManus: 添加对话记忆支持，移除@Component注解避免构造函数冲突

🌐 API接口扩展:
- /ai/keep_app/chat/sse/user: 流式对话(支持用户认证)
- /ai/manus/chat/user: Manus智能体(支持用户认证和对话记忆)
- /chat/history/list: 获取用户历史对话列表
- /chat/history/detail: 获取单个对话详情
- /chat/history/delete: 删除用户对话记录

📦 新增文件:
- ChatHistoryController: 历史对话REST API控制器
- ChatHistoryService: 历史对话业务逻辑接口
- ChatHistoryServiceImpl: 历史对话服务实现
- ChatHistoryListDTO/DetailDTO: 数据传输对象

🐛 问题修复:
- 修复chatId存储时重复添加前缀的问题
- 确保前端传递的chatId与数据库存储格式一致

前端功能实现 - Vibe Coding

参考 Prompt ：

▼
markdown
复制代码
1、前端交互流程

1. **展示历史对话列表**： 
   前端页面加载时，调用“获取用户的历史对话列表”接口，展示`chatId`、`lastMessage`、`updateTime`等信息（按`updateTime`倒序排列，最新对话在最前）。

2. **加载对话详情**： 
   用户点击某个历史对话时，前端携带`userId`和该对话的`chatId`，调用“获取单个对话的完整消息”接口，解析`messages`数组后，按顺序渲染用户和AI的消息（区分`USER`和`ASSISTANT`角色，用不同样式展示）。

3. **继续对话**： 
   用户在历史对话详情页发送新消息时，前端仍使用该`chatId`，后端将新消息追加到`messages`数组中，实现“续聊”功能。

2、接口调整

AI健身教练调用的后端AI接口改为：/api/ai/keep_app/chat/sse/user

AI超级智能体调用的后端AI接口改为：/api/ai/manus/chat/user

后续主包的 Commit 信息如下，看看 Commit 就知道主包调试时的头大了：

▼
markdown
复制代码
feat: 实现历史对话查看和状态恢复功能

🎉 主要功能实现：
- ✅ 修复页面刷新后无法查看历史对话的问题
- ✅ 实现对话状态恢复，用户返回主页后重新进入可恢复之前对话
- ✅ 解决页面卡住和EventSource连接泄漏问题
- ✅ 优化对话创建流程，避免不必要的新chatId生成

🔧 技术改进：
- 新增ChatManager.vue统一对话管理组件
- 新增LocalStorageService本地存储服务，实现数据持久化
- 修复API调用逻辑，正确处理后端响应数据格式
- 添加组件生命周期管理，防止内存泄漏
- 实现本地缓存降级策略，提升用户体验

🐛 问题修复：
- 修复404 API错误（移除不存在的saveAiMessage调用）
- 修复前端数据格式转换问题（chatId映射为id）
- 修复初始化时自动创建新对话的问题
- 修复SSE连接错误和EventSource资源泄漏
- 修复对话列表获取和显示逻辑

📱 用户体验优化：
- 页面刷新后自动恢复到最后活跃的对话
- 网络异常时使用本地缓存保证功能可用
- 优化欢迎消息显示逻辑
- 改进错误处理和用户反馈
- 添加详细的调试日志便于问题排查

🎯 核心解决方案：
1. 统一对话管理：ChatManager组件统一处理所有对话相关逻辑
2. 数据持久化：LocalStorageService确保数据不丢失
3. API修复：正确调用后端接口并处理响应数据
4. 状态恢复：页面刷新后智能恢复用户对话状态
5. 资源管理：正确清理EventSource连接防止内存泄漏

经过多轮调试和优化，终于实现了完整的历史对话查看功能！

最终历史对话效果

TODO

后端：

1. 实现用户上传头像功能
2. 实现身体数据的存储
3. 实现健身数据的存储

前端：

1. 实现删除用户的某个对话
2. 对话的标题使用用户提问的前6-12个字符
3. 输入框的优化
4. 添加与用户交互的动态效果，提高用户体验
5. 实现健身计划的推荐
6. 实现健身知识的展示