Spring AI 访问 DeepSeek 有多种方式，我来为你详细介绍具体的配置和使用方法：

1. 使用 Spring AI 原生支持（推荐）

1.1 添加依赖

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-deepseek-spring-boot-starter</artifactId>
    <version>0.8.1</version>
</dependency>

1.2 配置 application.yml

spring:
  ai:
    deepseek:
      base-url: https://api.deepseek.com
      api-key: ${DEEPSEEK_API_KEY}
      chat:
        options:
          model: deepseek-chat
          temperature: 0.7
          max-tokens: 2048

1.3 使用 ChatClient

@RestController
public class DeepSeekController {
    
    private final ChatClient chatClient;
    
    public DeepSeekController(ChatClient chatClient) {
        this.chatClient = chatClient;
    }
    
    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return chatClient.call(message);
    }
}

2. 使用 OpenAiApiClient（兼容 OpenAI 格式）

2.1 配置

spring:
  ai:
    openai:
      base-url: https://api.deepseek.com/v1
      api-key: ${DEEPSEEK_API_KEY}
      chat:
        options:
          model: deepseek-chat
          temperature: 0.7

2.2 代码使用

@Service
public class DeepSeekService {
    
    @Autowired
    private OpenAiChatClient chatClient;
    
    public String generateResponse(String prompt) {
        return chatClient.call(prompt);
    }
    
    public List<String> generateMultipleResponses(String prompt, int count) {
        Prompt chatPrompt = new Prompt(new UserMessage(prompt));
        ChatResponse response = chatClient.call(chatPrompt);
        
        return response.getResults().stream()
                .map(Generation::getOutput)
                .map(AssistantMessage::getContent)
                .collect(Collectors.toList());
    }
}

3. 高级配置和使用

3.1 完整配置示例

spring:
  ai:
    deepseek:
      base-url: https://api.deepseek.com
      api-key: ${DEEPSEEK_API_KEY}
      chat:
        options:
          model: deepseek-chat
          temperature: 0.7
          max-tokens: 4096
          top-p: 0.9
          frequency-penalty: 0.0
          presence-penalty: 0.0
      retry:
        max-attempts: 3
        backoff:
          initial-interval: 2s
          multiplier: 2
          max-interval: 10s

3.2 自定义 ChatOptions

@Configuration
public class DeepSeekConfig {
    
    @Bean
    public DeepSeekChatOptions deepSeekChatOptions() {
        return DeepSeekChatOptions.builder()
                .withModel("deepseek-chat")
                .withTemperature(0.7)
                .withMaxTokens(2048)
                .withTopP(0.9)
                .withStream(false)
                .build();
    }
    
    @Bean
    public ChatClient chatClient(DeepSeekChatClient deepSeekChatClient) {
        return deepSeekChatClient;
    }
}

4. 流式响应处理

4.1 流式对话

@RestController
public class StreamChatController {
    
    @Autowired
    private StreamingChatClient streamingChatClient;
    
    @GetMapping("/chat/stream")
    public Flux<String> streamChat(@RequestParam String message) {
        return streamingChatClient.stream(message)
                .content();
    }
    
    @GetMapping(value = "/chat/stream-sse", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<String>> streamChatSSE(@RequestParam String message) {
        return streamingChatClient.stream(message)
                .content()
                .map(content -> ServerSentEvent.builder(content).build());
    }
}

5. 消息历史管理

5.1 带历史记录的对话

@Service
public class ConversationService {
    
    private final List<Message> conversationHistory = new ArrayList<>();
    
    @Autowired
    private ChatClient chatClient;
    
    public String chatWithHistory(String userMessage) {
        // 添加用户消息到历史记录
        conversationHistory.add(new UserMessage(userMessage));
        
        // 构建包含历史记录的提示
        Prompt prompt = new Prompt(conversationHistory);
        
        // 调用 AI
        ChatResponse response = chatClient.call(prompt);
        String assistantResponse = response.getResult().getOutput().getContent();
        
        // 添加助手响应到历史记录
        conversationHistory.add(new AssistantMessage(assistantResponse));
        
        // 限制历史记录长度
        if (conversationHistory.size() > 20) {
            conversationHistory.remove(0);
            conversationHistory.remove(0);
        }
        
        return assistantResponse;
    }
    
    public void clearHistory() {
        conversationHistory.clear();
    }
}

6. 异常处理

6.1 全局异常处理

@ControllerAdvice
public class DeepSeekExceptionHandler {
    
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<ErrorResponse> handleDeepSeekException(RuntimeException ex) {
        ErrorResponse error = new ErrorResponse("DEEPSEEK_ERROR", ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
    }
    
    @ExceptionHandler(HttpClientErrorException.class)
    public ResponseEntity<ErrorResponse> handleHttpException(HttpClientErrorException ex) {
        ErrorResponse error = new ErrorResponse("API_ERROR", ex.getStatusCode().toString());
        return ResponseEntity.status(ex.getStatusCode()).body(error);
    }
}

// 错误响应类
public record ErrorResponse(String code, String message) {}

7. 测试配置

7.1 测试类

@SpringBootTest
class DeepSeekServiceTest {
    
    @Autowired
    private DeepSeekService deepSeekService;
    
    @Test
    void testChat() {
        String response = deepSeekService.generateResponse("你好，请介绍一下你自己");
        assertNotNull(response);
        assertFalse(response.isEmpty());
    }
    
    @TestConfiguration
    static class TestConfig {
        @Bean
        @Primary
        public DeepSeekChatClient deepSeekChatClient() {
            // 可以在这里配置 Mock 客户端用于测试
            return mock(DeepSeekChatClient.class);
        }
    }
}

8. 安全配置

8.1 API Key 安全管理

@Configuration
public class SecurityConfig {
    
    @Value("${deepseek.api.key}")
    private String apiKey;
    
    @Bean
    public DeepSeekApi deepSeekApi() {
        return new DeepSeekApi(apiKey);
    }
}

9. 性能优化配置

9.1 连接池配置

spring:
  ai:
    deepseek:
      connect-timeout: 10s
      read-timeout: 30s
  task:
    execution:
      pool:
        core-size: 10
        max-size: 50
        queue-capacity: 1000

注意事项

1. API Key 获取：需要在 DeepSeek 官网申请 API Key
2. 版本兼容：确保 Spring AI 版本与 DeepSeek API 兼容
3. 速率限制：注意 DeepSeek API 的调用频率限制
4. 错误处理：合理处理网络异常和 API 限制
5. 成本控制：监控 Token 使用量，避免意外费用

通过以上配置，你就可以在 Spring Boot 应用中轻松集成 DeepSeek 的 AI 能力了。记得根据实际需求调整参数和错误处理逻辑。