面试官：如何实现大模型连续对话？

所有的大模型本身是不进行信息存储的，也不提供连续对话功能，所以想要实现连续对话功能需要开发者自己写代码才能实现。那怎么才能实现大模型的连续对话功能呢？
大模型连续对话功能不同的框架实现也是不同的，以行业使用最多的 Java AI 框架 Spring AI 和 Spring AI Alibaba 为例，给大家演示一下它们连续对话是如何实现的。
1.SpringAI连续对话实现

Spring AI 以 MySQL 数据库为例，我们来实现一下它的连续对话功能。

PS：我们只有先讲对话存储起来，才能实现连续对话功能，所以我们需要借助数据库存储来连续对话。

1.1 准备工作

1.创建表

1. CREATE TABLE chat_message (
2.   id BIGINT AUTO_INCREMENT PRIMARY KEY,
3.   conversation_id VARCHAR(255) NOT NULL,
4.   role VARCHAR(50) NOT NULL,
5.   context TEXT NOT NULL,
6.   created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
7. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

复制代码

2.添加数据库和 MyBatisPlus 依赖：

1. <dependency>
2.   <groupId>com.baomidou</groupId>
3.   mybatis-plus-spring-boot3-starter</artifactId>
4.   <version>3.5.11</version>
5. </dependency>
7. <dependency>
8.   <groupId>com.mysql</groupId>
9.   mysql-connector-j</artifactId>
10.   <scope>runtime</scope>
11. </dependency>

复制代码

3.设置配置文件：

1. spring:
2.   datasource:
3.     url: jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8
4.     username: root
5.     password: 12345678
6.     driver-class-name: com.mysql.cj.jdbc.Driver
7. # 配置打印 MyBatis 执行的 SQL
8. mybatis-plus:
9.   configuration:
10.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
11. # 配置打印 MyBatis 执行的 SQL
12. logging:
13.   level:
14.     com:
15.       ai:
16.         deepseek: debug

复制代码

4.编写实体类

1. import com.baomidou.mybatisplus.annotation.IdType;
2. import com.baomidou.mybatisplus.annotation.TableId;
3. import com.baomidou.mybatisplus.annotation.TableName;
4. import lombok.Getter;
5. import lombok.Setter;
7. import java.io.Serializable;
8. import java.util.Date;
10. @Getter
11. @Setter
12. @TableName("chat_message")
13. public class ChatMessageDO implements Serializable {
15.     private static final long serialVersionUID = 1L;
17.     @TableId(value = "id", type = IdType.AUTO)
18.     private Long id;
20.     private String conversationId;
22.     private String role;
24.     private String context;
26.     private Date createdAt;
27. }

复制代码

5.编写 Mapper：

1. import com.ai.chat.entity.ChatMessageDO;
2. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
3. import org.apache.ibatis.annotations.Mapper;
5. @Mapper
6. public interface ChatMessageMapper extends BaseMapper<ChatMessageDO> {
7. }

复制代码

1.2 自定义ChatMemory类

自定义的 ChatMemory 实现类，将对话记录存储到 MySQL：

1. import com.ai.deepseek.entity.ChatMessageDO;
2. import com.ai.deepseek.mapper.ChatMessageMapper;
3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
4. import org.springframework.ai.chat.memory.ChatMemory;
5. import org.springframework.ai.chat.messages.Message;
6. import org.springframework.ai.chat.messages.UserMessage;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.stereotype.Component;
10. import java.util.List;
11. import java.util.stream.Collectors;
13. @Component
14. public class MySQLChatMemory implements ChatMemory {
15.     @Autowired
16.     private ChatMessageMapper repository;
18.     @Override
19.     public void add(String conversationId, Message message) {
20.         ChatMessageDO entity = new ChatMessageDO();
21.         entity.setConversationId(conversationId);
22.         entity.setRole(message.getMessageType().name());
23.         entity.setContext(message.getText());
24.         repository.insert(entity);
25.     }
27.     @Override
28.     public void add(String conversationId, List<Message> messages) {
29.         messages.forEach(message -> add(conversationId, message));
30.     }
32.     @Override
33.     public List<Message> get(String conversationId, int lastN) {
34.         LambdaQueryWrapper<ChatMessageDO> queryWrapper = new LambdaQueryWrapper<>();
35.         queryWrapper.eq(ChatMessageDO::getConversationId, conversationId);
36.         // queryWrapper.orderByDesc(ChatMessageDO::getId);
37.         return repository.selectList(queryWrapper)
38.         .stream()
39.         .limit(lastN)
40.         .map(e -> new UserMessage(e.getContext()))
41.         .collect(Collectors.toList());
42.     }
44.     @Override
45.     public void clear(String conversationId) {
46.         LambdaQueryWrapper<ChatMessageDO> queryWrapper = new LambdaQueryWrapper<>();
47.         queryWrapper.eq(ChatMessageDO::getConversationId, conversationId);
48.         repository.delete(queryWrapper);
49.     }
50. }

复制代码

1.3 代码调用

编写代码测试历史对话保存到 MySQL 的功能：

1. import com.ai.deepseek.component.MySQLChatMemory;
2. import org.springframework.ai.chat.client.ChatClient;
3. import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
4. import org.springframework.beans.factory.annotation.Autowired;
5. import org.springframework.web.bind.annotation.RequestMapping;
6. import org.springframework.web.bind.annotation.RequestParam;
7. import org.springframework.web.bind.annotation.RestController;
8. import reactor.core.publisher.Flux;
10. @RestController
11. @RequestMapping("/multi")
12. public class MultiChatController {
14.     @Autowired
15.     private ChatClient chatClient;
16.     @Autowired
17.     private MySQLChatMemory chatMemory;
19.     @RequestMapping("/chat")
20.     public Flux<String> chat(@RequestParam("msg") String msg,
21.                              @RequestParam(defaultValue = "default") String sessionId) {
22.         // 添加MessageChatMemoryAdvisor，自动管理上下文
23.         MessageChatMemoryAdvisor advisor =
24.         new MessageChatMemoryAdvisor(chatMemory, sessionId, 10); // 保留最近5条历史
25.         return chatClient.prompt()
26.         .user(msg)
27.         .advisors(advisor) // 关键：注入记忆管理
28.         .stream()
29.         .content();
30.     }
31. }

复制代码

以上程序执行结果如下：

2.SpringAIAlibaba实现连续对话

Spring AI Alibaba 连续对话的实现就简单很多了，因为它内置了 MySQL 和 Redis 的连续对话存储方式，接下来以 Redis 为例演示 SAA 的连续对话实现，它的实现步骤如下：

• 添加依赖。
  
• 设置配置文件，配置 Redis 连接信息。
  
• 添加 Redis 配置类，注入 RedisChatMemoryRepository 对象。
  
• 配置 ChatClient 实现连续对话。
  

具体实现如下。
2.1 添加依赖

1. <dependency>
2.   <groupId>com.alibaba.cloud.ai</groupId>
3.   spring-ai-alibaba-starter-memory-redis</artifactId>
4. </dependency>

复制代码

2.2 设置配置文件

设置配置文件，配置 Redis 连接信息：

1. spring:
2.   ai:
3.     memory:
4.       redis:
5.         host: localhost
6.         port: 6379
7.         timeout: 5000

复制代码

2.3 添加Redis配置类

添加 Redis 配置类，注入 RedisChatMemoryRepository 对象，实现 Redis 自定义存储器注入：

1. import com.alibaba.cloud.ai.memory.redis.RedisChatMemoryRepository;
2. import org.springframework.beans.factory.annotation.Value;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.Configuration;
6. @Configuration
7. public class RedisMemoryConfig {
9.     @Value("${spring.ai.memory.redis.host}")
10.     private String redisHost;
11.     @Value("${spring.ai.memory.redis.port}")
12.     private int redisPort;
13.     //    @Value("${spring.ai.memory.redis.password}")
14.     //    private String redisPassword;
15.     @Value("${spring.ai.memory.redis.timeout}")
16.     private int redisTimeout;
18.     @Bean
19.     public RedisChatMemoryRepository redisChatMemoryRepository() {
20.         return RedisChatMemoryRepository.builder()
21.         .host(redisHost)
22.         .port(redisPort)
23.         // 若没有设置密码则注释该项
24.         //           .password(redisPassword)
25.         .timeout(redisTimeout)
26.         .build();
27.     }
28. }

复制代码

2.4 配置ChatClient实现连续对话

1. import com.alibaba.cloud.ai.memory.redis.RedisChatMemoryRepository;
2. import org.springframework.ai.chat.client.ChatClient;
3. import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
4. import org.springframework.ai.chat.memory.MessageWindowChatMemory;
5. import org.springframework.ai.chat.model.ChatModel;
6. import org.springframework.web.bind.annotation.GetMapping;
7. import org.springframework.web.bind.annotation.RequestMapping;
8. import org.springframework.web.bind.annotation.RestController;
10. import static org.springframework.ai.chat.memory.ChatMemory.CONVERSATION_ID;
12. @RestController
13. @RequestMapping("/redis")
14. public class RedisMemoryController {
16.     private final ChatClient chatClient;
17.     private final int MAXMESSAGES = 10;
18.     private final MessageWindowChatMemory messageWindowChatMemory;
20.     public RedisMemoryController(ChatModel dashscopeChatModel,
21.                                  RedisChatMemoryRepository redisChatMemoryRepository) {
22.         this.messageWindowChatMemory = MessageWindowChatMemory.builder()
23.         .chatMemoryRepository(redisChatMemoryRepository)
24.         .maxMessages(MAXMESSAGES)
25.         .build();
27.         this.chatClient = ChatClient.builder(dashscopeChatModel)
28.         .defaultAdvisors(
29.             MessageChatMemoryAdvisor.builder(messageWindowChatMemory)
30.             .build()
31.         )
32.         .build();
33.     }
35.     @GetMapping("/call")
36.     public String call(String msg, String cid) {
37.         return chatClient.prompt(msg)
38.         .advisors(
39.             a -> a.param(CONVERSATION_ID, cid)
40.         )
41.         .call().content();
42.     }
43. }

复制代码

小结

通过以上代码大家也可以看出来，使用 Spring AI 实现连续对话是比较复杂的，需要自己实现数据库增删改查的代码，并且重写 ChatMemory 才能实现连续对话功能；而 Spring AI Alibaba 因为内置了连续对话的多种实现（Redis 和其他数据库），所以只需要简单配置就可以实现了。

本文已收录到我的面试小站 www.javacn.site，其中包含的内容有：场景题、SpringAI、SpringAIAlibaba、并发编程、MySQL、Redis、Spring、Spring MVC、Spring Boot、Spring Cloud、MyBatis、JVM、设计模式、消息队列、AI常见面试题等。

   

关注公众号（加好友）：

            
作者：        王磊的博客        
出处：        http://vipstone.cnblogs.com/        
   

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！