SpringAI集成DeepSeek实战

小马爱打代码

1291人浏览 · 2025-02-14 15:30:43

小马爱打代码 · 2025-02-14 15:30:43 发布

SpringAI集成DeepSeek实战教程

引言
Spring AI作为Spring生态系统中的新成员，为开发者提供了便捷的AI集成方案。本文将详细介绍如何在Spring项目中集成DeepSeek模型，实现智能对话等功能。

环境准备
在开始之前，请确保您的开发环境满足以下要求：

JDK 17或更高版本
Spring Boot 3.x
Maven或Gradle构建工具
DeepSeek API密钥

项目配置
首先，在pom.xml中添加Spring AI的依赖：

<dependencies>
    <!-- Spring AI 核心依赖 -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-core</artifactId>
        <version>0.8.0</version>
    </dependency>
    
    <!-- DeepSeek 集成依赖 -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-deepseek</artifactId>
        <version>0.8.0</version>
    </dependency>
</dependencies>

基础配置类
创建DeepSeek配置类：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.ai.deepseek.DeepSeekAiClient;
import org.springframework.ai.deepseek.DeepSeekAiProperties;

@Configuration
public class DeepSeekConfig {
    
    @Bean
    public DeepSeekAiProperties deepSeekAiProperties() {
        // 配置DeepSeek属性
        DeepSeekAiProperties properties = new DeepSeekAiProperties();
        properties.setApiKey("your-api-key-here");
        properties.setModel("deepseek-chat"); // 设置使用的模型
        return properties;
    }
    
    @Bean
    public DeepSeekAiClient deepSeekAiClient(DeepSeekAiProperties properties) {
        // 创建DeepSeek客户端实例
        return new DeepSeekAiClient(properties);
    }
}

服务层实现
创建一个服务类来处理与DeepSeek的交互：

import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.stereotype.Service;

@Service
public class ChatService {
    
    private final DeepSeekAiClient aiClient;
    
    public ChatService(DeepSeekAiClient aiClient) {
        this.aiClient = aiClient;
    }
    
    /**
     * 发送单轮对话请求
     * @param message 用户输入的消息
     * @return AI的响应内容
     */
    public String sendMessage(String message) {
        // 创建用户消息
        UserMessage userMessage = new UserMessage(message);
        // 创建prompt对象
        Prompt prompt = new Prompt(userMessage);
        // 获取AI响应
        ChatResponse response = aiClient.generate(prompt);
        return response.getGeneration().getContent();
    }
    
    /**
     * 发送多轮对话请求
     * @param messages 对话历史记录
     * @return AI的响应内容
     */
    public String sendConversation(List<String> messages) {
        List<Message> conversationHistory = new ArrayList<>();
        
        // 构建对话历史
        for (String message : messages) {
            conversationHistory.add(new UserMessage(message));
        }
        
        // 创建带有历史记录的prompt
        Prompt prompt = new Prompt(conversationHistory);
        ChatResponse response = aiClient.generate(prompt);
        return response.getGeneration().getContent();
    }
}

控制器实现
创建REST API接口：

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/chat")
public class ChatController {
    
    private final ChatService chatService;
    
    public ChatController(ChatService chatService) {
        this.chatService = chatService;
    }
    
    /**
     * 处理单条消息请求
     * @param message 用户消息
     * @return AI响应
     */
    @PostMapping("/message")
    public ResponseEntity<String> handleMessage(@RequestBody String message) {
        try {
            String response = chatService.sendMessage(message);
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("处理消息时发生错误：" + e.getMessage());
        }
    }
    
    /**
     * 处理多轮对话请求
     * @param messages 对话历史
     * @return AI响应
     */
    @PostMapping("/conversation")
    public ResponseEntity<String> handleConversation(@RequestBody List<String> messages) {
        try {
            String response = chatService.sendConversation(messages);
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("处理对话时发生错误：" + e.getMessage());
        }
    }
}

异常处理
添加全局异常处理：

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {
    
    /**
     * 处理DeepSeek API相关异常
     */
    @ExceptionHandler(DeepSeekApiException.class)
    public ResponseEntity<String> handleDeepSeekApiException(DeepSeekApiException e) {
        // 记录错误日志
        log.error("DeepSeek API错误", e);
        return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
            .body("AI服务暂时不可用，请稍后重试");
    }
    
    /**
     * 处理其他未预期的异常
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleGeneralException(Exception e) {
        log.error("系统错误", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body("系统发生错误，请联系管理员");
    }
}

使用示例
以下是一个简单的使用示例：

@SpringBootApplication
public class DeepSeekDemoApplication {
    
    @Autowired
    private ChatService chatService;
    
    public void demonstrateChat() {
        // 发送单条消息
        String response1 = chatService.sendMessage("你好，请介绍一下自己");
        System.out.println("AI响应：" + response1);
        
        // 发送多轮对话
        List<String> conversation = Arrays.asList(
            "你好，我想学习Java",
            "请推荐一些好的学习资源",
            "这些资源适合初学者吗？"
        );
        String response2 = chatService.sendConversation(conversation);
        System.out.println("AI响应：" + response2);
    }
    
    public static void main(String[] args) {
        SpringApplication.run(DeepSeekDemoApplication.class, args);
    }
}