基于Spring AI和Claude构建企业智能客服系统：从架构到实践的完整指南

个人名片

🎓作者简介：java领域优质创作者
🌐个人主页：码农阿豪
📞工作室：新空间代码工作室（提供各种软件服务)
💌个人邮箱：[[email protected]]
📱个人微信：15279484656
🌐个人导航网站：www.forff.top
💡座右铭：总有人要赢。为什么不能是我呢？

• 专栏导航：

码农阿豪系列专栏导航
面试专栏：收集了java相关高频面试题，面试实战总结🍻🎉🖥️
Spring5系列专栏：整理了Spring5重要知识点与实战演练，有案例可直接使用🚀🔧💻
Redis专栏：Redis从零到一学习分享，经验总结，案例实战💐📝💡
全栈系列专栏：海纳百川有容乃大，可能你想要的东西里面都有🤸🌱🚀

目录

• 基于Spring AI和Claude构建企业智能客服系统：从架构到实践的完整指南
  • 为什么选择Spring AI + Claude的技术组合？
    • Spring AI：企业级AI应用的理想选择
    • Claude：强大的对话AI能力
  • 系统架构设计
    • 整体架构概览
    • 核心组件说明
  • 项目搭建与依赖配置
    • Maven依赖配置
    • 应用配置
  • 核心业务实现
    • 1. 智能客服服务类
    • 2. 知识库管理服务
    • 3. REST API控制器
  • 系统优化与最佳实践
    • 1. 性能优化策略
    • 2. 安全考虑
    • 3. 监控和运维
  • 部署与运维
    • Docker容器化
    • Docker Compose配置
    • Kubernetes部署配置
  • 测试策略
    • 单元测试示例
    • 集成测试
  • 性能调优与扩展
    • 1. 缓存优化
    • 2. 异步处理优化
    • 3. 流式响应实现
  • 总结与展望
    • 技术优势
    • 业务价值
    • 未来发展方向

基于Spring AI和Claude构建企业智能客服系统：从架构到实践的完整指南

随着人工智能技术的快速发展，越来越多的企业开始构建内部智能客服系统来提升客户服务效率和质量。本文将详细介绍如何使用Spring AI框架结合Claude大语言模型，构建一个功能完善的企业级智能客服系统。

为什么选择Spring AI + Claude的技术组合？

Spring AI：企业级AI应用的理想选择

Spring AI是Spring生态系统中专门为AI应用开发设计的框架，它具有以下核心优势：

1. 天然的Spring生态集成

• 与Spring Boot、Spring Security等框架无缝集成
• 遵循Spring的依赖注入和自动配置机制
• 统一的配置管理和监控体系

2. 简化的AI开发体验

• 提供统一的API抽象，屏蔽底层复杂性
• 开箱即用的RAG（检索增强生成）支持
• 内置的向量数据库集成和文档处理能力

3. 企业级特性

• 完整的可观测性和监控支持
• 生产级的错误处理和重试机制
• 丰富的配置选项和扩展点

Claude：强大的对话AI能力

Claude作为Anthropic开发的大语言模型，在企业应用场景中表现出色：

• 高质量的中文理解和生成能力
• 良好的上下文理解和多轮对话支持
• 可靠的安全性和合规性保障
• 灵活的API调用方式

系统架构设计

整体架构概览

我们的智能客服系统采用分层架构设计，主要包含以下组件：

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ 前端界面 │────│ Spring Boot │────│ Claude API │ │ (Web/Mobile) │ │ 应用服务 │ │ │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ ┌─────────────────┐ │ 知识库系统 │ │ (Vector Store) │ └─────────────────┘ 

核心组件说明

1. 对话管理引擎

• 处理用户输入和多轮对话
• 管理会话上下文和历史记录
• 实现智能路由和意图识别

2. 知识检索系统

• 基于向量相似度的语义搜索
• 支持多种文档格式的知识导入
• 动态知识更新和版本控制

3. Claude集成层

• 封装Claude API调用
• 实现Prompt工程和上下文构建
• 处理流式响应和错误重试

项目搭建与依赖配置

Maven依赖配置

首先，让我们配置项目的基础依赖：

<?xml version="1.0" encoding="UTF-8"?><projectxmlns="http://maven.apache.org/POM/4.0.0"><modelVersion>4.0.0</modelVersion><groupId>com.company</groupId><artifactId>intelligent-customer-service</artifactId><version>1.0.0</version><packaging>jar</packaging><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.0</version><relativePath/></parent><dependencies><!-- Spring Boot核心依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-security</artifactId></dependency><!-- Spring AI相关依赖 --><dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-anthropic-spring-boot-starter</artifactId><version>1.0.0-M1</version></dependency><dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId><version>1.0.0-M1</version></dependency><dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-pdf-document-reader</artifactId><version>1.0.0-M1</version></dependency><!-- 数据库相关 --><dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId></dependency><!-- 其他工具库 --><dependency><groupId>org.apache.commons</groupId><artifactId>commons-lang3</artifactId></dependency></dependencies></project>

应用配置

在application.yml中配置相关参数：

spring:application:name: intelligent-customer-service # 数据库配置datasource:url: jdbc:postgresql://localhost:5432/customer_service username: ${DB_USERNAME:postgres}password: ${DB_PASSWORD:password}driver-class-name: org.postgresql.Driver # JPA配置jpa:hibernate:ddl-auto: update show-sql:falseproperties:hibernate:dialect: org.hibernate.dialect.PostgreSQLDialect # Spring AI配置ai:anthropic:api-key: ${ANTHROPIC_API_KEY}chat:options:model: claude-sonnet-4-20250514temperature:0.3max-tokens:2000vectorstore:pgvector:index-type: HNSW distance-type: COSINE_DISTANCE dimensions:1536# 应用自定义配置app:knowledge-base:max-file-size: 10MB supported-formats: pdf,docx,txt,md chat:max-history-size:20session-timeout: 30m logging:level:org.springframework.ai: DEBUG com.company.customerservice: DEBUG 

核心业务实现

1. 智能客服服务类

@Service@Slf4jpublicclassIntelligentCustomerService{privatefinalAnthropicChatModel chatModel;privatefinalVectorStore vectorStore;privatefinalChatMemory chatMemory;privatefinalConversationService conversationService;publicIntelligentCustomerService(AnthropicChatModel chatModel,VectorStore vectorStore,ChatMemory chatMemory,ConversationService conversationService){this.chatModel = chatModel;this.vectorStore = vectorStore;this.chatMemory = chatMemory;this.conversationService = conversationService;}/** * 处理用户问题的核心方法 */publicChatResponsehandleUserQuery(ChatRequest request){try{String userId = request.getUserId();String question = request.getMessage(); log.info("处理用户 {} 的问题: {}", userId, question);// 1. 从知识库检索相关信息List<Document> relevantDocs =retrieveRelevantKnowledge(question);// 2. 构建系统提示词String systemPrompt =buildSystemPrompt(relevantDocs, request.getUserContext());// 3. 获取对话历史List<Message> conversationHistory = chatMemory.get(userId,10);// 4. 构建完整的消息列表List<Message> messages =buildMessageList(systemPrompt, conversationHistory, question);// 5. 调用Claude获取回答Prompt prompt =newPrompt(messages,buildChatOptions());org.springframework.ai.chat.model.ChatResponse aiResponse = chatModel.call(prompt);// 6. 处理和保存结果String answer = aiResponse.getResult().getOutput().getContent();saveConversationHistory(userId, question, answer);// 7. 构建返回结果returnChatResponse.builder().message(answer).conversationId(request.getConversationId()).timestamp(LocalDateTime.now()).sources(extractSources(relevantDocs)).build();}catch(Exception e){ log.error("处理用户问题时发生错误", e);returnChatResponse.builder().message("抱歉，我暂时无法回答您的问题，请稍后重试。").error(true).build();}}/** * 从知识库检索相关文档 */privateList<Document>retrieveRelevantKnowledge(String question){SearchRequest searchRequest =SearchRequest.query(question).withTopK(5).withSimilarityThreshold(0.7);return vectorStore.similaritySearch(searchRequest);}/** * 构建系统提示词 */privateStringbuildSystemPrompt(List<Document> relevantDocs,UserContext userContext){StringBuilder contextBuilder =newStringBuilder(); contextBuilder.append("你是一个专业的企业内部客服助手。请基于以下知识库信息回答用户问题：\n\n");// 添加检索到的知识for(int i =0; i < relevantDocs.size(); i++){Document doc = relevantDocs.get(i); contextBuilder.append(String.format("知识片段 %d:\n%s\n\n", i +1, doc.getContent()));}// 添加用户上下文信息if(userContext !=null){ contextBuilder.append(String.format("用户信息：部门=%s，角色=%s\n\n", userContext.getDepartment(), userContext.getRole()));} contextBuilder.append("回答要求：\n"); contextBuilder.append("1. 基于提供的知识库信息回答，如果信息不足请说明\n"); contextBuilder.append("2. 回答要准确、简洁、友好\n"); contextBuilder.append("3. 如果涉及敏感信息，请提醒用户通过正式渠道处理\n"); contextBuilder.append("4. 使用中文回答\n");return contextBuilder.toString();}/** * 构建消息列表 */privateList<Message>buildMessageList(String systemPrompt,List<Message> history,String currentQuestion){List<Message> messages =newArrayList<>();// 添加系统消息 messages.add(newSystemMessage(systemPrompt));// 添加历史对话 messages.addAll(history);// 添加当前问题 messages.add(newUserMessage(currentQuestion));return messages;}/** * 构建Chat选项 */privateAnthropicChatOptionsbuildChatOptions(){returnAnthropicChatOptions.builder().withModel("claude-sonnet-4-20250514").withTemperature(0.3).withMaxTokens(2000).build();}/** * 保存对话历史 */privatevoidsaveConversationHistory(String userId,String question,String answer){// 保存到内存中的对话历史 chatMemory.add(userId,newUserMessage(question)); chatMemory.add(userId,newAssistantMessage(answer));// 保存到数据库（用于分析和审计） conversationService.saveConversation(userId, question, answer);}/** * 提取知识来源 */privateList<String>extractSources(List<Document> documents){return documents.stream().map(doc -> doc.getMetadata().get("source")).filter(Objects::nonNull).map(Object::toString).distinct().collect(Collectors.toList());}}

2. 知识库管理服务

@Service@Slf4jpublicclassKnowledgeBaseService{privatefinalVectorStore vectorStore;privatefinalKnowledgeDocumentRepository documentRepository;privatefinalTextSplitter textSplitter;@Value("${app.knowledge-base.max-file-size:10MB}")privateString maxFileSize;publicKnowledgeBaseService(VectorStore vectorStore,KnowledgeDocumentRepository documentRepository){this.vectorStore = vectorStore;this.documentRepository = documentRepository;this.textSplitter =newTokenTextSplitter(500,50);}/** * 添加文档到知识库 */@TransactionalpublicvoidaddDocument(MultipartFile file,String category,String uploadedBy){try{// 1. 验证文件validateFile(file);// 2. 读取文档内容List<Document> documents =readDocument(file);// 3. 文档分块List<Document> chunks =splitDocuments(documents);// 4. 添加元数据enrichDocuments(chunks, file.getOriginalFilename(), category, uploadedBy);// 5. 向量化并存储 vectorStore.add(chunks);// 6. 保存文档记录saveDocumentRecord(file, category, uploadedBy, chunks.size()); log.info("成功添加文档到知识库: {}, 分块数: {}", file.getOriginalFilename(), chunks.size());}catch(Exception e){ log.error("添加文档到知识库失败: {}", file.getOriginalFilename(), e);thrownewKnowledgeBaseException("文档处理失败: "+ e.getMessage());}}/** * 读取文档内容 */privateList<Document>readDocument(MultipartFile file)throwsIOException{String filename = file.getOriginalFilename();String extension =getFileExtension(filename);DocumentReader reader =switch(extension.toLowerCase()){case"pdf"->newPagePdfDocumentReader(file.getResource());case"docx"->newTikaDocumentReader(file.getResource());case"txt","md"->newTextDocumentReader(file.getResource());default->thrownewUnsupportedOperationException("不支持的文件格式: "+ extension);};return reader.get();}/** * 文档分块 */privateList<Document>splitDocuments(List<Document> documents){List<Document> allChunks =newArrayList<>();for(Document document : documents){List<Document> chunks = textSplitter.split(document); allChunks.addAll(chunks);}return allChunks;}/** * 丰富文档元数据 */privatevoidenrichDocuments(List<Document> chunks,String filename,String category,String uploadedBy){for(int i =0; i < chunks.size(); i++){Document chunk = chunks.get(i);Map<String,Object> metadata = chunk.getMetadata(); metadata.put("source", filename); metadata.put("category", category); metadata.put("uploadedBy", uploadedBy); metadata.put("chunkIndex", i); metadata.put("totalChunks", chunks.size()); metadata.put("uploadTime",LocalDateTime.now().toString());}}/** * 搜索知识库 */publicList<KnowledgeSearchResult>searchKnowledge(String query,int limit){SearchRequest searchRequest =SearchRequest.query(query).withTopK(limit).withSimilarityThreshold(0.6);List<Document> results = vectorStore.similaritySearch(searchRequest);return results.stream().map(this::convertToSearchResult).collect(Collectors.toList());}/** * 删除文档 */@TransactionalpublicvoiddeleteDocument(Long documentId){KnowledgeDocument document = documentRepository.findById(documentId).orElseThrow(()->newEntityNotFoundException("文档不存在"));// 从向量数据库删除 vectorStore.delete(List.of(document.getFilename()));// 从数据库删除记录 documentRepository.delete(document); log.info("成功删除文档: {}", document.getFilename());}/** * 获取知识库统计信息 */publicKnowledgeBaseStatsgetStatistics(){long totalDocuments = documentRepository.count();long totalChunks = vectorStore.similaritySearch(SearchRequest.query("").withTopK(Integer.MAX_VALUE)).size();Map<String,Long> categoryStats = documentRepository.findCategoryStatistics();returnKnowledgeBaseStats.builder().totalDocuments(totalDocuments).totalChunks(totalChunks).categoryStatistics(categoryStats).lastUpdated(LocalDateTime.now()).build();}// 辅助方法privatevoidvalidateFile(MultipartFile file){if(file.isEmpty()){thrownewIllegalArgumentException("文件不能为空");}String filename = file.getOriginalFilename();if(filename ==null|| filename.trim().isEmpty()){thrownewIllegalArgumentException("文件名不能为空");}// 验证文件大小和格式// ... 具体验证逻辑}privateStringgetFileExtension(String filename){if(filename ==null||!filename.contains(".")){return"";}return filename.substring(filename.lastIndexOf(".")+1);}privatevoidsaveDocumentRecord(MultipartFile file,String category,String uploadedBy,int chunkCount){KnowledgeDocument document =KnowledgeDocument.builder().filename(file.getOriginalFilename()).fileSize(file.getSize()).category(category).uploadedBy(uploadedBy).chunkCount(chunkCount).uploadTime(LocalDateTime.now()).build(); documentRepository.save(document);}privateKnowledgeSearchResultconvertToSearchResult(Document document){returnKnowledgeSearchResult.builder().content(document.getContent()).source(document.getMetadata().get("source").toString()).category(document.getMetadata().get("category").toString()).relevanceScore(0.0)// 实际项目中需要计算相似度分数.build();}}

3. REST API控制器

@RestController@RequestMapping("/api/chat")@Slf4j@ValidatedpublicclassChatController{privatefinalIntelligentCustomerService customerService;privatefinalKnowledgeBaseService knowledgeBaseService;publicChatController(IntelligentCustomerService customerService,KnowledgeBaseService knowledgeBaseService){this.customerService = customerService;this.knowledgeBaseService = knowledgeBaseService;}/** * 处理聊天消息 */@PostMapping("/message")publicResponseEntity<ApiResponse<ChatResponse>>sendMessage(@Valid@RequestBodyChatRequest request,HttpServletRequest httpRequest){try{// 从请求中获取用户信息String userId =getUserIdFromRequest(httpRequest); request.setUserId(userId);// 处理用户问题ChatResponse response = customerService.handleUserQuery(request);returnResponseEntity.ok(ApiResponse.success(response));}catch(Exception e){ log.error("处理聊天消息失败", e);returnResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ApiResponse.error("服务暂时不可用，请稍后重试"));}}/** * 获取对话历史 */@GetMapping("/history/{conversationId}")publicResponseEntity<ApiResponse<List<ConversationHistory>>>getConversationHistory(@PathVariableString conversationId,@RequestParam(defaultValue ="0")int page,@RequestParam(defaultValue ="50")int size){try{List<ConversationHistory> history = customerService.getConversationHistory( conversationId, page, size);returnResponseEntity.ok(ApiResponse.success(history));}catch(Exception e){ log.error("获取对话历史失败", e);returnResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ApiResponse.error("获取对话历史失败"));}}/** * 清除对话历史 */@DeleteMapping("/history/{conversationId}")publicResponseEntity<ApiResponse<Void>>clearConversationHistory(@PathVariableString conversationId){try{ customerService.clearConversationHistory(conversationId);returnResponseEntity.ok(ApiResponse.success(null));}catch(Exception e){ log.error("清除对话历史失败", e);returnResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ApiResponse.error("清除对话历史失败"));}}privateStringgetUserIdFromRequest(HttpServletRequest request){// 从JWT token或session中获取用户ID// 这里简化处理，实际项目中需要根据认证方案实现return request.getHeader("X-User-ID");}}/** * 知识库管理API */@RestController@RequestMapping("/api/knowledge")@Slf4jpublicclassKnowledgeController{privatefinalKnowledgeBaseService knowledgeBaseService;publicKnowledgeController(KnowledgeBaseService knowledgeBaseService){this.knowledgeBaseService = knowledgeBaseService;}/** * 上传文档到知识库 */@PostMapping("/upload")publicResponseEntity<ApiResponse<String>>uploadDocument(@RequestParam("file")MultipartFile file,@RequestParam("category")String category,HttpServletRequest request){try{String uploadedBy =getUserIdFromRequest(request); knowledgeBaseService.addDocument(file, category, uploadedBy);returnResponseEntity.ok(ApiResponse.success("文档上传成功"));}catch(Exception e){ log.error("上传文档失败", e);returnResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ApiResponse.error("文档上传失败: "+ e.getMessage()));}}/** * 搜索知识库 */@GetMapping("/search")publicResponseEntity<ApiResponse<List<KnowledgeSearchResult>>>searchKnowledge(@RequestParamString query,@RequestParam(defaultValue ="10")int limit){try{List<KnowledgeSearchResult> results = knowledgeBaseService.searchKnowledge(query, limit);returnResponseEntity.ok(ApiResponse.success(results));}catch(Exception e){ log.error("搜索知识库失败", e);returnResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ApiResponse.error("搜索失败"));}}/** * 获取知识库统计信息 */@GetMapping("/stats")publicResponseEntity<ApiResponse<KnowledgeBaseStats>>getStatistics(){try{KnowledgeBaseStats stats = knowledgeBaseService.getStatistics();returnResponseEntity.ok(ApiResponse.success(stats));}catch(Exception e){ log.error("获取统计信息失败", e);returnResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ApiResponse.error("获取统计信息失败"));}}privateStringgetUserIdFromRequest(HttpServletRequest request){return request.getHeader("X-User-ID");}}

系统优化与最佳实践

1. 性能优化策略

缓存机制

• 对频繁查询的知识片段进行缓存
• 使用Redis缓存用户会话和对话历史
• 实现智能的缓存失效策略

异步处理

• 文档上传和处理使用异步队列
• 长时间的AI推理任务异步执行
• 实现流式响应提升用户体验

资源优化

• 合理配置数据库连接池
• 优化向量检索的参数设置
• 实现请求限流和熔断保护

2. 安全考虑

数据安全

• 所有敏感配置使用环境变量管理
• 实现完整的用户认证和授权机制
• 对上传文档进行安全扫描

API安全

• 实现请求签名验证
• 添加频率限制和防爬虫机制
• 记录详细的审计日志

3. 监控和运维

应用监控

@ComponentpublicclassChatServiceMetrics{privatefinalMeterRegistry meterRegistry;privatefinalCounter chatRequestCounter;privatefinalTimer responseTimeTimer;publicChatServiceMetrics(MeterRegistry meterRegistry){this.meterRegistry = meterRegistry;this.chatRequestCounter =Counter.builder("chat.requests.total").description("Total number of chat requests").register(meterRegistry);this.responseTimeTimer =Timer.builder("chat.response.time").description("Chat response time").register(meterRegistry);}publicvoidrecordChatRequest(){ chatRequestCounter.increment();}publicTimer.SamplestartTimer(){returnTimer.start(meterRegistry);}}

健康检查

@ComponentpublicclassChatServiceHealthIndicatorimplementsHealthIndicator{privatefinalAnthropicChatModel chatModel;privatefinalVectorStore vectorStore;@OverridepublicHealthhealth(){try{// 检查Claude API连接checkClaudeConnection();// 检查向量数据库连接checkVectorStoreConnection();returnHealth.up().withDetail("claude","Available").withDetail("vectorStore","Available").build();}catch(Exception e){returnHealth.down().withDetail("error", e.getMessage()).build();}}privatevoidcheckClaudeConnection(){// 简单的健康检查请求 chatModel.call(newPrompt("Hello"));}privatevoidcheckVectorStoreConnection(){// 检查向量数据库连接 vectorStore.similaritySearch(SearchRequest.query("test").withTopK(1));}}

部署与运维

Docker容器化

FROM openjdk:17-jdk-slim COPY target/intelligent-customer-service-1.0.0.jar app.jar EXPOSE 8080 ENTRYPOINT ["java", "-jar", "/app.jar"] 

Docker Compose配置

version:'3.8'services:app:build: . ports:-"8080:8080"environment:- ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}- DB_USERNAME=postgres - DB_PASSWORD=password depends_on:- postgres - redis postgres:image: pgvector/pgvector:pg16 environment:- POSTGRES_DB=customer_service - POSTGRES_USER=postgres - POSTGRES_PASSWORD=password ports:-"5432:5432"volumes:- postgres_data:/var/lib/postgresql/data redis:image: redis:7-alpine ports:-"6379:6379"volumes:- redis_data:/data volumes:postgres_data:redis_data:

Kubernetes部署配置

apiVersion: apps/v1 kind: Deployment metadata:name: intelligent-customer-service labels:app: customer-service spec:replicas:3selector:matchLabels:app: customer-service template:metadata:labels:app: customer-service spec:containers:-name: customer-service image: company/intelligent-customer-service:1.0.0 ports:-containerPort:8080env:-name: ANTHROPIC_API_KEY valueFrom:secretKeyRef:name: api-secrets key: anthropic-api-key -name: DB_USERNAME valueFrom:configMapKeyRef:name: app-config key: db-username -name: DB_PASSWORD valueFrom:secretKeyRef:name: db-secrets key: password resources:requests:memory:"1Gi"cpu:"500m"limits:memory:"2Gi"cpu:"1000m"livenessProbe:httpGet:path: /actuator/health port:8080initialDelaySeconds:60periodSeconds:30readinessProbe:httpGet:path: /actuator/health/readiness port:8080initialDelaySeconds:30periodSeconds:10---apiVersion: v1 kind: Service metadata:name: customer-service-service spec:selector:app: customer-service ports:-protocol: TCP port:80targetPort:8080type: ClusterIP 

测试策略

单元测试示例

@ExtendWith(MockitoExtension.class)classIntelligentCustomerServiceTest{@MockprivateAnthropicChatModel chatModel;@MockprivateVectorStore vectorStore;@MockprivateChatMemory chatMemory;@MockprivateConversationService conversationService;@InjectMocksprivateIntelligentCustomerService customerService;@TestvoidshouldHandleUserQuerySuccessfully(){// GivenChatRequest request =ChatRequest.builder().userId("user123").message("如何申请年假？").conversationId("conv456").build();List<Document> mockDocs =Arrays.asList(newDocument("年假申请需要提前2周提交申请表..."));when(vectorStore.similaritySearch(any(SearchRequest.class))).thenReturn(mockDocs);when(chatMemory.get(eq("user123"),eq(10))).thenReturn(Arrays.asList());org.springframework.ai.chat.model.ChatResponse mockResponse =neworg.springframework.ai.chat.model.ChatResponse(Arrays.asList(newGeneration(newAssistantMessage("根据公司政策，年假申请需要..."))));when(chatModel.call(any(Prompt.class))).thenReturn(mockResponse);// WhenChatResponse response = customerService.handleUserQuery(request);// ThenassertThat(response).isNotNull();assertThat(response.getMessage()).contains("年假申请");assertThat(response.isError()).isFalse();verify(vectorStore).similaritySearch(any(SearchRequest.class));verify(chatModel).call(any(Prompt.class));verify(chatMemory,times(2)).add(eq("user123"),any(Message.class));}@TestvoidshouldHandleEmptyKnowledgeBase(){// GivenChatRequest request =ChatRequest.builder().userId("user123").message("这是一个新问题").build();when(vectorStore.similaritySearch(any(SearchRequest.class))).thenReturn(Arrays.asList());// When & ThenChatResponse response = customerService.handleUserQuery(request);assertThat(response).isNotNull();// 验证系统能够优雅处理空知识库的情况}}

集成测试

@SpringBootTest(webEnvironment =SpringBootTest.WebEnvironment.RANDOM_PORT)@AutoConfigureTestDatabase(replace =AutoConfigureTestDatabase.Replace.NONE)@TestcontainersclassCustomerServiceIntegrationTest{@ContainerstaticPostgreSQLContainer<?> postgres =newPostgreSQLContainer<>("pgvector/pgvector:pg16").withDatabaseName("test_customer_service").withUsername("test").withPassword("test");@AutowiredprivateTestRestTemplate restTemplate;@AutowiredprivateKnowledgeBaseService knowledgeBaseService;@MockBeanprivateAnthropicChatModel chatModel;@TestvoidshouldCompleteFullChatFlow()throwsException{// 1. 准备测试数据 - 添加知识文档MockMultipartFile testFile =newMockMultipartFile("file","test-doc.txt","text/plain","这是一个测试文档，包含公司政策信息。".getBytes()); knowledgeBaseService.addDocument(testFile,"policy","test-user");// 2. 模拟Claude响应org.springframework.ai.chat.model.ChatResponse mockResponse =neworg.springframework.ai.chat.model.ChatResponse(Arrays.asList(newGeneration(newAssistantMessage("基于提供的文档，我可以回答您的问题..."))));when(chatModel.call(any(Prompt.class))).thenReturn(mockResponse);// 3. 发送聊天请求ChatRequest chatRequest =ChatRequest.builder().message("请告诉我公司政策").userId("test-user").conversationId("test-conv").build();HttpHeaders headers =newHttpHeaders(); headers.set("X-User-ID","test-user");HttpEntity<ChatRequest> request =newHttpEntity<>(chatRequest, headers);// 4. 验证响应ResponseEntity<ApiResponse> response = restTemplate.postForEntity("/api/chat/message", request,ApiResponse.class);assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);assertThat(response.getBody().isSuccess()).isTrue();}}

性能调优与扩展

1. 缓存优化

@Configuration@EnableCachingpublicclassCacheConfig{@BeanpublicCacheManagercacheManager(){RedisCacheManager.Builder builder =RedisCacheManager .RedisCacheManagerBuilder.fromConnectionFactory(redisConnectionFactory()).cacheDefaults(cacheConfiguration());return builder.build();}privateRedisCacheConfigurationcacheConfiguration(){returnRedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(30)).serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(newStringRedisSerializer())).serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(newGenericJackson2JsonRedisSerializer()));}}@ServicepublicclassCachedKnowledgeService{@Cacheable(value ="knowledge-search", key ="#query + '-' + #limit")publicList<KnowledgeSearchResult>searchWithCache(String query,int limit){return knowledgeBaseService.searchKnowledge(query, limit);}@CacheEvict(value ="knowledge-search", allEntries =true)publicvoidclearSearchCache(){// 当知识库更新时清除缓存}}

2. 异步处理优化

@Configuration@EnableAsyncpublicclassAsyncConfig{@Bean(name ="documentProcessingExecutor")publicTaskExecutordocumentProcessingExecutor(){ThreadPoolTaskExecutor executor =newThreadPoolTaskExecutor(); executor.setCorePoolSize(4); executor.setMaxPoolSize(8); executor.setQueueCapacity(100); executor.setThreadNamePrefix("doc-processing-"); executor.setRejectedExecutionHandler(newThreadPoolExecutor.CallerRunsPolicy()); executor.initialize();return executor;}@Bean(name ="chatProcessingExecutor")publicTaskExecutorchatProcessingExecutor(){ThreadPoolTaskExecutor executor =newThreadPoolTaskExecutor(); executor.setCorePoolSize(8); executor.setMaxPoolSize(16); executor.setQueueCapacity(200); executor.setThreadNamePrefix("chat-processing-"); executor.initialize();return executor;}}@ServicepublicclassAsyncDocumentProcessor{@Async("documentProcessingExecutor")publicCompletableFuture<Void>processDocumentAsync(MultipartFile file,String category,String uploadedBy){try{ knowledgeBaseService.addDocument(file, category, uploadedBy);// 发送处理完成通知 notificationService.sendProcessingComplete(uploadedBy, file.getOriginalFilename());returnCompletableFuture.completedFuture(null);}catch(Exception e){ log.error("异步文档处理失败", e); notificationService.sendProcessingError(uploadedBy, file.getOriginalFilename(), e.getMessage());thrownewCompletionException(e);}}}

3. 流式响应实现

@RestControllerpublicclassStreamingChatController{@GetMapping(value ="/api/chat/stream", produces =MediaType.TEXT_EVENT_STREAM_VALUE)publicFlux<ServerSentEvent<String>>streamChat(@RequestParamString message,@RequestParamString userId){returnFlux.create(sink ->{try{// 构建流式请求ChatRequest request =ChatRequest.builder().message(message).userId(userId).build();// 调用支持流式响应的服务 customerService.handleUserQueryStream(request).subscribe( chunk -> sink.next(ServerSentEvent.<String>builder().data(chunk).build()), error -> sink.error(error),()-> sink.complete());}catch(Exception e){ sink.error(e);}});}}

总结与展望

基于Spring AI和Claude构建企业智能客服系统，我们获得了以下核心优势：

技术优势

1. 开发效率大幅提升：Spring AI提供的统一抽象层大大简化了AI集成的复杂度
2. 企业级稳定性：完整的Spring生态支持确保了系统的可靠性和可维护性
3. 灵活的扩展能力：模块化设计支持快速添加新功能和集成其他AI服务

业务价值

1. 智能化客服体验：基于企业知识库的精准回答提升了服务质量
2. 成本效益显著：自动化处理减少了人工客服的工作量
3. 数据安全可控：内部部署确保了企业数据的安全性

未来发展方向

随着AI技术的快速发展，我们的智能客服系统还可以在以下方面进行增强：

多模态支持

• 集成图像理解能力，支持图文混合问答
• 添加语音交互功能，提供更自然的交互体验

智能化升级

• 实现意图识别和情感分析
• 支持主动推荐和个性化服务
• 集成工作流自动化能力

性能优化

• 实现更智能的缓存策略
• 优化向量检索算法
• 支持大规模并发处理

通过本文的详细介绍，相信您已经掌握了使用Spring AI和Claude构建企业智能客服系统的核心技术和实践方法。这套方案不仅技术先进，而且具有良好的工程实践性，能够满足企业级应用的各种需求。

在实际项目中，建议根据具体的业务场景和技术栈情况，对架构和实现细节进行适当调整。同时，持续关注Spring AI和Claude的更新动态，及时采用新功能来进一步提升系统能力。

企业智能客服系统的建设是一个持续迭代的过程，通过不断优化和完善，必将为企业带来更大的价值和竞争优势。