实战：在纯Java微服务中集成BERT模型，实现高效文本实体识别-育师

1. 为什么要在Java微服务里直接跑BERT模型？

如果你正在维护一个Java技术栈的微服务集群，每天要处理成千上万条用户输入的文本，比如新闻摘要、客服对话或者商品评论，需要从中快速、准确地提取人名、地名、机构名这些关键信息，你会怎么做？

几年前，一个很常见的做法是：单独部署一个用Python写的AI服务，专门跑BERT这类深度学习模型。你的Java服务收到请求后，再通过HTTP或者RPC去调用这个Python服务，拿到实体识别的结果。这个方案听起来挺合理，技术栈也专一，但我自己踩过坑。最大的问题就出在网络开销和系统复杂度上。每次调用，哪怕只是局域网内，那几毫秒甚至十几毫秒的网络延迟，在高并发场景下累积起来就非常可观了。更别提还要维护两套完全不同的技术栈、两套部署流程、两套监控告警，出了问题还得两边查日志，运维成本直接翻倍。

所以，我当时就在想，能不能让Java服务自己“吃掉”这个AI能力？让模型直接在JVM进程里跑起来，一次本地调用就搞定所有事情。这样不仅响应速度更快，架构也瞬间清爽了。经过一番折腾，我发现这条路完全走得通，而且用起来非常“香”。今天我就把自己这套在纯Java微服务里集成BERT模型，实现高效文本实体识别的实战经验，毫无保留地分享给你。整个过程不需要你懂Python，也不需要额外部署任何服务，就用你熟悉的Spring Boot和Maven，咱们一步步来。

2. 动手之前：模型、框架与核心思路

在开始敲代码之前，我们得先把几个关键的东西捋清楚，知道我们要用什么，以及为什么要这么选。

2.1 模型选择：为什么是RoBERTa？

做中文文本实体识别，BERT家族是首选。但原始的BERT模型有点“老”了，这里我推荐使用它的改进版——RoBERTa。简单来说，RoBERTa可以理解为“更大力出奇迹”的BERT，它去掉了BERT中“预测下一个句子”这个任务，用更大的批次和更多的数据训练了更长时间，在中文任务上通常表现更稳健。

对于我们这个实战场景，我选择的是uer/roberta-base-finetuned-cluener2020-chinese这个模型。这个名字有点长，我来拆解一下：

uer：这是模型作者或机构的名字。
roberta-base：基础版的RoBERTa模型。
finetuned-cluener2020-chinese：最关键的部分，说明这个模型已经在CLUENER 2020这个经典的中文命名实体识别数据集上微调过了。这意味着它已经学会了识别像人名、地名、组织机构、职位等10种常见的中文实体类型，我们拿过来就能用，省去了自己标注数据、训练模型的巨大成本。

你完全可以去Hugging Face社区找其他模型，但记住一个原则：优先选择在具体任务上（比如NER）微调过的模型，这比用原始的基础模型效果好得多。

2.2 框架选择：为什么是DJL？

要在Java里跑PyTorch模型，我们需要一个“桥梁”。这个领域有几个选择，比如Deep Java Library和ONNX Runtime。我最终选择了DJL，原因很直接：它对Hugging Face生态的支持最好，用起来最像在Python里操作。

DJL是亚马逊开源的一个Java深度学习库，它的设计目标就是让Java开发者能轻松使用各种深度学习框架（PyTorch, TensorFlow, MXNet）的模型。它的API设计得非常友好，加载模型、数据预处理、推理预测，整个流程非常顺畅。更重要的是，它提供了djl-huggingface-tokenizers这个模块，能直接加载和使用Hugging Face格式的分词器（Tokenizer），这解决了我们一大半的麻烦。你不用自己去实现BERT那套复杂的WordPiece分词逻辑了。

2.3 核心思路：从Python到Java的平滑迁移

整个集成的核心思路，其实就是在模仿Pythontransformers库的工作流程，但用Java代码来实现。主要分三步：

模型准备：在Python环境中，把Hugging Face上的模型下载到本地，并确保它包含Java所需的所有文件（特别是tokenizer.json）。
模型转换（可选但推荐）：将PyTorch的.bin模型文件，转换成更通用的.pt(TorchScript) 格式。这一步能提升Java端的加载和推理效率，也避免了潜在的兼容性问题。
Java集成：在Spring Boot项目中引入DJL，编写服务类加载本地模型和分词器，接收文本输入，输出结构化的实体信息。

听起来是不是没那么复杂了？接下来，我们就进入实战环节。

3. 第一步：在Python环境中准备模型文件

虽然我们的目标是纯Java，但第一步确实需要借助Python来完成一些“脏活累活”。别担心，这只是一次性的准备工作，就像你安装软件前需要先下载安装包一样。

3.1 下载模型到本地

首先，你需要一个安装了Python和transformers库的环境。打开你的命令行，用pip install transformers安装好。然后，创建一个Python脚本，比如叫download_model.py。

from huggingface_hub import hf_hub_download, HfApi import os # 1. 指定你要下载的模型ID model_id = "uer/roberta-base-finetuned-cluener2020-chinese" # 2. 指定模型要保存到本地的目录 target_dir = r"/your/local/path/bert_models/roberta-cluener" os.makedirs(target_dir, exist_ok=True) # 3. 定义模型通常需要的文件 files = ["config.json", "vocab.txt", "tokenizer.json", "special_tokens_map.json", "pytorch_model.bin"] api = HfApi() for file_name in files: try: print(f"正在下载: {file_name}") # 关键：使用 local_dir 参数将文件直接保存到指定目录，而不是缓存 hf_hub_download(repo_id=model_id, filename=file_name, local_dir=target_dir, local_dir_use_symlinks=False) print(f"保存成功") except Exception as e: # 有些模型可能缺少某些文件，比如 tokenizer.json，这很正常，我们下一步处理 print(f"下载 {file_name} 失败: {e}") print("模型文件下载完成！")

运行这个脚本，它会把模型从Hugging Face仓库拉取到你指定的target_dir目录下。去文件夹里看看，应该会有config.json,vocab.txt,pytorch_model.bin这几个核心文件。

3.2 生成缺失的tokenizer.json文件

很多模型（包括我们用的这个）默认不包含tokenizer.json文件，但DJL在加载分词器时非常依赖它。没有这个文件，Java这边就没办法正确分词。解决办法很简单，再用Python脚本生成一下。

from transformers import AutoTokenizer # 指定上一步模型保存的本地目录 model_local_path = r"/your/local/path/bert_models/roberta-cluener" print("正在从本地加载分词器并生成 tokenizer.json...") tokenizer = AutoTokenizer.from_pretrained(model_local_path) # 注意：legacy_format=False 确保生成新的json格式 tokenizer.save_pretrained(model_local_path, legacy_format=False) print(f"tokenizer.json 已生成在: {model_local_path}")

运行后，你的模型目录里就会多出一个tokenizer.json文件。至此，Python的使命就基本完成了。

3.3 （关键步骤）将模型转换为TorchScript格式

这是提升Java端体验非常关键的一步。原始的.bin文件是PyTorch的state_dict格式，它只保存了模型的权重参数。而TorchScript格式的.pt文件，保存的是整个模型的计算图。你可以把它理解为一个“冻结”的、优化过的、可以直接执行的计算程序。

在Java端使用TorchScript模型，加载速度更快，推理过程也更稳定。转换代码如下：

from transformers import BertTokenizerFast, BertForTokenClassification import torch model_dir = r"/your/local/path/bert_models/roberta-cluener" tokenizer = BertTokenizerFast.from_pretrained(model_dir) model = BertForTokenClassification.from_pretrained(model_dir) model.eval() # 将模型设置为评估模式 # 准备一个示例输入，用于追踪计算图。这个输入的格式必须和未来Java端的输入完全一致。 # 我们假设输入是已经按字切分的中文字符列表（这是中文NER的常见做法） example_text = "这是一个示例句子。" example_tokens = list(example_text) # 按字切分：['这', '是', '一', '个', '示', '例', '句', '子', '。'] inputs = tokenizer(example_tokens, return_tensors="pt", is_split_into_words=True) # 告诉分词器，传入的已经是切分好的token # 使用 torch.jit.trace 追踪模型的计算过程，生成TorchScript模型 # 注意：我们追踪的是模型对 (input_ids, attention_mask) 的推理过程 traced_model = torch.jit.trace(model, (inputs["input_ids"], inputs["attention_mask"]), strict=False) # 保存转换后的模型 traced_model.save("/your/local/path/bert_models/roberta-cluener/roberta-cluener-traced.pt") print("TorchScript 模型转换完成！")

执行完这一步，你就得到了一个roberta-cluener-traced.pt文件。这个文件，就是我们最终要在Java服务里加载的模型。

4. 第二步：构建你的Java微服务工程

好了，现在我们可以暂时告别Python，回到熟悉的Java世界了。我假设你已经有了一个Spring Boot项目，如果没有，用Spring Initializr创建一个就行，记得选择Java 11或以上版本。

4.1 引入依赖：关键配置详解

打开你的pom.xml文件，添加以下依赖。这里面的门道我详细说一下：

<properties> <!-- 建议指定一个较新的DJL版本 --> <djl.version>0.34.0</djl.version> </properties> <dependencyManagement> <dependencies> <!-- 引入DJL的BOM，管理所有DJL组件的版本 --> <dependency> <groupId>ai.djl</groupId> <artifactId>bom</artifactId> <version>${djl.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <!-- Spring Boot基础依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- DJL 核心API --> <dependency> <groupId>ai.djl</groupId> <artifactId>api</artifactId> </dependency> <!-- DJL PyTorch引擎：这是核心，让DJL能跑PyTorch模型 --> <dependency> <groupId>ai.djl.pytorch</groupId> <artifactId>pytorch-engine</artifactId> </dependency> <!-- PyTorch本地库：根据你的操作系统选择 --> <!-- 如果你是Linux/macOS，通常用这个 --> <dependency> <groupId>ai.djl.pytorch</groupId> <artifactId>pytorch-native-cpu</artifactId> <classifier>linux-x86_64</classifier> <!-- 或 osx-x86_64, osx-aarch64 (M芯片Mac) --> <version>2.7.1</version> <!-- 版本号最好与BOM保持一致 --> </dependency> <!-- 如果你是Windows，用这个 --> <!-- <dependency> <groupId>ai.djl.pytorch</groupId> <artifactId>pytorch-native-cpu</artifactId> <classifier>win-x86_64</classifier> <version>2.7.1</version> </dependency> --> <!-- HuggingFace分词器支持：至关重要！ --> <dependency> <groupId>ai.djl.huggingface</groupId> <artifactId>tokenizers</artifactId> </dependency> </dependencies>

重点说明：

pytorch-native-cpu：这个依赖包含了PyTorch的C++核心库（LibTorch）的Java绑定。DJL通过它来真正执行模型计算。你必须根据你的操作系统选择正确的classifier。如果选错了，应用启动时会报找不到本地库的错误。
版本对齐：尽量保证pytorch-engine和pytorch-native-cpu的版本匹配，使用BOM可以帮你管理。

4.2 编写模型服务类：NerService

这是整个功能的核心。我们将创建一个NerService，在Spring容器启动时加载模型，并提供实体识别方法。

首先，我们需要定义实体类，用来封装识别结果：

import lombok.AllArgsConstructor; import lombok.Data; @Data @AllArgsConstructor public class NerEntity { /** 识别出的实体文本，如“北京大学” */ private String entity; /** 实体类型，如“organization” */ private String type; /** 实体在原始文本中的起始位置（字符索引） */ private int start; /** 实体在原始文本中的结束位置（字符索引） */ private int end; }

接下来是重头戏，NerService的实现。我会逐段解释，你可以先通读，再复制到你的项目里。

import ai.djl.MalformedModelException; 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.ndarray.types.DataType; import ai.djl.ndarray.types.Shape; import ai.djl.translate.NoopTranslator; import ai.djl.translate.TranslateException; import ai.djl.huggingface.tokenizers.HuggingFaceTokenizer; import ai.djl.huggingface.tokenizers.Encoding; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import javax.annotation.PostConstruct; import java.io.IOException; import java.nio.file.Paths; import java.util.*; @Service @Slf4j public class NerService { private Model model; private HuggingFaceTokenizer tokenizer; // 标签映射表：将模型输出的数字ID映射为BIO标签 // 这个映射关系来自你下载的模型中的 config.json 文件里的 "id2label" 字段 private final Map<Integer, String> ID_2_LABEL = new HashMap<>(); public NerService() { // 初始化标签映射。这里以CLUENER数据集为例，你必须根据自己模型的config.json来修改！ ID_2_LABEL.put(0, "O"); ID_2_LABEL.put(1, "B-address"); ID_2_LABEL.put(2, "I-address"); ID_2_LABEL.put(3, "B-book"); ID_2_LABEL.put(4, "I-book"); ID_2_LABEL.put(5, "B-company"); ID_2_LABEL.put(6, "I-company"); ID_2_LABEL.put(7, "B-game"); ID_2_LABEL.put(8, "I-game"); ID_2_LABEL.put(9, "B-government"); ID_2_LABEL.put(10, "I-government"); ID_2_LABEL.put(11, "B-movie"); ID_2_LABEL.put(12, "I-movie"); ID_2_LABEL.put(13, "B-name"); ID_2_LABEL.put(14, "I-name"); ID_2_LABEL.put(15, "B-organization"); ID_2_LABEL.put(16, "I-organization"); ID_2_LABEL.put(17, "B-position"); ID_2_LABEL.put(18, "I-position"); ID_2_LABEL.put(19, "B-scene"); ID_2_LABEL.put(20, "I-scene"); } @PostConstruct public void init() throws IOException, MalformedModelException { log.info("开始加载NER模型和分词器..."); long start = System.currentTimeMillis(); // 1. 加载分词器 // 路径指向包含 tokenizer.json 的目录 String modelDir = "/your/local/path/bert_models/roberta-cluener"; tokenizer = HuggingFaceTokenizer.builder() .optTokenizerPath(Paths.get(modelDir)) .optAddSpecialTokens(true) // 自动添加[CLS]和[SEP] .build(); // 2. 加载TorchScript模型 model = Model.newInstance("ner-model", "PyTorch"); // 指定引擎为PyTorch // 加载我们之前转换好的 .pt 文件 model.load(Paths.get(modelDir).resolve("roberta-cluener-traced.pt")); long cost = System.currentTimeMillis() - start; log.info("NER模型加载完成，耗时 {} ms", cost); } /** * 实体识别主方法 * @param text 待识别的原始文本 * @return 识别出的实体列表 */ public List<NerEntity> predict(String text) throws TranslateException { // 使用NDManager管理DJL中的张量内存，try-with-resources确保自动关闭 try (NDManager manager = NDManager.newBaseManager()) { // 第一步：分词与编码 Encoding encoding = tokenizer.encode(text); long[] inputIds = encoding.getIds(); // token ID序列 long[] attentionMask = encoding.getAttentionMask(); // 注意力掩码 String[] tokens = encoding.getTokens(); // 分词后的token字符串（包含[CLS], [SEP]） log.debug("输入文本: {}", text); log.debug("Token序列: {}", Arrays.toString(tokens)); // 第二步：将Java数组转换为DJL NDArray（深度学习张量） // 形状为 [1, sequence_length]，1代表批处理大小为1 NDArray inputIdsArray = manager.create(inputIds, new Shape(1, inputIds.length), DataType.INT64); NDArray attentionMaskArray = manager.create(attentionMask, new Shape(1, attentionMask.length), DataType.INT64); // 第三步：模型推理 // NoopTranslator表示不对输入输出做额外处理，因为我们已手动处理好了 try (Predictor<NDList, NDList> predictor = model.newPredictor(new NoopTranslator())) { NDList input = new NDList(inputIdsArray, attentionMaskArray); NDList output = predictor.predict(input); // 执行预测 NDArray logits = output.singletonOrThrow(); // 获取模型输出 [1, seq_len, num_labels] // 第四步：后处理 - 取每个token概率最大的标签ID NDArray predictedLabelIds = logits.argMax(2); // 形状变为 [1, seq_len] long[] labelIdArray = predictedLabelIds.toLongArray(); // 转成Java数组 // 第五步：解码，将标签ID序列转换为实体对象 // 注意：tokens[0]是[CLS]，tokens[last]是[SEP]，我们需要跳过它们 String[] contentTokens = Arrays.copyOfRange(tokens, 1, tokens.length - 1); long[] contentLabelIds = Arrays.copyOfRange(labelIdArray, 1, labelIdArray.length - 1); List<NerEntity> entities = decodeEntities(contentTokens, contentLabelIds); log.debug("识别到 {} 个实体: {}", entities.size(), entities); return entities; } } } /** * 将标签ID序列解码为实体列表（BIO格式解码） * @param tokens 去除了[CLS]和[SEP]的token列表 * @param labelIds 对应的标签ID列表 * @return 实体列表 */ private List<NerEntity> decodeEntities(String[] tokens, long[] labelIds) { List<NerEntity> entities = new ArrayList<>(); StringBuilder currentEntity = new StringBuilder(); String currentType = null; int startIndex = -1; for (int i = 0; i < tokens.length && i < labelIds.length; i++) { String token = tokens[i]; // 根据标签ID获取BIO标签，如“B-organization” String label = ID_2_LABEL.getOrDefault((int) labelIds[i], "O"); if (label.startsWith("B-")) { // 遇到一个新的实体开始 // 如果之前已经有一个实体在构建中，先把它保存起来 if (currentType != null) { entities.add(new NerEntity(currentEntity.toString(), currentType, startIndex, i)); } // 开始构建新实体 currentEntity = new StringBuilder(token); currentType = label.substring(2); // 去掉“B-”前缀，得到实体类型 startIndex = i; } else if (label.startsWith("I-") && currentType != null) { // 判断是否是当前实体的延续 String innerType = label.substring(2); if (innerType.equals(currentType)) { currentEntity.append(token); // 中文按字分词，直接拼接 } else { // 如果I-标签类型与当前实体不符，结束当前实体 if (currentType != null) { entities.add(new NerEntity(currentEntity.toString(), currentType, startIndex, i)); currentType = null; } } } else { // 遇到“O”或其他情况，结束当前实体 if (currentType != null) { entities.add(new NerEntity(currentEntity.toString(), currentType, startIndex, i)); currentType = null; currentEntity.setLength(0); } } } // 循环结束后，检查是否还有一个实体未保存 if (currentType != null) { entities.add(new NerEntity(currentEntity.toString(), currentType, startIndex, tokens.length)); } return entities; } }

这段代码看起来长，但逻辑很清晰。init方法在服务启动时加载模型和分词器。predict方法是核心，它接收一个字符串，然后：

用分词器（Tokenizer）把句子变成模型能懂的ID序列。
把ID序列转换成DJL的张量（NDArray）。
调用模型进行推理，得到每个token属于各个实体标签的概率。
找出概率最大的标签，并通过decodeEntities方法，将“B-ORG, I-ORG, I-ORG, O, B-PER...”这样的标签序列，合并成“{entity: ‘北京大学’， type: ‘organization’}”这样的结构化实体。

4.3 创建REST接口对外提供服务

有了服务类，我们还需要一个控制器（Controller）来暴露HTTP API，这样其他服务才能调用。

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @RequestMapping("/api/ner") public class NerController { @Autowired private NerService nerService; @PostMapping("/extract") public ApiResponse<List<NerEntity>> extractEntities(@RequestBody TextRequest request) { try { List<NerEntity> entities = nerService.predict(request.getText()); return ApiResponse.success(entities); } catch (Exception e) { return ApiResponse.error("实体识别失败: " + e.getMessage()); } } // 简单的请求体封装 @Data public static class TextRequest { private String text; } // 统一的响应封装 @Data @AllArgsConstructor public static class ApiResponse<T> { private int code; private String message; private T data; public static <T> ApiResponse<T> success(T data) { return new ApiResponse<>(200, "success", data); } public static <T> ApiResponse<T> error(String msg) { return new ApiResponse<>(500, msg, null); } } }

现在，启动你的Spring Boot应用。如果一切顺利，你会在日志中看到“NER模型加载完成”的信息。

5. 第三步：测试、调优与生产化思考

服务跑起来了，我们先来试试效果，然后再聊聊怎么让它变得更健壮、更高效。

5.1 编写单元测试验证功能

我习惯先写个单元测试，快速验证核心逻辑。

import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import java.util.List; @SpringBootTest public class NerServiceTest { @Autowired private NerService nerService; @Test public void testNerPrediction() throws Exception { // 测试用例1：包含多种实体 String text1 = "据报道，苹果公司的首席执行官蒂姆·库克近日参观了位于上海浦东的富士康工厂。"; System.out.println("测试文本1: " + text1); List<NerEntity> entities1 = nerService.predict(text1); entities1.forEach(System.out::println); System.out.println("-----"); // 测试用例2：中文场景 String text2 = "李华和她的同事张明计划下周去杭州西湖旅游，他们预订了亚朵酒店。"; System.out.println("测试文本2: " + text2); List<NerEntity> entities2 = nerService.predict(text2); entities2.forEach(System.out::println); } }

运行测试，你应该能看到控制台打印出识别出的实体，例如{entity=‘苹果公司’， type=‘company’， start=4, end=8}。恭喜你，核心功能已经打通了！

5.2 性能调优与生产级考量

直接跑通只是第一步，要上线生产环境，我们还得考虑更多。

1. 模型加载与单例Predictor：我们之前在NerService里每次预测都new一个Predictor。这在测试时没问题，但在生产环境，Predictor的创建是有开销的。更优的做法是，在init方法里创建一个Predictor单例，并在predict方法中复用。但要注意，DJL的Predictor本身不是线程安全的。对于高并发场景，我们可以使用ThreadLocal或者一个简单的对象池来管理多个Predictor实例。

// 在NerService中增加一个Predictor池（简化示例） private final ThreadLocal<Predictor<NDList, NDList>> predictorThreadLocal = ThreadLocal.withInitial(() -> { try { return model.newPredictor(new NoopTranslator()); } catch (Exception e) { log.error("创建Predictor失败", e); return null; } }); public List<NerEntity> predictWithPool(String text) throws TranslateException { Predictor<NDList, NDList> predictor = predictorThreadLocal.get(); if (predictor == null) { throw new RuntimeException("Predictor不可用"); } try (NDManager manager = NDManager.newBaseManager()) { // ... 前面的编码和NDArray创建逻辑不变 ... NDList output = predictor.predict(input); // 使用从池中获取的predictor // ... 后面的解码逻辑不变 ... } // 注意：这里没有关闭predictor，它由ThreadLocal管理生命周期 }

2. 输入长度与批处理：BERT模型有最大输入长度限制（通常是512个token）。对于超长文本，你需要设计截断或分段策略。此外，我们的例子是单条推理。如果吞吐量要求高，可以考虑批处理，即一次传入多条文本。这需要你将多个文本的input_ids和attention_mask在批次维度上堆叠起来，模型推理效率会更高。DJL的NDArray和Translator接口对批处理有很好的支持。

3. 内存管理与监控：深度学习模型推理会消耗不少内存。务必关注JVM的堆内存和堆外内存（因为PyTorch本地库会使用堆外内存）使用情况。在Docker容器中部署时，要合理设置内存限制。同时，建议将推理耗时、请求量、错误率等指标接入你的监控系统（如Prometheus）。

4. 模型更新与热加载：模型可能需要定期更新。一个可行的方案是，将模型文件放在外部存储（如S3、NAS），服务启动时拉取，或者监听模型版本变化。实现热加载需要小心，可以在新模型加载验证成功后，通过原子引用切换NerService中持有的model和predictor实例。

5. 异常处理与降级：实体识别功能不应影响主业务链路。在Controller或Service层做好异常捕获，当模型服务不可用或超时时，要有降级策略，比如返回空列表，并记录日志告警，而不是让整个请求失败。

6. 踩坑记录与常见问题

这条路我走过，也踩过不少坑。这里列几个你可能遇到的，帮你提前避雷。

Q1: 启动时报no jni-pytorch in java.library.path或找不到本地库。A1:这是最常见的问题。99%的原因是pytorch-native-cpu依赖的classifier没选对。请严格按照你的操作系统（Linux/macOS/Windows）和架构（x86_64/aarch64）选择。还有一个可能是依赖没下载完整，试试mvn clean compile -U强制更新。

Q2: 模型推理结果全是乱码或标签不对。A2:首先，检查你的标签映射ID_2_LABEL是否和模型config.json里的id2label字段完全一致。其次，确认分词方式。我们的例子是按字分词（list(text)），如果你的模型是在不同分词数据上训练的，结果可能不准。确保Python转换脚本和Java服务中的文本预处理逻辑一致。

Q3: 服务运行一段时间后内存暴涨。A3:DJL的NDManager和NDArray管理着堆外内存。务必确保它们在try-with-resources语句块中，或者在使用后手动调用close()方法。Predictor和Model也要确保正确关闭。内存泄漏通常是因为这些资源没有及时释放。

Q4: 推理速度比预期慢很多。A4:首次推理会慢一些，因为涉及JIT编译。后续会快。如果一直很慢：