SpringBoot整合DeepSeek技术指南(实际应用场景)

<!-- pom.xml 核心依赖 -->
<dependency>
    <groupId>com.deepseek</groupId>
    <artifactId>deepseek-java-sdk</artifactId>
    <version>2.5.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

# application.yml
deepseek:
  api:
    base-url: https://api.deepseek.com/v2
    token: ${DEEPSEEK_API_KEY} # 从环境变量读取
  timeout: 10000 # 毫秒
  retry:
    max-attempts: 3
    backoff: 2000

@Service
@Slf4j
public class DeepseekService {
    @Value("${deepseek.api.base-url}")
    private String baseUrl;
    @Value("${deepseek.api.token}")
    private String apiToken;
    private final WebClient webClient;
    public DeepseekService(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl(baseUrl)
                .defaultHeader("Authorization", "Bearer " + apiToken)
                .build();
    }
    /**
     * 通用AI请求方法
     * @param request 包含prompt和参数的DTO对象
     * @return 生成的文本内容
     */
    public Mono<String> generateContent(DeepseekRequest request) {
        return webClient.post()
                .uri("/generate")
                .bodyValue(request)
                .retrieve()
                .bodyToMono(DeepseekResponse.class)
                .timeout(Duration.ofMillis(10000))
                .retryWhen(Retry.backoff(3, Duration.ofSeconds(2)))
                .map(response -> {
                    if (response.getCode() != 200) {
                        throw new DeepseekException(response.getMsg());
                    }
                    return response.getData().getText();
                });
    }
}

@RestControllerAdvice
public class DeepseekExceptionHandler {
    @ExceptionHandler(DeepseekException.class)
    public ResponseEntity<ErrorResult> handleDeepseekException(DeepseekException ex) {
        ErrorResult error = new ErrorResult("DEEPSEEK_ERROR", 
            "AI服务异常: " + ex.getMessage());
        return ResponseEntity.status(502).body(error);
    }
    @ExceptionHandler(WebClientResponseException.class)
    public ResponseEntity<ErrorResult> handleWebClientException(WebClientResponseException ex) {
        ErrorResult error = new ErrorResult("NETWORK_ERROR",
            "接口通信失败: " + ex.getStatusCode());
        return ResponseEntity.status(503).body(error);
    }
}

@PostMapping("/generate-article")
public Mono<ResponseEntity<String>> generateArticle(@RequestBody ArticleRequest request) {
    String prompt = String.format("生成一篇关于%s的技术文章，包含以下要素：%s", 
        request.getTopic(), 
        String.join(",", request.getKeywords()));
    DeepseekRequest deepseekRequest = new DeepseekRequest(
        prompt, 
        "technical_writing", 
        0.7, 
        1024
    );
    return deepseekService.generateContent(deepseekRequest)
            .map(content -> {
                String formatted = ContentFormatter.formatMarkdown(content);
                return ResponseEntity.ok(formatted);
            });
}

@PostMapping("/optimize-content")
public Mono<ResponseEntity<ContentOptimization>> optimizeContent(
    @RequestBody String rawContent) {
    String optimizationPrompt = "优化以下内容使其更符合新媒体传播：\n" + rawContent;
    return deepseekService.generateContent(
            new DeepseekRequest(optimizationPrompt, "content_optimization", 0.5, 512))
        .zipWith(deepseekService.generateContent(
            new DeepseekRequest("生成5个爆款标题", "title_generation", 0.9, 128)))
        .map(tuple -> {
            ContentOptimization result = new ContentOptimization();
            result.setOptimizedContent(tuple.getT1());
            result.setTitles(Arrays.asList(tuple.getT2().split("\n")));
            return ResponseEntity.ok(result);
        });
}

@SpringBootTest
class DeepseekServiceTest {
    @Autowired
    private DeepseekService deepseekService;
    @Test
    void testTechnicalWriting() {
        DeepseekRequest request = new DeepseekRequest(
            "用Java解释量子计算基础",
            "technical_writing",
            0.6,
            800
        );
        StepVerifier.create(deepseekService.generateContent(request))
            .assertNext(content -> {
                assertTrue(content.contains("量子比特"));
                assertTrue(content.length() > 500);
            })
            .verifyComplete();
    }
}