企业官网建设流程全解析

1. 为什么Java开发者突然开始关注AI框架

这两年AI应用开发的热度不用我多说，但有一个现象挺有意思：以前搞Java后端的兄弟，聊的都是Spring Cloud、分库分表、JVM调优，现在群里时不时就有人甩出一句“这个模型怎么在Java里调”。原因很现实——大量企业的核心业务系统是Java写的，订单、风控、客服、报表这些链路全跑在JVM上，你不可能为了接一个AI能力就把整套架构推倒重来。所以“在Java里做AI”不是一个赶时髦的话题，而是一个实打实的工程落地问题。

我自己是从一个智能客服的需求开始接触Java AI框架的。当时的需求很朴素：把用户的问题做意图分类，再从知识库里检索答案，最后调一个大模型做润色。听起来简单，但真动手就发现，Python那边生态成熟得让人眼红，Java这边得自己挑框架、自己踩坑。折腾了大半年，前前后后试了五六个框架，有的适合做传统机器学习，有的专攻大模型编排，有的主打本地推理。这篇就把我认为目前Java生态里最值得关注的5个AI框架掰开揉碎讲清楚，包括它们各自解决什么问题、核心API长什么样、什么场景该选谁，以及我在实际项目里踩过的坑。

不管你是完全没接触过AI的Java后端，还是想从Python转过来看看Java这边有什么可用的，这篇应该都能给你一个比较完整的选型地图。我会尽量少讲虚的，多讲代码和参数，把每个框架的“脾气”说透。

2. 先搞清楚Java AI框架到底分几类

在具体讲框架之前，得先建立一个分类的认知，不然很容易把不同定位的东西放在一起比较，越比越乱。Java生态里的AI框架，按解决的问题大致可以分成三大类，这个分类是我自己总结的，不一定学术严谨，但对选型特别实用。

2.1 传统机器学习类：做分类、回归、聚类

这一类框架对标的是Python的scikit-learn，核心能力是特征工程、模型训练、模型评估。它们不涉及深度学习那套神经网络，主要用决策树、随机森林、SVM、KMeans这些算法。典型代表是Smile和Weka。这类框架的特点是轻量、可解释性强、训练速度快，适合数据量在几十万到几百万行、特征维度不高的场景，比如用户流失预测、信用评分、异常检测。

我个人的判断是，如果你的需求是“给一批结构化数据打个标签”，别一上来就想着上大模型，传统机器学习往往又快又准，还省算力。很多业务问题根本用不着神经网络。

2.2 深度学习类：跑神经网络推理

这一类对标的是PyTorch、TensorFlow，但在Java里主要是做推理而不是训练。典型代表是Deeplearning4j（简称DL4J）和DJL（Deep Java Library）。它们的核心价值是让你在JVM里直接加载训练好的模型文件，做前向推理，不用起一个Python服务。适合图像识别、语音处理、NLP里的文本分类这些场景。

这里有个关键认知：Java做深度学习，绝大多数情况是“训练在Python，推理在Java”。因为训练需要大量GPU资源和灵活的调试环境，Python生态更顺手；而推理要嵌入到线上服务里，Java的稳定性和并发能力更靠谱。所以这类框架的重点是推理性能、模型格式兼容性、内存管理。

2.3 大模型编排类：调LLM、做RAG、搭Agent

这是最近两年最火的一类，对标的是Python的LangChain、LlamaIndex。典型代表是LangChain4j和Spring AI。它们的核心能力是把大模型的调用、提示词模板、对话记忆、向量检索、工具调用这些东西编排起来，让你用几行代码就能搭一个RAG问答或者Agent应用。

这类框架的定位不是“训练模型”，而是“用好模型”。它们屏蔽了不同模型厂商API的差异，提供统一的抽象层。比如你今天用某个云端模型，明天想换成另一个，改个配置就行，业务代码不用动。对于绝大多数Java业务开发者来说，这一类框架是入门AI最直接的切入点。

把这三类分清楚之后，选型就简单了：先问自己要做的是“训练传统模型”“跑深度推理”还是“编排大模型”，答案不同，框架完全不同。下面我逐个展开。

3. 框架一：Smile——传统机器学习的瑞士军刀

Smile全称Statistical Machine Intelligence and Learning Engine，是我在Java里做传统机器学习第一个推荐的框架。它的API设计非常接近scikit-learn，如果你有Python机器学习的经验，上手几乎零成本。

3.1 核心能力与适用场景

Smile覆盖了分类、回归、聚类、降维、特征选择、模型评估等完整链路，算法数量在Java生态里算是相当全的。它还有一个很实用的能力是数据可视化，内置了绘图功能，做探索性数据分析的时候很方便。

适用场景我举几个真实的例子：电商里做商品推荐的前置召回、金融里做交易欺诈检测、运维里做日志异常聚类。这些场景的数据都是结构化的，特征明确，用Smile训练一个随机森林或者梯度提升树，效果往往比硬上深度学习好得多，而且模型可解释，业务方容易接受。

3.2 一个完整的分类任务代码示例

下面这段代码是我实际项目里用过的简化版，做的是用户是否会复购的二分类预测。数据用CSV加载，特征做标准化，然后训练一个随机森林。

import smile.classification.RandomForest; import smile.data.DataFrame; import smile.data.formula.Formula; import smile.io.Read; import smile.validation.CrossValidation; public class ChurnPredict { public static void main(String[] args) throws Exception { // 加载数据，最后一列是标签 DataFrame data = Read.csv("user_features.csv"); // 定义公式：label 由其他所有特征决定 Formula formula = Formula.lhs("repurchase"); // 交叉验证评估 CrossValidation cv = CrossValidation.classification( 5, data, formula, (f, d) -> RandomForest.fit(f, d) ); System.out.println("准确率: " + cv.avg().accuracy()); // 用全量数据训练最终模型 RandomForest model = RandomForest.fit(formula, data); // 预测新样本 double[] newUser = {25.0, 3.0, 1200.0, 0.8}; int pred = model.predict(newUser); System.out.println("预测结果: " + pred); } }

这段代码有几个点值得说。第一，Formula这个抽象很好用，它把“哪些列是特征、哪列是标签”用声明式的方式表达出来，比手动切分X和y清晰得多。第二，CrossValidation直接内置了交叉验证，不用自己写循环。第三，RandomForest.fit返回的模型对象可以直接predict，也能序列化保存。

3.3 实操心得与避坑

用Smile有几个坑我踩过。第一个是数据预处理，Smile对缺失值比较敏感，训练前一定要处理干净，要么填充要么删除，否则会直接抛异常。第二个是特征标准化，像SVM、KNN这类基于距离的算法，不做标准化效果会差很多，Smile提供了smile.feature.Scaling工具类，别偷懒。第三个是内存，Smile默认把数据全加载到内存，数据量超过几百万行就要考虑分批或者换框架。

提示：Smile的版本迭代比较快，不同版本API有变动，建议锁定一个稳定版本，别盲目升级。我用的2.x系列，API相对稳定。

还有一个经验：Smile的模型评估指标很全，但别只看准确率。类别不平衡的场景下，准确率会骗人，一定要看召回率、F1和AUC。我见过一个欺诈检测模型准确率99%，结果一看是把所有样本都预测成“正常”，这种模型上线就是灾难。

4. 框架二：Weka——老牌但依然能打

Weka是Java机器学习里的“活化石”，1993年就开始了，比很多读者的年龄都大。但别因为它老就小看它，Weka的算法库极其丰富，而且有一个图形化界面，做快速实验特别方便。

4.1 它和Smile的差异在哪

很多人问Smile和Weka怎么选。我的经验是：Weka胜在算法全、文档多、图形界面友好，适合做研究和快速验证；Smile胜在API现代、性能好、适合嵌入生产代码。Weka的API相对啰嗦一些，但它的Instances数据结构设计得很经典，处理ARFF格式数据非常顺手。

Weka还有一个杀手锏是它的实验器（Experimenter）和工作流（Knowledge Flow）功能，可以批量跑算法对比，做模型选型的时候能省不少事。如果你需要向团队证明“为什么选这个算法”，用Weka跑一组对比实验，出个表格，很有说服力。

4.2 用Weka做算法对比的实操

下面这段代码演示如何用Weka批量评估多个分类器，这是我做模型选型时的标准动作。

import weka.classifiers.Classifier; import weka.classifiers.bayes.NaiveBayes; import weka.classifiers.trees.J48; import weka.classifiers.functions.Logistic; import weka.core.Instances; import weka.core.converters.ConverterUtils.DataSource; import weka.classifiers.Evaluation; public class ModelCompare { public static void main(String[] args) throws Exception { DataSource source = new DataSource("data.arff"); Instances data = source.getDataSet(); data.setClassIndex(data.numAttributes() - 1); Classifier[] models = { new J48(), // 决策树 new NaiveBayes(), // 朴素贝叶斯 new Logistic() // 逻辑回归 }; for (Classifier model : models) { Evaluation eval = new Evaluation(data); eval.crossValidateModel(model, data, 10, new java.util.Random(1)); System.out.printf("%s -> 准确率: %.4f, F1: %.4f%n", model.getClass().getSimpleName(), eval.pctCorrect() / 100, eval.fMeasure(1)); } } }

这段代码的价值在于，它把“选哪个算法”这个决策变成了数据驱动的过程。我一般会跑五六个算法，看哪个在验证集上综合表现最好，再决定用哪个。别凭直觉选算法，数据会告诉你答案。

4.3 注意事项

Weka最大的问题是内存。它的Instances对象把整个数据集加载到内存，而且对象开销比较大，几十万行数据就可能吃满几个G。所以Weka适合中小规模数据，大数据量要么采样，要么换Smile或者Spark MLlib。

另外Weka的ARFF格式虽然经典，但实际项目里数据大多是CSV或者数据库，需要转换。Weka提供了转换器，但字段类型、缺失值标记这些细节容易出错，转换后一定要检查一遍。

注意：Weka的图形界面适合探索，但生产环境一定要用API，别把GUI当生产工具。我见过有人把Weka的GUI跑在服务器上，结果内存泄漏把机器搞挂了。

5. 框架三：Deeplearning4j——JVM上的深度学习

DL4J是我认为Java深度学习里最“重”的一个框架，功能全、生态完整，但学习曲线也陡。它的定位是让你在JVM上完整地做深度学习，从数据管道到模型训练到推理，全流程都能在Java里完成。

5.1 核心架构与ND4J

DL4J的底层是ND4J，这是它的张量计算库，相当于Java版的NumPy。ND4J提供了多维数组、矩阵运算、GPU加速这些能力。理解ND4J是理解DL4J的前提，因为DL4J的模型输入输出都是ND4J的INDArray对象。

DL4J的模型定义用MultiLayerConfiguration，可以搭全连接、卷积、循环等各种网络。它还支持从Keras导入模型，这个功能很实用——你可以在Python里用Keras训练，导出h5文件，然后在Java里加载推理。

5.2 加载Keras模型做推理的完整流程

这是我最常用的模式，因为训练在Python做，Java只负责推理。下面演示如何加载一个Keras导出的模型。

import org.deeplearning4j.nn.multilayer.MultiLayerNetwork; import org.deeplearning4j.util.ModelSerializer; import org.nd4j.linalg.api.ndarray.INDArray; import org.nd4j.linalg.factory.Nd4j; public class KerasInference { public static void main(String[] args) throws Exception { // 加载Keras导出的模型 MultiLayerNetwork model = ModelSerializer.restoreMultiLayerNetwork( "keras_model.zip" ); // 构造输入，形状要和训练时一致 INDArray input = Nd4j.create(new float[]{0.5f, 0.3f, 0.2f}, new int[]{1, 3}); // 推理 INDArray output = model.output(input); System.out.println("预测输出: " + output); // 取最大概率的类别 int predClass = Nd4j.argMax(output, 1).getInt(0); System.out.println("预测类别: " + predClass); } }

这里的关键是输入的形状必须和训练时完全一致。我踩过一个坑：Python里输入是(batch, features)，Java里如果忘了加batch维度，直接传一维数组，会报维度不匹配。Nd4j.create的第二个参数new int[]{1, 3}就是显式指定batch为1。

5.3 性能调优与内存管理

DL4J的性能调优有几个关键点。第一是后端选择，ND4J支持CPU和GPU后端，GPU后端需要额外的依赖配置，配置对了推理速度能快十几倍。第二是内存管理，DL4J用的是堆外内存，INDArray不占JVM堆，但需要配置好ND4J的内存参数，否则容易OOM。

第三是模型加载，restoreMultiLayerNetwork每次调用都会重新加载，生产环境一定要做成单例，启动时加载一次，后续复用。我见过有人在每个请求里都加载模型，QPS直接掉到个位数。

提示：DL4J的依赖包比较大，打包出来的jar动辄几百兆，做微服务的时候要考虑镜像体积。可以考虑把模型文件外置，通过配置加载。

DL4J适合什么场景？我的判断是：如果你需要在JVM里做复杂的深度学习推理，而且对性能有要求，DL4J是首选。但如果只是简单调用大模型API，用DL4J就是杀鸡用牛刀，LangChain4j更合适。

6. 框架四：DJL——更现代的深度学习推理

DJL是亚马逊开源的深度学习库，定位和DL4J类似，但设计更现代、API更简洁。它最大的特点是“引擎无关”，底层可以接PyTorch、TensorFlow、MXNet等多个引擎，你写一套代码，换引擎不用改业务逻辑。

6.1 引擎无关的设计哲学

DJL的抽象层次是这样的：最上层是Model和Predictor，中间是Engine，底层是具体的深度学习引擎。你通过Criteria来构建模型，指定引擎、模型路径、输入输出类型，然后拿到Predictor做推理。

这种设计的好处是解耦。比如你一开始用PyTorch引擎，后来发现某个模型只有TensorFlow版本，换个引擎配置就行，业务代码不动。这在多模型、多团队协作的场景下特别有价值。

6.2 用DJL加载PyTorch模型的实操

下面演示用DJL加载一个PyTorch的TorchScript模型做推理。

import ai.djl.Model; import ai.djl.inference.Predictor; import ai.djl.ndarray.NDArray; import ai.djl.ndarray.NDList; import ai.djl.ndarray.NDManager; import ai.djl.translate.Translator; import ai.djl.translate.TranslatorContext; public class DJLInference { public static void main(String[] args) throws Exception { try (Model model = Model.newInstance("my_model", "PyTorch")) { model.load(java.nio.file.Paths.get("model.pt")); Translator<float[], float[]> translator = new Translator<>() { @Override public NDList processInput(TranslatorContext ctx, float[] input) { NDManager manager = ctx.getNDManager(); NDArray array = manager.create(input); return new NDList(array); } @Override public float[] processOutput(TranslatorContext ctx, NDList list) { return list.singletonOrThrow().toFloatArray(); } }; try (Predictor<float[], float[]> predictor = model.newPredictor(translator)) { float[] result = predictor.predict(new float[]{0.5f, 0.3f, 0.2f}); System.out.println("推理结果: " + java.util.Arrays.toString(result)); } } } }

这段代码的核心是Translator，它负责Java数据类型和NDArray之间的转换。DJL把预处理、后处理的逻辑都放在Translator里，业务代码只关心输入输出，这个设计比DL4J清晰。

6.3 DJL vs DL4J 怎么选

这两个框架经常被拿来比较，我的经验是这样：DJL的API更现代、引擎支持更灵活、社区更活跃，新项目优先选DJL；DL4J的历史更久、中文资料相对多、和Hadoop/Spark生态集成更好，如果团队已经在用这些大数据组件，DL4J可能更顺。

性能上两者差距不大，都支持GPU加速。DJL在模型格式兼容性上更好，PyTorch、TensorFlow、ONNX都能接；DL4J主要是Keras和它自己的格式。

注意：DJL的引擎依赖需要单独引入，比如用PyTorch引擎就要加pytorch-engine和对应的native库。native库和操作系统相关，跨平台部署的时候要特别注意，别在开发机跑得好好的，上了服务器就报找不到库。

7. 框架五：LangChain4j——大模型应用编排的首选

前面四个框架都是“传统AI”范畴，LangChain4j是真正面向大模型时代的。它的定位是帮你把大模型、向量库、工具调用这些东西编排起来，用Java写出RAG、Agent这类应用。

7.1 核心抽象：ChatLanguageModel与EmbeddingModel

LangChain4j最核心的两个抽象是ChatLanguageModel和EmbeddingModel。前者负责对话生成，后者负责把文本转成向量。这两个抽象屏蔽了不同厂商的差异，你换模型只需要换实现类。

它支持的模型接入方式很全，云端API、本地部署的模型都能接。这种统一抽象的价值在于，你可以在开发阶段用便宜的模型，生产环境换更强的模型，代码几乎不用改。

7.2 搭一个RAG问答的完整代码

RAG是LangChain4j最典型的应用场景。下面演示一个完整的检索增强问答流程。

import dev.langchain4j.model.chat.ChatLanguageModel; import dev.langchain4j.model.openai.OpenAiChatModel; import dev.langchain4j.data.document.Document; import dev.langchain4j.data.document.splitter.DocumentSplitters; import dev.langchain4j.data.segment.TextSegment; import dev.langchain4j.store.embedding.EmbeddingStore; import dev.langchain4j.store.embedding.inmemory.InMemoryEmbeddingStore; import dev.langchain4j.retriever.EmbeddingStoreRetriever; import dev.langchain4j.chain.ConversationalRetrievalChain; public class RagDemo { public static void main(String[] args) { // 1. 初始化对话模型 ChatLanguageModel chatModel = OpenAiChatModel.builder() .apiKey(System.getenv("API_KEY")) .modelName("gpt-4o-mini") .build(); // 2. 初始化向量存储 EmbeddingStore<TextSegment> store = new InMemoryEmbeddingStore<>(); // 3. 加载文档并切分 Document doc = Document.from("你的知识库文本内容..."); var segments = DocumentSplitters.recursive(500, 50).split(doc); // 4. 向量化并存入 var embeddingModel = new AllMiniLmL6V2EmbeddingModel(); for (TextSegment seg : segments) { store.add(embeddingModel.embed(seg).content(), seg); } // 5. 构建检索器 var retriever = EmbeddingStoreRetriever.from(store, embeddingModel, 3); // 6. 构建问答链 var chain = ConversationalRetrievalChain.builder() .chatLanguageModel(chatModel) .retriever(retriever) .build(); // 7. 提问 String answer = chain.execute("你的问题是什么？"); System.out.println(answer); } }

这段代码把RAG的核心链路走通了：文档切分、向量化、存储、检索、生成。每一步都有讲究，我逐个说。

文档切分这里用的是递归切分，500是每段最大字符数，50是重叠字符数。重叠是为了避免语义被切断，比如一句话正好跨在两个段之间，有重叠就能保证至少有一段包含完整语义。这个参数要根据文档特点调，技术文档可以小一点，叙事性文档要大一点。

检索数量3表示每次取最相似的3段喂给模型。取太多会超出上下文窗口，取太少可能漏掉关键信息。一般3到5比较合适。

7.3 提示词模板与对话记忆

LangChain4j的提示词模板功能很实用，可以把变量注入到提示词里。对话记忆则让多轮对话成为可能，它会自动把历史对话带上。

import dev.langchain4j.model.input.PromptTemplate; import java.util.Map; PromptTemplate template = PromptTemplate.from( "你是一个{{role}}，请用{{style}}的风格回答：{{question}}" ); var prompt = template.apply(Map.of( "role", "技术支持工程师", "style", "简洁专业", "question", "如何重置密码？" ));

对话记忆用MessageWindowChatMemory，可以限制保留多少轮历史，避免上下文无限增长。

7.4 实操避坑指南

用LangChain4j有几个坑必须提醒。第一是API Key的管理，千万别硬编码在代码里，用环境变量或者配置中心。第二是向量库的选择，开发阶段用内存向量库没问题，生产环境数据量大了必须换成专业的向量数据库，否则检索性能会崩。第三是成本控制，大模型调用是按token计费的，RAG里检索出来的内容越多，token消耗越大，要在效果和成本之间找平衡。

提示：LangChain4j的版本更新很快，API偶有变动，建议关注官方文档的迁移指南。我遇到过升级版本后EmbeddingStoreRetriever的构造方法变了，编译不过的情况。

还有一个经验：RAG的效果很大程度上取决于文档质量，而不是模型。文档切分得合理、内容准确，比换一个更贵的模型提升更大。我做过对比，同样的模型，优化切分策略后准确率提升了将近20个百分点。

8. 五个框架横向对比与选型建议

讲了这么多，最后给一个横向对比表，方便你快速决策。

选型的决策路径我建议这样走：先明确你要解决的是“传统ML”“深度推理”还是“大模型编排”。传统ML优先Smile，需要算法对比和快速验证加Weka；深度推理新项目选DJL，已有Spark/Hadoop生态选DL4J；大模型应用直接上LangChain4j。

实际项目里这几个框架不是互斥的，经常组合使用。比如我用Smile做用户画像的初步分类，用LangChain4j做智能问答，两者通过消息队列解耦。框架是工具，别为了用而用。

9. 我在实际项目里踩过的那些坑

最后分享几个跨框架的通用经验，都是真金白银换来的。

第一个坑是依赖冲突。这几个框架都依赖大量的第三方库，尤其是ND4J和DJL的native库，很容易和项目里已有的依赖打架。我的做法是用Maven的dependencyManagement统一管理版本，遇到冲突用mvn dependency:tree排查，别硬扛。

第二个坑是模型文件的管理。模型文件动辄几百兆，别塞进代码仓库，用对象存储或者制品库管理，通过配置加载。我见过有人把模型文件提交到Git，仓库直接膨胀到几个G，clone一次要半小时。

第三个坑是并发安全。很多模型对象不是线程安全的，比如DL4J的MultiLayerNetwork，多线程同时调用output可能出问题。生产环境要么加锁，要么用对象池，要么每个线程一个实例。这个坑不踩一次很难意识到，但踩了就是线上事故。

第四个坑是监控。AI服务的监控和普通服务不一样，除了QPS、延迟，还要监控模型推理耗时、输入数据分布、输出置信度。输入数据分布漂移是模型效果下降的早期信号，早点发现能避免很多问题。

第五个坑是版本锁定。AI框架迭代快，今天能跑的代码明天可能就编译不过。生产项目一定要锁定版本，升级前先在测试环境充分验证。我吃过一次亏，一个小版本升级导致推理结果全错，排查了两天才发现是默认参数变了。

这些经验不一定全面，但每一条都是我实际遇到过的。Java做AI确实比Python麻烦一些，但生态在快速成熟，上面这五个框架基本能覆盖大部分场景。选对框架、理解原理、注意工程细节，Java开发者一样能把AI应用做得又稳又好。