Java 做 AI 的定位:能做什么、不做什么
本篇要点:能判断一个 AI 需求该落在 Java 侧还是 Python 侧,并在 Spring AI、LangChain4j、原生 SDK 之间做出选择。 前置:只需 Java 17+ 与 Spring Boot 基础。本篇的代码只用来对比三种写法,真正的业务封装从《Spring AI 入门:ChatClient 与模型接入》开始。
1. 为什么需要它
2026 年 3 月,一个跑了四年的订单中台接到需求:客服提交工单时,系统自动写一段问题摘要,并按品类打标签。中台是八个 Spring Boot 服务、四十万行 Java、十二个人的团队,没有人在生产环境写过 Python。
第一次评审的结论是招一个算法工程师。三个月后人到了,他看完需求说的第一句话是:这个不需要 GPU,你们 Java 那边调个 HTTP 接口就行。
这句话值得停一下。招人的那三个月里,团队真正缺的不是算法,是把"模型在哪跑""模型怎么训""业务怎么用它"分开的能力。分不开,就会用训练的成本去解决推理的问题——买卡、搭环境、招人,最后发现要的只是三次 HTTP 调用和一套超时。
这一章要给的是一条边界线:哪些活 Java 干得好,哪些活硬塞给 Java 会变成维护负担,判断依据是什么。
2. 核心概念
2.1 训练和推理是两条流水线
训练(training)指用数据反复调整模型参数;推理(inference)指参数固定之后做一次前向计算,输入文本、输出文本。前者按周计、按 GPU 卡时计费,后者按毫秒和 token 计费。
类比:训练是钢厂,推理是五金加工厂。你要做一批门把手,不需要自己建钢厂,但你需要知道钢材的牌号、进货周期和次品率。
反例:把"我们要做 AI"翻译成"我们要训一个模型"。大多数企业的真实需求在推理侧,即把已有的模型接进业务。我经手的项目里这个比例是九成以上。
Java 在训练侧几乎没有位置。PyTorch 的算子、分布式训练框架、CUDA 绑定都在 Python 侧。JVM 上能跑前向计算的库是有的——DJL、ONNX Runtime 的 Java 绑定、Oracle 的 Tribuo,跑小规模训练也跑得动,但主流路径不在这里,招人也不好招。Java 在训练侧做的是调度:把任务提交到集群、读指标、做审批,而不是写训练循环。
2.2 应用集成层才是 Java 的主场
应用集成层(application integration layer)指业务系统和模型服务之间的那段代码:鉴权、超时、重试、限流、计量、审计、脱敏、降级、结果校验。它的职责不是让模型变聪明,而是让模型的不稳定不至于变成系统的不稳定。
类比:和十年前接支付网关一模一样。没人会因为"支付是金融科技"就把收银台换成 C++。
反例:把 chatModel.call(...) 直接写在 Controller 里,没有超时、没有计量、没有兜底。这不是集成,是把一个秒级抖动、按次计费的外部依赖直接引到自己的 Tomcat 线程池里。
这段恰好是 Java 攒了二十年的东西:连接池、事务、Resilience4j、Micrometer、Spring Security、统一异常处理。换一门语言你要重新搭一遍,在这里是现成的。
反过来说,如果一段代码里既没有超时也没有计量,那它还不算集成层,只是一次 HTTP 调用。判断标准很简单:模型服务挂三分钟,你的接口会不会跟着挂三分钟。
2.3 三条路线的差别在抽象层次
三条路线不是三个竞品,是三种抽象高度。选错的表现通常不是跑不起来,而是排查问题时不知道该看哪一层。
| 维度 | Spring AI | LangChain4j | 原生 SDK / HttpClient |
|---|---|---|---|
| Maven 坐标 | org.springframework.ai:spring-ai-starter-model-* | dev.langchain4j:langchain4j-* | com.openai:openai-java 或无依赖 |
| 版本基线(截至 2026 年 11 月) | 2.0.x,要求 Spring Boot 4.0.x / 4.1.x | 1.x 线,最低 JDK 17 | 各厂商各自发布 |
| 抽象层次 | ChatClient + Advisor 链 | AiServices 声明式接口 | 一个 HTTP 客户端 |
| 工具调用 | @Tool 注解,自动注册 | @Tool 注解 + AiServices | 自己实现 JSON 协议 |
| RAG | VectorStore + QuestionAnswerAdvisor | EmbeddingStore + ContentRetriever | 自己拼上下文 |
| MCP | 官方 starter | 有 langchain4j-mcp 模块 | 自己实现 JSON-RPC |
| 适合谁 | 已经在 Spring Boot 4 上 | Quarkus / Helidon / 纯 Java | 单点调用、排障基线 |
Spring AI 是 Spring 官方的模型接入层,容器里注入 ChatClient,配置走 application.yml,埋点接 Micrometer。它的版本约束要先记住:2.0.x 只支持 Spring Boot 4.0.x / 4.1.x。把 BOM 塞进 Boot 3 的项目里,报错不会告诉你版本不匹配,只会给你一个找不到的类。
LangChain4j 不绑定 Spring,用接口加注解声明一次调用(AiServices)。它在 Quarkus、Helidon 和纯 Java 服务里更自然,代价是那些 Spring 里现成的东西——配置绑定、健康检查、指标——要自己接线。
原生 SDK 指各厂商的官方 Java 包,或者干脆用 JDK 自带的 HttpClient 拼 JSON。零抽象,出问题一眼能看到 HTTP 状态码和原始响应体。
我现在的判断:已经在 Spring Boot 4 上的团队直接用 Spring AI;用 Quarkus 或 Helidon 的选 LangChain4j;整个项目只需要调一两个接口的,用 HttpClient 就够,引框架反而多一层要排查的东西。
不建议的是同一个项目里两种抽象各占一半。工具注册、advisor 顺序、重试策略各有一套语义,出故障时你要同时读两份文档,还要向两个社区提问。
2.4 该交给 Python 的四类活
自建推理(用 vLLM、SGLang 部署开源权重)、微调(LoRA 或全参)、GPU 批处理、文档解析与 OCR 这类重库依赖(PyMuPDF、MinerU 都在 Python 侧)。再算上评测集管理与实验跟踪,工具链也在那边更成熟。
一句话的边界:参数和 GPU 在哪,那边就是 Python;业务流程和事务在哪,那边就是 Java。中间用 HTTP 或 gRPC 连起来,契约写死。
2.5 上下文窗口是个成本问题
上下文窗口(context window)指一次请求里模型能看的 token 上限。token 是模型处理文本的最小单位,大约四分之三个英文单词,中文大致一字一 token。
窗口大小决定了你不能把整张工单的历史记录都塞进去。这看着是模型能力问题,落到工程上是预算问题:每多一千 token 输入,就是每千次请求多一笔钱,还要多几百毫秒的首字延迟。
算一遍更直观。一天八万张工单,如果每张多塞 800 token 的对话历史,一天多出来六千四百万 token 的输入。这个数字先别急着换算成钱,先换算成你团队的月度预算,再决定要不要做摘要压缩。
所以 Java 侧一定要有裁剪和缓存。《对话记忆与上下文工程》讲记忆与上下文,《可观测与护栏:成本、延迟与安全》讲计量与预算。这里先记住一句:窗口不是越大越好用,越大越要先算账。
图 1-1 从需求出发判断该走哪条路线,以及 Python 侧的边界画在哪里
如图 1-1 所示,除了最左边那条训练支路,其余几个终点最后都汇到同一个方框:Java 侧不论用哪种写法,交付的都是同一件事——集成层。这张图后面每一章都会回到这条主线上。
3. 动手实践
同一件事写两遍:把一段工单原文压成一句中文摘要。第一遍只用 JDK,第二遍用 LangChain4j。目的不是比优劣,是让你看清框架替你做了什么。
环境:JDK 17+,一个 OpenAI 兼容的端点和 key。DeepSeek、通义、智谱等厂商都提供 OpenAI 兼容的 /chat/completions,换 AI_BASE_URL 即可;具体型号、上下文长度与价格以各厂商官网为准(截至 2026 年 11 月)。
export AI_BASE_URL=https://api.deepseek.com
export AI_API_KEY=sk-xxxx
export AI_MODEL=deepseek-chat三行 export 执行完不会有任何输出,这是正常的;用 echo $AI_MODEL 能看到值就说明生效了。
第一版,零依赖。JDK 17 自带 java.net.http,这个类不需要任何 Maven 坐标。
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 不引任何第三方依赖,只为看清协议长什么样。
* 编译运行:javac RawCallDemo.java && java RawCallDemo
*/
public class RawCallDemo {
// 故意写糙:真实响应里字段顺序不固定,正则随时会崩
private static final Pattern CONTENT =
Pattern.compile("\"content\"\\s*:\\s*\"(.*?)\"", Pattern.DOTALL);
public static void main(String[] args) throws Exception {
String baseUrl = System.getenv().getOrDefault("AI_BASE_URL", "https://api.deepseek.com");
String apiKey = System.getenv("AI_API_KEY");
String model = System.getenv().getOrDefault("AI_MODEL", "deepseek-chat");
// 手写 JSON 就是"没有框架"的代价:转义、逗号、字段名全靠自己
String body = """
{
"model": "%s",
"messages": [
{"role": "system", "content": "你是客服工单助手,只输出一句中文摘要,不超过 30 字。"},
{"role": "user", "content": "收到的电饭煲内胆有划痕,要求换货,已拍照。"}
],
"temperature": 0.2
}
""".formatted(model);
HttpClient client = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(3))
.build();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/chat/completions"))
.timeout(Duration.ofSeconds(20)) // 少了这一行,故障时会挂住工作线程
.header("Content-Type", "application/json")
.header("Authorization", "Bearer " + apiKey)
.POST(HttpRequest.BodyPublishers.ofString(body))
.build();
long start = System.nanoTime();
HttpResponse<String> resp = client.send(request, HttpResponse.BodyHandlers.ofString());
long costMs = (System.nanoTime() - start) / 1_000_000;
System.out.println("HTTP " + resp.statusCode() + "," + costMs + " ms");
String raw = resp.body();
System.out.println("原始响应前 120 字符:" + raw.substring(0, Math.min(120, raw.length())));
Matcher m = CONTENT.matcher(raw);
System.out.println("摘要:" + (m.find() ? m.group(1) : "(未匹配到 content)"));
}
}运行结果:
HTTP 200,1462 ms
原始响应前 120 字符:{"id":"b7f3c1...","object":"chat.completion","created":1789...,"model":"deepseek-chat","choices":[{"index":0,"message":{"role":"assistant","content":"用户反馈电饭煲内胆划痕并申请换货,已附照片。"...
摘要:用户反馈电饭煲内胆划痕并申请换货,已附照片。耗时只作量级参考,随网络与排队变化,别当基准。
顺手做个实验:把 AI_API_KEY 改错一位再跑一次,你会拿到 HTTP 401 和一段 JSON 错误体。后面每一章的降级逻辑,起点都是这类非 200 响应。
第二版用 LangChain4j。Maven 坐标如下;1.23.0 是文档站当前的示例版本,动手前先看一眼 LangChain4j 文档站 的更新记录。
<!-- pom.xml:只需要这两个坐标 -->
<dependencies>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>1.23.0</version>
</dependency>
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-open-ai</artifactId>
<version>1.23.0</version>
</dependency>
</dependencies>import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import java.time.Duration;
public class LangChain4jDemo {
/** 一个接口就是一份调用契约,方法名和注解描述意图 */
interface TicketSummarizer {
@SystemMessage("你是客服工单助手,只输出一句中文摘要,不超过 30 字。")
@UserMessage("{{it}}")
String summarize(String rawText);
}
public static void main(String[] args) {
OpenAiChatModel model = OpenAiChatModel.builder()
.baseUrl(System.getenv().getOrDefault("AI_BASE_URL", "https://api.deepseek.com/v1"))
.apiKey(System.getenv("AI_API_KEY"))
.modelName(System.getenv().getOrDefault("AI_MODEL", "deepseek-chat"))
.temperature(0.2)
.timeout(Duration.ofSeconds(20))
.build();
TicketSummarizer summarizer = AiServices.builder(TicketSummarizer.class)
.chatModel(model)
.build();
String summary = summarizer.summarize("收到的电饭煲内胆有划痕,要求换货,已拍照。");
System.out.println("摘要:" + summary);
}
}运行结果:
摘要:电饭煲内胆有划痕,客户要求换货,已拍照。同一件事:三十行 HTTP 变成十来行声明。代价是多两个依赖,多一层你看不见的默认值——重试几次、超时多少、失败抛什么异常,都得另外查。
相关文章用 Spring AI 写第三遍。你会看到它在 Spring 项目里多出来的东西:配置绑定、advisor 链和埋点。
4. 常见误解
"Java 做 AI 比 Python 慢。" 模型不在你的进程里跑,那一跳是 HTTP。Java 多做的是序列化和网络,毫秒级;模型本身是秒级。真正决定延迟的是排队、上下文长度和输出长度。这句话只在自建推理的场合成立,而自建推理本来就该用 Python。
"用了框架就自动处理了模型的不稳定。" 框架给的是钩子:重试模板、advisor 插槽、结构化转换。哪些错误该重试、重试几次、失败返回什么,仍然要按业务写。《Spring AI 入门:ChatClient 与模型接入》会看到默认重试是 10 次、退避乘数 5,照抄等于把一次故障放大成几分钟。
"先做 PoC,治理上线前再补。" 计量和超时是最难后补的两样。它们要求每次调用都经过同一个入口,而 PoC 阶段最常见的写法是每个 Controller 各自 new 一个客户端。等到要补,你面对的是二十个调用点。
5. 小结
- 训练和推理是两条流水线。Java 的位置在推理侧,训练侧只做调度与审批。
- Java 承担的是应用集成层:鉴权、超时、重试、限流、计量、审计、脱敏、降级、结果校验。
- 三条路线按抽象层次分:Spring AI(需 Spring Boot 4.0.x / 4.1.x)、LangChain4j(不绑定 Spring,JDK 17+)、原生 SDK 或 HttpClient(零抽象)。
- 参数和 GPU 在 Python 侧,业务流程和事务在 Java 侧,中间用 HTTP 或 gRPC 定契约。
- 上下文窗口先算成本再做设计,裁剪和缓存是 Java 侧的活。
6. 相关文章
接着看[《Spring AI 入门:ChatClient 与模型接入》 Spring AI 入门:ChatClient 与模型接入](/guide/java-ai/spring-ai-getting-started.html):把上面第二条落到代码,用 Spring AI 建第一个 ChatClient,把同步调用、流式输出、多模型切换、Prompt 模板和降级写成一个能跑的 Spring Boot 服务。