1. 为什么要在JDK1.8环境下集成DeepSeek-R1？

如果你和我一样，是个在传统Java项目里摸爬滚打多年的老开发，看到这个标题的第一反应可能是：“都202X年了，怎么还在聊JDK1.8？” 说实话，我刚开始也这么想。但现实是，我手头维护的至少三个核心项目，都还跑在JDK1.8和SpringBoot 2.x上。升级？谈何容易。业务不能停，重构风险大，依赖库一堆兼容性问题。所以，当DeepSeek-R1这种强大的推理模型出现时，我的第一念头不是“哇，新技术！”，而是“这玩意儿能在我的老项目里跑起来吗？”

这就是我今天想跟你聊的核心：如何在JDK1.8和SpringBoot 2.x这个“经典”但略显老旧的栈上，无缝集成最新的DeepSeek-R1大模型。你可能已经搜过不少教程，发现主流方案要么是Spring AI（要求JDK 17+），要么是各种新潮的框架，对老环境支持寥寥。别急，我踩过这些坑，也找到了切实可行的路。

简单来说，DeepSeek-R1不是个只能在高版本环境里供着的“花瓶”。通过一些适配和选对工具，我们完全可以让它在JDK1.8的环境下稳定工作，为你的老系统注入AI智能。无论是想给内部管理系统加个智能问答助手，还是为传统业务逻辑增加一些推理和决策能力，这个组合都能帮你实现，而且不需要你动架构、升版本。接下来，我就带你一步步走通这条路，从环境准备到代码落地，全是实战干货。

2. 核心工具选型：ai4j vs. 原生HTTP调用 vs. DeepSeek4j

面对JDK1.8的限制，我们主要有三条技术路径可选。我挨个试过，各有优劣，你得根据自己项目的实际情况来挑。

### 2.1 方案一：使用ai4j（一站式集成）

这是我最初尝试的方案，也是很多教程里推荐的。ai4j 这个库的定位很清晰：为Java开发者提供一个统一的API，来调用各种AI模型。它的最大优点就是省心。

• 优点：

  1. 开箱即用：它封装了DeepSeek、Ollama、智谱等多种平台的调用细节，你不需要关心每个平台API的细微差别。
  2. JDK1.8友好：官方明确支持JDK1.8，这是它相对于Spring AI的最大优势。
  3. API统一：不管后端是哪个模型，你调用的方法几乎一样，降低了学习成本和后续切换模型的风险。
  4. 功能齐全：基础的对话、流式输出、甚至一些简单的工具调用（Tool Call）都支持。

• 缺点与坑点：

  1. 版本迭代快：我写这篇文章时最新是1.3.0，但可能你看到时已经更新了。新版本有时会引入不兼容的改动，需要仔细看更新日志。
  2. 依赖传递复杂：它会引入一系列传递依赖，可能会和你项目里已有的库产生冲突，需要做好依赖管理。
  3. 灵活性受限：因为是高度封装的，如果你想对DeepSeek-R1的一些特有参数（比如更精细地控制思维链输出）做深度定制，可能会发现API不支持。

### 2.2 方案二：原生HTTP调用（最灵活，最可控）

这是最“原始”但也最可靠的方法。说白了，就是自己用HttpClient或者像Hutool这样的工具库，按照DeepSeek官方API文档，手动组装HTTP请求、解析响应。

• 优点：

  1. 零依赖冲突：除了一个HTTP客户端和JSON解析库，几乎不引入任何外部依赖，完美避开依赖地狱。
  2. 绝对可控：请求体、响应头、错误处理、重试机制，所有细节你都能自己掌控。DeepSeek-R1的任何新特性，只要API支持，你都能第一时间用上。
  3. 轻量级：特别适合在已有的大型、稳定项目中，以最小侵入的方式增加AI功能。

• 缺点：

  1. 开发成本高：你需要自己处理HTTP连接池、超时设置、响应解析、异常处理等一堆琐事。
  2. 代码冗余：如果项目里还要调用其他AI服务，每个都要写一套类似的HTTP调用代码，维护起来麻烦。

### 2.3 方案三：使用DeepSeek4j（专为DeepSeek而生）

这是我近期发现的一个宝藏项目。DeepSeek4j 是专门为DeepSeek模型打造的Java客户端，特别是对DeepSeek-R1的思维链（Reasoning）能力做了深度适配和保留。

• 优点：

  1. 思维链完整保留：这是它最大的亮点！Spring AI或ai4j在调用R1时，可能会丢失模型中间“思考”的过程，而DeepSeek4j能完整地在响应中返回这些内容，对于调试和理解模型行为至关重要。
  2. 响应式流式处理：基于Project Reactor，提供了非常优雅的流式响应（Flux）支持，做聊天应用体验很好。
  3. Spring Boot Starter：提供了开箱即用的Spring Boot Starter，同时支持2.x和3.x版本，配置简单。
  4. 内置调试页面：这个功能太实用了！它自带一个HTML页面，可以直接在浏览器里测试接口，实时看到流式输出和思维链。

• 缺点：

  1. 相对小众：社区和生态不如ai4j或Spring AI成熟，遇到问题时可能需要自己深入源码解决。
  2. 专注DeepSeek：顾名思义，它只服务于DeepSeek。如果你的项目未来需要接入多模型，它可能不是最佳选择。

我的选择建议：

• 求稳、快速上线、且项目结构简单：选 ai4j。它能让你最快跑通流程。
• 项目庞大、依赖复杂、追求极致稳定和控制力：选 原生HTTP调用。虽然起步慢点，但一劳永逸。
• 深度使用DeepSeek-R1、特别看重其思维链能力、且项目技术栈较新（能用响应式编程）：强烈推荐尝试 DeepSeek4j。

为了覆盖最广泛的场景，下面的实战部分，我将以 “原生HTTP调用” 和 “ai4j” 这两个最具代表性的方案作为主线，给你最详细的演示。DeepSeek4j的方案我会在进阶部分简要提及其思路。

3. 实战准备：获取DeepSeek API Key与项目初始化

无论选哪种方案，第一步都一样：拿到“钥匙”并搭好项目架子。

### 3.1 获取DeepSeek API Key

1. 访问DeepSeek开放平台官网（这里假设为官方平台）。如果你所在网络环境访问有困难，也可以考虑使用阿里云百炼、火山引擎等国内云厂商提供的DeepSeek API服务，它们通常有稳定的国内节点，申请方式类似。
2. 注册并登录后，在控制台找到“API Keys”或“密钥管理” section。
3. 点击“创建新的API Key”，给它起个名字（比如“MySpringBootApp”），然后复制生成的那一串以sk-开头的密钥。切记：这个密钥只显示一次，务必妥善保存。我习惯把它先存到本地的加密笔记里，等会儿配置要用。

### 3.2 创建SpringBoot 2.x项目

这里我假设你用Maven。打开IDE或者使用Spring Initializr网站。

• Project: Maven
• Language: Java
• Spring Boot: 选择一个2.x的最终稳定版，比如 2.7.18 或 2.6.14（这两个版本和JDK1.8配合非常稳定）。
• Project Metadata：按你的习惯填。
• Dependencies：至少添加 Spring Web。为了方便，我还会加上 Lombok（减少Getter/Setter代码）和 Hutool-all（一个国产全能工具库，HTTP和JSON处理非常方便）。如果你不用Hutool，确保有类似功能的库如Apache HttpClient和Jackson。

点击生成，下载并导入到你的IDE中。检查一下pom.xml里的Java版本配置，确保是1.8：

<properties>
    <java.version>1.8</java.version>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

4. 方案A实战：使用原生HTTP调用集成（Hutool示例）

这个方案最能体现“自力更生”的精神，适合所有场景。我们使用Hutool来简化HTTP操作。

### 4.1 添加依赖

在pom.xml的<dependencies>部分添加Hutool和Lombok（如果Initializr没选的话）：

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.24</version> <!-- 使用一个稳定的版本 -->
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>provided</scope>
</dependency>

### 4.2 编写配置类

我们不希望把API Key硬编码在代码里。在application.yml中配置：

deepseek:
  api:
    key: sk-你的实际API密钥 # 从环境变量读取更安全，例如 ${DEEPSEEK_API_KEY}
    url: https://api.deepseek.com/chat/completions # DeepSeek官方API地址
    model: deepseek-r1 # 指定使用R1模型
    temperature: 0.7 # 创造性，0-2之间
    max-tokens: 2000 # 最大生成长度

然后创建一个配置类DeepSeekConfig.java来映射这些属性：

package com.yourpackage.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
@ConfigurationProperties(prefix = "deepseek.api")
public class DeepSeekConfig {
    private String key;
    private String url;
    private String model;
    private Double temperature;
    private Integer maxTokens;
}

### 4.3 定义请求与响应体

根据DeepSeek API文档，我们需要定义对应的Java对象。创建dto包，放入以下类：

ChatRequest.java (请求体)：

package com.yourpackage.dto;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChatRequest {
    private String model;
    private List<Message> messages;
    private Double temperature;
    private Integer max_tokens;
    private Boolean stream = false; // 非流式设为false

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Message {
        private String role; // "user", "assistant", "system"
        private String content;
    }
}

ChatResponse.java (响应体)：

package com.yourpackage.dto;

import lombok.Data;
import java.util.List;

@Data
public class ChatResponse {
    private String id;
    private String object;
    private Long created;
    private String model;
    private List<Choice> choices;
    private Usage usage;

    @Data
    public static class Choice {
        private Integer index;
        private Message message;
        private String finish_reason;

        @Data
        public static class Message {
            private String role;
            private String content;
        }
    }

    @Data
    public static class Usage {
        private Integer prompt_tokens;
        private Integer completion_tokens;
        private Integer total_tokens;
    }
}

注意：这是最简化的响应结构。DeepSeek-R1的响应里可能包含reasoning_content等额外字段，如果你需要，可以参照官方文档扩展这个类。

### 4.4 实现服务层

创建服务接口和实现类： IDeepSeekService.java:

package com.yourpackage.service;

public interface IDeepSeekService {
    String chat(String userMessage);
}

DeepSeekServiceImpl.java:

package com.yourpackage.service.impl;

import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.Method;
import cn.hutool.json.JSONUtil;
import com.yourpackage.config.DeepSeekConfig;
import com.yourpackage.dto.ChatRequest;
import com.yourpackage.dto.ChatResponse;
import com.yourpackage.service.IDeepSeekService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;

@Service
@Slf4j
public class DeepSeekServiceImpl implements IDeepSeekService {

    @Resource
    private DeepSeekConfig deepSeekConfig;

    @Override
    public String chat(String userMessage) {
        try {
            // 1. 构建请求
            ChatRequest request = ChatRequest.builder()
                    .model(deepSeekConfig.getModel())
                    .temperature(deepSeekConfig.getTemperature())
                    .max_tokens(deepSeekConfig.getMaxTokens())
                    .messages(Collections.singletonList(
                            new ChatRequest.Message("user", userMessage)
                    ))
                    .build();

            String requestBody = JSONUtil.toJsonStr(request);
            log.info("发送DeepSeek请求: {}", requestBody);

            // 2. 发送HTTP请求
            HttpResponse response = HttpRequest.of(deepSeekConfig.getUrl())
                    .method(Method.POST)
                    .header("Authorization", "Bearer " + deepSeekConfig.getKey())
                    .header("Content-Type", "application/json")
                    .header("Accept", "application/json")
                    .timeout(60000) // 设置60秒超时，R1推理可能较慢
                    .body(requestBody)
                    .execute();

            // 3. 处理响应
            if (response.isOk()) {
                String body = response.body();
                log.info("收到DeepSeek响应: {}", body);
                ChatResponse chatResponse = JSONUtil.toBean(body, ChatResponse.class);
                if (chatResponse.getChoices() != null && !chatResponse.getChoices().isEmpty()) {
                    return chatResponse.getChoices().get(0).getMessage().getContent();
                } else {
                    throw new RuntimeException("API响应中未包含有效结果");
                }
            } else {
                log.error("DeepSeek API调用失败，状态码: {}, 响应体: {}", response.getStatus(), response.body());
                throw new RuntimeException("调用AI服务失败，状态码: " + response.getStatus());
            }
        } catch (Exception e) {
            log.error("调用DeepSeek-R1服务异常", e);
            throw new RuntimeException("AI服务暂时不可用: " + e.getMessage());
        }
    }
}

### 4.5 创建控制器

最后，创建一个简单的REST接口来暴露功能： ChatController.java:

package com.yourpackage.controller;

import com.yourpackage.service.IDeepSeekService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@RestController
@RequestMapping("/api/chat")
public class ChatController {

    @Resource
    private IDeepSeekService deepSeekService;

    @GetMapping("/simple")
    public String chat(@RequestParam String message) {
        return deepSeekService.chat(message);
    }
}

### 4.6 测试

启动你的SpringBoot应用，然后使用浏览器、Postman或者curl测试：

curl "http://localhost:8080/api/chat/simple?message=请用Java写一个快速排序的方法"

如果一切顺利，你将收到DeepSeek-R1生成的代码。这个方案虽然代码量稍多，但每一行都在你的掌控之中，没有黑盒，非常适合在生产环境使用。

5. 方案B实战：使用ai4j快速集成

如果你觉得上面那种方式太“硬核”，那么ai4j提供的封装会让你感觉轻松很多。

### 5.1 添加ai4j依赖

在你的pom.xml中，替换或添加ai4j的starter依赖。注意：你需要根据ai4j的官方文档确认最新版本号。

<dependency>
    <groupId>io.github.lnyo-cly</groupId>
    <artifactId>ai4j-spring-boot-starter</artifactId>
    <version>1.3.0</version> <!-- 请检查GitHub仓库获取最新版本 -->
</dependency>

添加这个依赖后，你可能需要解决一些传递依赖冲突，特别是Netty和Jackson的版本。这是使用ai4j的主要“坑点”之一，耐心调整<exclusions>即可。

### 5.2 配置ai4j

在application.yml中，配置ai4j使用DeepSeek平台：

ai:
  deepseek:
    api-key: sk-你的实际API密钥
    # ai4j可能已经内置了DeepSeek的base-url，如果不需要自定义代理，可以不配

ai4j的魅力在于，它通过PlatformType.DEEPSEEK来抽象化配置。你不需要像原生调用那样自己拼装URL和请求头。

### 5.3 编写ai4j版本的控制器

直接注入AiService，通过它获取指定平台的服务实例：

package com.yourpackage.controller;

import io.github.lnyocly.ai4j.platform.openai.chat.entity.ChatCompletion;
import io.github.lnyocly.ai4j.platform.openai.chat.entity.ChatCompletionResponse;
import io.github.lnyocly.ai4j.platform.openai.chat.entity.ChatMessage;
import io.github.lnyocly.ai4j.service.IChatService;
import io.github.lnyocly.ai4j.service.PlatformType;
import io.github.lnyocly.ai4j.service.factor.AiService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@RestController
@Slf4j
public class Ai4jChatController {

    @Resource
    private AiService aiService;

    @GetMapping("/ai4j/chat")
    public String chat(@RequestParam String question) {
        try {
            // 1. 获取DeepSeek平台的聊天服务
            IChatService chatService = aiService.getChatService(PlatformType.DEEPSEEK);
            // 2. 构建请求（ai4j使用了与OpenAI兼容的请求结构）
            ChatCompletion completion = ChatCompletion.builder()
                    .model("deepseek-r1") // 指定模型
                    .message(ChatMessage.withUser(question))
                    .temperature(0.7)
                    .maxTokens(2000)
                    .build();
            // 3. 调用并获取响应
            ChatCompletionResponse response = chatService.chatCompletion(completion);
            // 4. 提取内容
            String answer = response.getChoices().get(0).getMessage().getContent().getText();
            Long tokensUsed = response.getUsage().getTotalTokens();
            log.info("本次对话消耗Token: {}", tokensUsed);
            return answer;
        } catch (Exception e) {
            log.error("ai4j调用DeepSeek失败", e);
            return "服务调用出错: " + e.getMessage();
        }
    }
}

可以看到，代码简洁了很多。AiService帮我们处理了认证、序列化、反序列化等所有底层细节。流式调用的支持也类似，ai4j提供了SseListener等工具类。

6. 进阶话题：流式响应、思维链与本地部署

### 6.1 实现流式响应（Server-Sent Events）

无论是原生调用还是ai4j，都支持流式响应（Streaming）。这对于生成较长文本时的用户体验至关重要，用户不需要等待全部生成完毕就能看到部分结果。

在原生HTTP方案中，你需要将请求中的stream字段设为true，然后API会返回一个data: 格式的流。你需要逐行读取并解析。使用Hutool的HttpRequest可以配合回调函数处理流式响应，代码会变得复杂一些。

在ai4j中，则相对简单，使用chatService.chatCompletionStream(completion, sseListener)方法，并实现一个SseListener来处理每一块返回的数据。

### 6.2 处理DeepSeek-R1的思维链

DeepSeek-R1的核心优势在于其“思考在前，结论在后”的推理能力。在原生API的响应中，你可能会在choices[0].message里看到一个额外的reasoning_content字段，里面包含了模型的完整思考过程。

在ai4j的当前版本（1.3.0）中，我实测发现其标准的ChatCompletionResponse可能没有直接暴露这个字段。你可能需要查看响应原始JSON，或者等待ai4j后续版本更新对R1思维链的专门支持。

这也是为什么DeepSeek4j这个项目有它的价值，因为它从设计之初就考虑到了完整保留和展示思维链。

### 6.3 本地部署与Ollama集成

如果你的数据敏感，或者希望获得更低的调用延迟和成本，可以考虑使用Ollama在本地或内网服务器部署DeepSeek-R1模型。

1. 安装Ollama：去官网下载对应操作系统的安装包，一行命令安装。
2. 拉取并运行模型：在终端执行 ollama run deepseek-r1:7b（根据你的显卡选择7b, 14b等参数版本）。
3. 修改集成方式：
   • 原生HTTP调用：只需将配置中的api.url从DeepSeek官方地址改为你本地的Ollama地址，例如 http://localhost:11434/api/chat，并且请求体格式需要遵循Ollama的API（与OpenAI格式略有不同）。
   • 使用ai4j：这是ai4j的强项。你只需要在配置中将平台类型从PlatformType.DEEPSEEK改为PlatformType.OLLAMA，并在配置文件中指定Ollama的base-url和模型名称deepseek-r1:7b即可。ai4j内部会处理API格式的转换。

本地部署后，API调用就不再需要互联网，也不再产生费用，但需要你自有足够的算力（GPU）来支撑推理速度。

7. 生产环境注意事项与性能调优

把Demo跑起来只是第一步，要真正用到生产环境，还有几个关键点必须注意。

### 7.1 安全性

• API Key管理：绝对不要将API Key提交到代码仓库。使用环境变量、配置中心（如Apollo、Nacos）或云厂商的密钥管理服务来存储。在application.yml中这样引用：api-key: ${DEEPSEEK_API_KEY}。
• 输入输出过滤：对用户输入的question和模型返回的content进行必要的敏感词过滤和内容安全检查，防止生成不当内容。
• 权限控制：你的/api/chat接口应该加上身份认证和鉴权，避免被恶意滥用导致API Key消耗殆尽。

### 7.2 稳定性与容错

• 超时设置：DeepSeek-R1进行复杂推理时可能耗时较长，务必设置合理的连接超时和读取超时（例如60-120秒），并做好超时后的异常处理和用户提示。
• 重试机制：对于网络抖动或API限流导致的短暂失败，可以实现带有退避策略的重试机制（如指数退避）。
• 熔断降级：使用Resilience4j或Sentinel等组件，当AI服务连续失败或响应过慢时，自动熔断，避免拖垮整个应用，并可以降级到返回缓存答案或默认提示。
• 限流：对你自己的服务接口做限流，防止单个用户过度调用。

### 7.3 性能与成本

• Token消耗监控：每次调用记录消耗的Token数（响应中的usage字段），这直接关联成本。可以设置告警，当日消耗超过阈值时通知。
• 异步处理：对于非实时性的任务（如批量处理文档），务必使用@Async或消息队列进行异步处理，避免阻塞HTTP线程。
• 缓存：对于一些常见的、答案固定的问题（如“公司介绍”），可以将问答对缓存起来（用Redis），下次直接返回，节省Token。
• 连接池：如果你使用原生HTTP调用且并发量高，务必使用带连接池的HTTP客户端（如OkHttp、Apache HttpClient），并合理配置池大小。

走完以上所有步骤，你应该已经拥有了一个在JDK1.8环境下稳定、可用的DeepSeek-R1集成方案。技术选型没有银弹，关键是理解每种方案的优劣，并根据自己项目的团队能力、运维要求和未来规划做出合适的选择。我最开始用原生HTTP调用，虽然费点事，但心里特别踏实，后来在一些工具类项目里用了ai4j，也确实提升了开发效率。希望我的这些实战经验，能帮你少走弯路，顺利地把AI能力带到你的“老”项目里。