logo

开发者热搜

从0到1：Spring Boot与Spring AI构建AI应用全链路实战

作者：半吊子全栈工匠2025.09.25 20:09浏览量：0

简介：本文详细阐述如何基于Spring Boot与Spring AI框架，结合DeepSeek大模型，从零开始构建一个完整的AI应用。涵盖环境搭建、模型集成、服务开发到性能优化的全流程，适合Java开发者快速上手AI工程化实践。

一、技术选型与架构设计

1.1 技术栈选择依据

Spring Boot作为企业级Java开发框架，其”约定优于配置”的特性可大幅缩短开发周期。Spring AI是Spring生态针对AI场景的扩展模块，提供与主流大模型（如DeepSeek）的无缝集成能力。选择DeepSeek作为底层模型，因其具备以下优势：

  • 开源生态支持完善
  • 推理性能与精度平衡
  • 支持多模态交互
  • 社区活跃度高

1.2 系统架构分层

采用经典三层架构：

  1. ┌───────────────┐    ┌───────────────┐    ┌───────────────┐
  2. │   Client层    │ →  │   Service层   │ →  │   Model层    │
  3. └───────────────┘    └───────────────┘    └───────────────┘
  • Client层：Web/移动端交互界面
  • Service层：业务逻辑处理与AI服务编排
  • Model层：DeepSeek模型推理服务

1.3 关键组件说明

组件 功能说明 技术选型
模型服务 封装DeepSeek推理接口 Spring AI + DeepSeek Java SDK
缓存层 减少重复推理开销 Redis
监控系统 性能指标采集与告警 Prometheus + Grafana

二、开发环境搭建

2.1 基础环境配置

  1. # 推荐环境配置
  2. JDK 17+
  3. Maven 3.8+
  4. Spring Boot 3.2+
  5. Docker 24.0+

2.2 项目初始化

通过Spring Initializr生成基础项目：

  1. <!-- pom.xml关键依赖 -->
  2. <dependencies>
  3.     <dependency>
  4.         <groupId>org.springframework.boot</groupId>
  5.         <artifactId>spring-boot-starter-web</artifactId>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>org.springframework.ai</groupId>
  9.         <artifactId>spring-ai-starter-deepseek</artifactId>
  10.         <version>0.7.0</version>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>org.projectlombok</groupId>
  14.         <artifactId>lombok</artifactId>
  15.         <optional>true</optional>
  16.     </dependency>
  17. </dependencies>

2.3 模型服务配置

在application.yml中配置DeepSeek连接：

  1. spring:
  2.   ai:
  3.     deepseek:
  4.       api-key: your_api_key
  5.       endpoint: https://api.deepseek.com/v1
  6.       model: deepseek-chat:7b
  7.       temperature: 0.7
  8.       max-tokens: 2000

三、核心功能实现

3.1 模型服务封装

创建DeepSeekService类：

  1. @Service
  2. @RequiredArgsConstructor
  3. public class DeepSeekService {
  4.     private final DeepSeekClient deepSeekClient;
  6.     public String generateResponse(String prompt) {
  7.         ChatCompletionRequest request = ChatCompletionRequest.builder()
  8.             .model("deepseek-chat:7b")
  9.             .messages(List.of(
  10.                 new ChatMessage("user", prompt)
  11.             ))
  12.             .temperature(0.7)
  13.             .build();
  15.         ChatCompletionResponse response = deepSeekClient.chatCompletion(request);
  16.         return response.getChoices().get(0).getMessage().getContent();
  17.     }
  18. }

3.2 REST API开发

创建AIController：

  1. @RestController
  2. @RequestMapping("/api/ai")
  3. @RequiredArgsConstructor
  4. public class AIController {
  5.     private final DeepSeekService deepSeekService;
  7.     @PostMapping("/chat")
  8.     public ResponseEntity<String> chat(
  9.             @RequestBody @Valid ChatRequest request) {
  10.         String response = deepSeekService.generateResponse(request.getPrompt());
  11.         return ResponseEntity.ok(response);
  12.     }
  14.     @Data
  15.     static class ChatRequest {
  16.         @NotBlank
  17.         private String prompt;
  18.     }
  19. }

3.3 缓存优化实现

添加Redis缓存层：

  1. @Service
  2. @RequiredArgsConstructor
  3. public class CachedDeepSeekService {
  4.     private final DeepSeekService deepSeekService;
  5.     private final RedisTemplate<String, String> redisTemplate;
  7.     public String getCachedResponse(String prompt) {
  8.         String cacheKey = "ai:prompt:" + DigestUtils.md5Hex(prompt);
  10.         return redisTemplate.opsForValue().computeIfAbsent(
  11.             cacheKey, 
  12.             Duration.ofMinutes(10),
  13.             k -> deepSeekService.generateResponse(prompt)
  14.         );
  15.     }
  16. }

四、高级功能开发

4.1 流式响应实现

  1. public Flux<String> streamResponse(String prompt) {
  2.     StreamCompletionRequest request = StreamCompletionRequest.builder()
  3.         .model("deepseek-chat:7b")
  4.         .prompt(prompt)
  5.         .stream(true)
  6.         .build();
  8.     return deepSeekClient.streamCompletion(request)
  9.         .map(StreamCompletionChunk::getText)
  10.         .filter(StringUtils::isNotBlank);
  11. }

4.2 多模型路由

  1. @Service
  2. public class ModelRouterService {
  3.     @Value("${spring.ai.deepseek.model}")
  4.     private String defaultModel;
  6.     private final Map<String, String> modelMap = Map.of(
  7.         "quick", "deepseek-chat:3.5b",
  8.         "precise", "deepseek-chat:7b",
  9.         "creative", "deepseek-chat:16b"
  10.     );
  12.     public String resolveModel(String modelType) {
  13.         return Optional.ofNullable(modelMap.get(modelType))
  14.             .orElse(defaultModel);
  15.     }
  16. }

4.3 异步处理优化

  1. @Async
  2. public CompletableFuture<String> asyncGenerate(String prompt) {
  3.     return CompletableFuture.supplyAsync(() -> 
  4.         deepSeekService.generateResponse(prompt)
  5.     );
  6. }

五、部署与运维

5.1 Docker化部署

  1. FROM eclipse-temurin:17-jdk-jammy
  2. ARG JAR_FILE=target/*.jar
  3. COPY ${JAR_FILE} app.jar
  4. ENTRYPOINT ["java","-jar","/app.jar"]

5.2 Kubernetes配置示例

  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   name: spring-ai-app
  5. spec:
  6.   replicas: 3
  7.   selector:
  8.     matchLabels:
  9.       app: spring-ai
  10.   template:
  11.     metadata:
  12.       labels:
  13.         app: spring-ai
  14.     spec:
  15.       containers:
  16.       - name: app
  17.         image: your-registry/spring-ai:latest
  18.         ports:
  19.         - containerPort: 8080
  20.         resources:
  21.           requests:
  22.             cpu: "500m"
  23.             memory: "1Gi"
  24.           limits:
  25.             cpu: "1"
  26.             memory: "2Gi"

5.3 监控指标配置

  1. @Bean
  2. public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
  3.     return registry -> registry.config().commonTags("application", "spring-ai-demo");
  4. }
  6. @Timed(value = "ai.response", description = "Time taken to get AI response")
  7. public String generateResponse(String prompt) {
  8.     // ...
  9. }

六、最佳实践与优化

6.1 性能优化策略

  1. 批处理优化：合并多个小请求为批量请求
  2. 连接池管理：配置合理的HTTP连接池参数
  3. 模型缓存：缓存常用提示的模型输出

6.2 安全实践

  1. 输入验证：防止提示注入攻击
  2. 速率限制：防止API滥用
  3. 数据脱敏：敏感信息处理

6.3 成本优化

  1. 模型选择：根据场景选择合适参数量的模型
  2. 缓存策略：合理设置缓存TTL
  3. 监控告警：及时发现异常调用

七、完整案例演示

7.1 智能客服系统实现

  1. @Service
  2. public class SmartCustomerService {
  3.     private final Map<String, String> intentMap = Map.of(
  4.         "order_status", "请提供您的订单号，我将为您查询最新状态",
  5.         "return_policy", "我们的退货政策是30天内无理由退换"
  6.     );
  8.     @Autowired
  9.     private DeepSeekService deepSeekService;
  11.     public String handleQuery(String query) {
  12.         // 意图识别
  13.         String intent = identifyIntent(query);
  15.         // 匹配预设回答
  16.         if (intentMap.containsKey(intent)) {
  17.             return intentMap.get(intent);
  18.         }
  20.         // AI生成回答
  21.         return deepSeekService.generateResponse(
  22.             "作为客服，请用专业友好的语气回答以下问题：" + query
  23.         );
  24.     }
  26.     private String identifyIntent(String query) {
  27.         // 简化的意图识别逻辑
  28.         if (query.contains("订单") || query.contains("发货")) {
  29.             return "order_status";
  30.         }
  31.         if (query.contains("退货") || query.contains("退款")) {
  32.             return "return_policy";
  33.         }
  34.         return "general";
  35.     }
  36. }

7.2 测试用例示例

  1. @SpringBootTest
  2. class AIControllerTest {
  3.     @Autowired
  4.     private TestRestTemplate restTemplate;
  6.     @Test
  7.     void testChatEndpoint() {
  8.         ChatRequest request = new ChatRequest();
  9.         request.setPrompt("解释Spring AI框架的作用");
  11.         String response = restTemplate.postForObject(
  12.             "/api/ai/chat", 
  13.             request, 
  14.             String.class
  15.         );
  17.         assertThat(response).contains("Spring AI");
  18.     }
  19. }

八、总结与展望

本实战项目完整展示了从Spring Boot项目初始化到AI服务集成的全流程。关键收获包括：

  1. 掌握Spring AI与DeepSeek的集成方法
  2. 理解AI应用开发的典型架构模式
  3. 实践性能优化与运维监控的最佳实践

未来发展方向：

  1. 探索多模型融合架构
  2. 实现自适应模型选择机制
  3. 集成向量数据库提升上下文理解能力

建议开发者持续关注Spring AI生态更新，特别是对多模态支持的增强。实际生产环境中，建议从轻量级模型开始，逐步根据业务需求升级模型能力。

相关文章推荐

发表评论

最热文章

关于作者

  • 被阅读数
  • 被赞数
  • 被收藏数