记一次 Spring Boot 接入 DeepSeek 的踩坑实践：从连接超时到流式响应优化

2026-08-17 14:23:11.123 ERROR [http-nio-8080-exec-8] o.s.web.client.RestTemplate : 
I/O error on POST request for "https://api.deepseek.com/v1/chat/completions": 
Read timed out; nested exception is java.net.SocketTimeoutException: Read timed out

<properties>
    <java.version>21</java.version>
    <spring-ai.version>1.0.0-M6</spring-ai.version>
</properties>

<dependencies>
    <!-- Spring AI 核心 -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        <version>${spring-ai.version}</version>
    </dependency>

    <!-- 关键：替换默认 HTTP 客户端为 OkHttp，支持连接池 -->
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>4.12.0</version>
    </dependency>
    
    <!-- 可选：若使用 WebFlux 流式，需排除冲突 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
</dependencies>

import okhttp3.ConnectionPool;
import okhttp3.OkHttpClient;
import org.springframework.ai.openai.OpenAiChatModel;
import org.springframework.ai.openai.OpenAiChatOptions;
import org.springframework.ai.openai.api.OpenAiApi;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.time.Duration;
import java.util.concurrent.TimeUnit;

@Configuration
public class DeepSeekConfig {

    @Value("${spring.ai.openai.api-key}")
    private String apiKey;

    @Value("${spring.ai.openai.base-url}")
    private String baseUrl;

    @Bean
    public OkHttpClient okHttpClient() {
        return new OkHttpClient.Builder()
                // 1. 连接超时：握手阶段最多等 10s
                .connectTimeout(Duration.ofSeconds(10))
                // 2. 读取超时：等待大模型返回第一个 Token 的时间（TTFT）
                //    注意：这里设为 120s，是因为长文本生成慢，但配合下文流式，我们会缩短这个值
                .readTimeout(Duration.ofSeconds(120))
                // 3. 写入超时：发送 Prompt 的时间（通常极短）
                .writeTimeout(Duration.ofSeconds(30))
                // 4. 【核心】连接池配置：MaxIdle=50，存活时间 5 分钟
                .connectionPool(new ConnectionPool(50, 5, TimeUnit.MINUTES))
                // 5. 重试机制：网络抖动自动重试一次（但注意幂等性）
                .retryOnConnectionFailure(true)
                .build();
    }

    @Bean
    public OpenAiChatModel deepSeekChatModel(OkHttpClient okHttpClient) {
        // 使用 OkHttp 构建 Spring AI 的底层 Api
        OpenAiApi openAiApi = new OpenAiApi(baseUrl, apiKey, okHttpClient);
        
        return OpenAiChatModel.builder()
                .openAiApi(openAiApi)
                .options(OpenAiChatOptions.builder()
                        .model("deepseek-chat") // DeepSeek 模型名
                        .temperature(0.7)
                        .maxTokens(4096)
                        .build())
                .build();
    }
}

import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.openai.OpenAiChatModel;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

@Service
public class AIChatService {

    private final OpenAiChatModel chatModel;

    public AIChatService(OpenAiChatModel chatModel) {
        this.chatModel = chatModel;
    }

    // 流式调用，返回 Flux
    public Flux<String> chatStream(String userMessage) {
        Prompt prompt = new Prompt(new UserMessage(userMessage));
        // Spring AI 的 stream 方法底层基于 WebClient，此时配合 OkHttp 的 EventSource
        return chatModel.stream(prompt)
                .map(response -> response.getResult().getOutput().getContent())
                .onErrorResume(e -> {
                    // 流式中断时的降级处理：返回友好提示
                    return Flux.just("【系统提示】AI 服务响应超时，请稍后重试。");
                });
    }
}

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

@RestController
public class ChatController {

    private final AIChatService chatService;

    public ChatController(AIChatService chatService) {
        this.chatService = chatService;
    }

    @GetMapping(value = "/ai/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> chat(@RequestParam String msg) {
        // 前端使用 EventSource 接收
        return chatService.chatStream(msg);
    }
}

spring:
  ai:
    openai:
      api-key: ${DEEPSEEK_API_KEY} # 从环境变量读取，禁止硬编码
      base-url: https://api.deepseek.com/v1 # DeepSeek 官方地址

# 调整 Tomcat 线程池，防止排队过长
server:
  tomcat:
    threads:
      max: 200        # 最大线程数
      min-spare: 10
    accept-count: 50  # 等待队列长度
    connection-timeout: 120000 # 连接超时 120s

// 简易拦截器：在 Service 层判断字符长度，粗略截断（精确截断需引入 Tokenizer）
if (userMessage.length() > 12000) {
    userMessage = userMessage.substring(0, 12000) + "...(内容过长已截断)";
}