企业官网建设流程全解析

在《我的世界》Java 版 1.20.1 的 Fabric 生态环境里，玩家对模组的需求已经从“加几个物品”变成了“让服务器更有生命力”。于是“我的世界 JAVA1.20.1 fabric 的 aichatbot 模组”这类项目开始出现：它让服务器里的机器人可以自动回复玩家消息，甚至能根据上下文聊上一阵，而不是只回复提前写死的固定文本。

这类模组的核心思路并不神秘：在 Minecraft 客户端或服务端捕获聊天事件，把玩家消息转发给一个 AI 接口，再把 AI 返回的文本塞回聊天框。难点在于 Fabric 的事件监听、异步任务调度、HTTP 请求处理、配置管理和游戏线程安全。这篇文章就从零开始，带你实现一个可运行的 aichatbot 模组，并解释每一步背后的设计逻辑。

1. 先理解 Fabric 模组里聊天机器人要解决什么问题

1.1 聊天机器人模组的核心链路

在 Minecraft 服务端里，玩家发送一条聊天消息时，会经过ServerPlayNetworkHandler的消息处理逻辑。如果想让 AI 代替服务器管理员回复玩家，最简单的做法是监听玩家聊天事件，截获消息内容，调用远程 AI 接口，再把结果通过服务端广播出去。

整条链路大致如下：

1. 玩家在游戏里输入聊天内容并发送。
2. 服务端触发ServerMessageEvents.CHAT_MESSAGE事件。
3. 模组代码拿到消息内容和发送者信息。
4. 模组把消息封装成请求体，通过 HTTP 调用 AI 接口。
5. 模组收到 AI 回复后，在服务端调用广播方法。
6. 所有在线玩家看到机器人的回复。

这个链路里有两个关键选择：事件在哪个端触发，以及如何处理阻塞网络请求。网络请求不能直接放在游戏主线程里执行，否则玩家一聊天，整个服务器就卡住。因此必须用异步任务。

1.2 为什么选择 Fabric 而不是 Forge

Fabric 在 1.20.1 版本下轻量、启动快，模组加载机制清晰，API 更新节奏也更贴近新版本。对于只想在服务端加一个“聊天机器人”的玩家，Fabric 的fabric-api已经提供了事件注册入口，不需要修改游戏核心类。

从开发角度讲，Fabric 提供了ServerMessageEvents这样的高层 API，开发者不需要了解 Mojang 网络协议的每一个细节。下面用到的ServerPlayNetworking和ServerMessageEvents都在 Fabric API 覆盖范围内。

1.3 这个项目适合哪些场景

适合场景包括：

• 玩家在服务器里问“这个服务器有没有领地插件”，AI 机器人能根据维护者配置的简介回答。
• 服务器管理员不在线时，AI 机器人临时维护基础秩序。
• 给玩家的单人存档增加一个聊天伙伴，提升游玩趣味性。
• 在模组开发学习中，作为“事件监听 + HTTP 请求 + 配置管理 + 线程调度”的综合练习。

需要注意，这个模组本质上是一个客户端到服务端再到 AI 服务的转发器。是否适合生产环境，取决于你选择的 AI 接口的稳定性、频率限制、内容安全策略和成本。

注意：把聊天消息发送给第三方 AI 接口前，要确认消息里可能包含玩家隐私、服务器内部信息或敏感内容。生产环境必须加脱敏、频率限制和审计日志。

2. 环境准备：JDK、Fabric 开发环境和 1.20.1 依赖版本

2.1 开发环境清单

开发 Fabric 模组通常使用官方模板仓库生成项目骨架。这里先列出一套可以跑通的环境参考：

如果你本地还没有 JDK，建议先安装 JDK 17，并且确认java -version输出包含 17 字样。不要在 JDK 21 上直接套用模板，除非你明确知道怎么处理 Gradle 和 Loom 兼容性。

2.2 生成 Fabric 模组项目骨架

官方推荐使用 Fabric 的在线模板生成器。打开官方模板生成页面，填写模组名称和包名后，下载 zip 解压到本地。这里假设生成的包名是com.example.aichatbot，模组名称是aichatbot。

解压后，项目结构大致如下：

aichatbot/ ├── build.gradle ├── gradle.properties ├── settings.gradle ├── gradle/ │ └── wrapper/ │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties └── src/ └── main/ ├── java/ │ └── com/example/aichatbot/ │ ├── AIChatBotMod.java │ └── ... └── resources/ ├── fabric.mod.json └── ...

关键修改文件是gradle.properties。把版本号对准 1.20.1：

minecraft_version=1.20.1 yarn_mappings=1.20.1+build.10 loader_version=0.15.11 # Fabric API 版本要和 1.20.1 匹配 fabric_version=0.92.2+1.20.1

2.3 确认fabric.mod.json配置

在src/main/resources/fabric.mod.json里，至少要有入口点和依赖声明。

{ "schemaVersion": 1, "id": "aichatbot", "version": "1.0.0", "name": "AI Chat Bot", "description": "A simple AI chatbot mod for Minecraft 1.20.1 Fabric.", "authors": ["yourname"], "contact": {}, "license": "MIT", "icon": "assets/aichatbot/icon.png", "environment": "*", "entrypoints": { "server": [ "com.example.aichatbot.AIChatBotMod" ], "client": [ "com.example.aichatbot.AIChatBotModClient" ] }, "depends": { "fabricloader": ">=0.15.0", "minecraft": "~1.20.1", "java": ">=17", "fabric-api": "*" } }

这里要注意environment字段设置为*，表示客户端和服务端都能加载。如果只在服务端运行，可以只保留server入口点，并把environment改成server。

模板生成后，先用一次构建命令确认环境能通：

./gradlew build

如果没有报错，说明 JDK、Gradle 和依赖都正常。第一次构建会下载大量依赖，建议在网络稳定时执行。

3. 编写核心事件监听：捕获玩家聊天并触发 AI 请求

3.1 事件注册入口

在AIChatBotMod.java里注册聊天事件。Fabric 的ServerMessageEvents.CHAT_MESSAGE可以在玩家发送消息时被回调。回调参数包括消息对象、发送者信息以及消息是否被系统取消。

package com.example.aichatbot; import net.fabricmc.api.ModInitializer; import net.fabricmc.fabric.api.message.v1.ServerMessageEvents; import net.minecraft.server.network.ServerPlayerEntity; import net.minecraft.text.Text; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class AIChatBotMod implements ModInitializer { public static final String MOD_ID = "aichatbot"; public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); @Override public void onInitialize() { ServerMessageEvents.CHAT_MESSAGE.register((message, sender, params) -> { String raw = message.getContent().getString(); String senderName = sender != null ? sender.getName().getString() : "unknown"; LOGGER.info("Chat message from {}: {}", senderName, raw); // 触发 AI 异步回复 ChatBotHandler.handleMessage(sender, senderName, raw); }); LOGGER.info("AI Chat Bot mod initialized."); } }

这里有两个细节需要注意。第一，ServerMessageEvents.CHAT_MESSAGE的注册位置在服务端初始化阶段，因此AIChatBotMod应该作为 server 入口点加载。第二，消息内容不是直接取字符串，而是通过message.getContent().getString()获取普通文本内容。如果消息包含 JSON 格式的富文本，可能需要更复杂的解析。

3.2 异步处理不能阻塞游戏主线程

Minecraft 服务端的主循环对性能要求很高。如果在聊天事件回调里直接执行 HTTP POST 请求，服务端每收到一条聊天消息就会同步等待 AI 接口返回，通常需要几百毫秒甚至几秒，这会直接造成整个服务器卡顿。

正确做法是使用独立的线程池。Java 里可以使用CompletableFuture.runAsync，把网络请求放到公共线程池，等 AI 返回后再切换回游戏线程执行广播。

package com.example.aichatbot; import net.minecraft.server.network.ServerPlayerEntity; import net.minecraft.server.MinecraftServer; import net.minecraft.text.Text; import java.util.concurrent.CompletableFuture; public class ChatBotHandler { private static MinecraftServer currentServer; public static void setServer(MinecraftServer server) { currentServer = server; } public static void handleMessage(ServerPlayerEntity sender, String senderName, String raw) { CompletableFuture.runAsync(() -> { try { String reply = AiClient.requestReply(senderName, raw); if (reply == null || reply.isBlank()) { return; } // 回到游戏线程广播 if (currentServer != null) { currentServer.execute(() -> { currentServer.getPlayerManager().broadcast( Text.literal("[AI] " + reply), false ); }); } } catch (Exception e) { AIChatBotMod.LOGGER.error("Failed to handle AI chat request", e); } }); } }

这里的关键点是currentServer.execute(...)。Minecraft 的MinecraftServer.execute会把任务提交到服务端主线程执行，所以最终广播操作是线程安全的。如果不这样做，直接在线程池里调用broadcast，很可能触发并发修改异常。

还需要在服务端启动和关闭时维护currentServer。可以在AIChatBotMod里监听服务器生命周期事件，也可以在专用入口类里注册ServerLifecycleEvents.SERVER_STARTED和SERVER_STOPPING。

package com.example.aichatbot; import net.fabricmc.api.ModInitializer; import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents; public class AIChatBotMod implements ModInitializer { @Override public void onInitialize() { ServerLifecycleEvents.SERVER_STARTED.register(server -> { ChatBotHandler.setServer(server); }); ServerLifecycleEvents.SERVER_STOPPING.register(server -> { ChatBotHandler.setServer(null); }); // 其他初始化逻辑 } }

3.3 权限和触发条件

不是所有玩家消息都应该转发给 AI。如果不想让机器人在服务器聊天频道里刷屏，可以加一个触发词，比如只有以!ai开头的消息才交给 AI 回复。这样既能控制成本，也能避免玩家在普通聊天里被机器人打断。

public static void handleMessage(ServerPlayerEntity sender, String senderName, String raw) { if (!raw.startsWith("!ai ")) { return; } String prompt = raw.substring(4); CompletableFuture.runAsync(() -> { // ... }); }

在正式服务器里，还建议增加“冷却时间”和“频率限制”。比如同一个玩家 10 秒内只能触发一次 AI 回复，避免玩家连续刷屏导致 AI 接口费用飙升或服务被限流。

4. 接入 AI 接口：HTTP 请求、JSON 解析和配置管理

4.1 请求体设计

为了让示例可运行，这里使用 OpenAI 兼容的请求格式。很多国内大模型服务也提供 OpenAI 风格的接口，因此这套示例结构可以复用。

请求地址通常是：

POST https://api.example.com/v1/chat/completions

请求头：

Content-Type: application/json Authorization: Bearer YOUR_API_KEY

请求体：

{ "model": "gpt-3.5-turbo", "messages": [ { "role": "system", "content": "你是一个《我的世界》服务器助手，回答要简洁、有趣、符合游戏设定。" }, { "role": "user", "content": "玩家 Steve 说：服务器怎么传送到 spawn？" } ], "max_tokens": 200, "temperature": 0.7 }

在设计 system prompt 时，要让 AI 明确自己的身份和边界。不要只是简单转发玩家消息，而要告诉它这是 Minecraft 服务器场景，避免 AI 输出过长的非游戏内容。

4.2 Java HTTP 客户端代码

JDK 自带的java.net.http.HttpClient足够完成这个功能，不需要额外引入 OkHttp。下面是一个最小实现。

package com.example.aichatbot; import com.google.gson.JsonArray; import com.google.gson.JsonObject; import com.google.gson.JsonParser; import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.time.Duration; public class AiClient { private static final HttpClient HTTP_CLIENT = HttpClient.newBuilder() .connectTimeout(Duration.ofSeconds(10)) .build(); public static String requestReply(String senderName, String prompt) throws Exception { String apiKey = AIConfig.getApiKey(); String apiUrl = AIConfig.getApiUrl(); String model = AIConfig.getModel(); JsonObject systemMsg = new JsonObject(); systemMsg.addProperty("role", "system"); systemMsg.addProperty("content", AIConfig.getSystemPrompt()); JsonObject userMsg = new JsonObject(); userMsg.addProperty("role", "user"); userMsg.addProperty("content", "玩家 " + senderName + " 说：" + prompt); JsonArray messages = new JsonArray(); messages.add(systemMsg); messages.add(userMsg); JsonObject body = new JsonObject(); body.addProperty("model", model); body.add("messages", messages); body.addProperty("max_tokens", AIConfig.getMaxTokens()); body.addProperty("temperature", AIConfig.getTemperature()); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(apiUrl)) .timeout(Duration.ofSeconds(30)) .header("Content-Type", "application/json") .header("Authorization", "Bearer " + apiKey) .POST(HttpRequest.BodyPublishers.ofString(body.toString())) .build(); HttpResponse<String> response = HTTP_CLIENT.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() != 200) { throw new RuntimeException("AI API error, status: " + response.statusCode() + ", body: " + response.body()); } return parseReply(response.body()); } private static String parseReply(String responseBody) { JsonObject root = JsonParser.parseString(responseBody).getAsJsonObject(); return root.getAsJsonArray("choices") .get(0) .getAsJsonObject() .getAsJsonObject("message") .get("content") .getAsString() .trim(); } }

这段代码里有几个值得注意的地方：

1. 超时设置很关键。连接超时 10 秒、请求超时 30 秒，可以避免 AI 接口无响应时把服务端线程池占满。
2. 状态码必须检查。不要只看返回体里有没有choices，因为 401 表示 API Key 错误，429 表示限流，500 表示服务端错误。
3. 解析逻辑依赖 JSON 结构，如果服务商返回格式不同，需要单独适配。

4.3 配置管理：从环境变量到配置文件

API Key 不应该硬编码在 Java 源码里，更不能写进模组 jar 包后公开分享。推荐把这部分配置放到游戏运行目录的config/aichatbot.properties文件里。

# AI 接口地址 api.url=https://api.example.com/v1/chat/completions # API Key，不要在公开仓库泄露 api.key=sk-xxxxxxxx # 模型名称 model=gpt-3.5-turbo # system prompt system.prompt=你是一个《我的世界》服务器助手，回答要简洁、有趣、符合游戏设定。 # 最大生成 token max.tokens=200 # 采样温度 temperature=0.7 # 触发词，玩家需要以 !ai 开头才会触发机器人 trigger.prefix=!ai # 冷却时间，单位毫秒 cooldown.ms=10000

在AIConfig类里读取配置文件。如果配置文件不存在，就使用默认值，并把默认值写到文件里，方便玩家修改。

package com.example.aichatbot; import net.fabricmc.loader.api.FabricLoader; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardCopyOption; import java.util.Properties; public class AIConfig { private static final Properties PROPS = new Properties(); private static boolean loaded = false; public static void load() { if (loaded) { return; } Path configDir = FabricLoader.getInstance().getConfigDir(); Path configFile = configDir.resolve("aichatbot.properties"); if (!Files.exists(configFile)) { try (InputStream in = AIConfig.class.getResourceAsStream("/aichatbot.properties")) { Files.createDirectories(configDir); if (in != null) { Files.copy(in, configFile, StandardCopyOption.REPLACE_EXISTING); } } catch (IOException e) { AIChatBotMod.LOGGER.error("Failed to create default config", e); } } try (InputStream in = Files.newInputStream(configFile)) { PROPS.load(in); loaded = true; } catch (IOException e) { AIChatBotMod.LOGGER.error("Failed to load AI chatbot config", e); } } public static String getApiUrl() { return PROPS.getProperty("api.url", "https://api.example.com/v1/chat/completions"); } public static String getApiKey() { return PROPS.getProperty("api.key", ""); } public static String getModel() { return PROPS.getProperty("model", "gpt-3.5-turbo"); } public static String getSystemPrompt() { return PROPS.getProperty("system.prompt", "你是一个《我的世界》服务器助手，回答要简洁、有趣、符合游戏设定。"); } public static int getMaxTokens() { return Integer.parseInt(PROPS.getProperty("max.tokens", "200")); } public static double getTemperature() { return Double.parseDouble(PROPS.getProperty("temperature", "0.7")); } public static String getTriggerPrefix() { return PROPS.getProperty("trigger.prefix", "!ai"); } public static long getCooldownMs() { return Long.parseLong(PROPS.getProperty("cooldown.ms", "10000")); } }

引入 Gson 解析 JSON 时，需要在build.gradle里添加依赖。Fabric Loom 的依赖声明如下：

dependencies { minecraft "com.mojang:minecraft:${project.minecraft_version}" mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2" modImplementation "net.fabricmc:fabric-loader:${project.loader_version}" modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}" // 用于 JSON 解析 implementation 'com.google.code.gson:gson:2.10.1' include 'com.google.code.gson:gson:2.10.1' }

这里include会把 Gson 打包进模组 jar，避免运行环境没有 Gson 依赖。

5. 带冷却频率控制：防止玩家刷屏和 AI 接口被打爆

5.1 为什么必须有冷却控制

联机服务器里，玩家的聊天频率远高于单人游戏。如果每个玩家发一句话都触发一次 AI 请求，可能出现两个问题：

• AI 接口按调用次数计费，成本失控。
• 接口有每分钟请求数限制，超限后返回 429，机器人持续报错。

因此，模组里必须实现一个简单的玩家冷却表。按玩家 UUID 记录上次调用时间，在允许范围内才继续请求。

5.2 基于 ConcurrentHashMap 的冷却实现

package com.example.aichatbot; import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; public class CooldownManager { private static final Map<UUID, Long> LAST_CALL_TIME = new ConcurrentHashMap<>(); public static boolean tryAcquire(UUID playerUuid) { long now = System.currentTimeMillis(); long cooldown = AIConfig.getCooldownMs(); Long last = LAST_CALL_TIME.get(playerUuid); if (last != null && (now - last) < cooldown) { return false; } LAST_CALL_TIME.put(playerUuid, now); return true; } public static void clear(UUID playerUuid) { LAST_CALL_TIME.remove(playerUuid); } }

在ChatBotHandler.handleMessage里调用冷却判断：

public static void handleMessage(ServerPlayerEntity sender, String senderName, String raw) { if (sender == null) { return; } String prefix = AIConfig.getTriggerPrefix(); if (!raw.startsWith(prefix)) { return; } if (!CooldownManager.tryAcquire(sender.getUuid())) { sender.sendMessage(Text.literal("[AI] 你的请求太频繁了，请稍后再试。"), false); return; } String prompt = raw.substring(prefix.length()).trim(); // 异步调用 AI }

这里用ConcurrentHashMap是因为聊天事件可能在不同线程回调，需要保证线程安全。服务端主线程、网络线程都可能触发消息事件。

5.3 管理员开关和消息前缀

为了便于服务器管理员控制，可以再加一个配置项：是否只允许特定权限等级的玩家触发 AI。Minecraft 没有内置权限插件时，可以通过sender.hasPermissionLevel(2)判断 OP 权限。也可以在配置里维护一个白名单玩家名列表。

如果想让回复更清晰，可以在广播时带上发送者名字，例如：

currentServer.getPlayerManager().broadcast( Text.literal("[AI -> " + senderName + "] " + reply), false );

这样可以避免多个玩家同时触发时，不知道机器人到底在回复谁。

注意：不要在代码里把 API Key 打印到日志里。排查问题时，可以在日志里记录“已加载 API Key，长度 18 位”，但不要输出完整 key。

6. 完整启动流程与常见配置问题

6.1 启动服务端验证模组加载

在开发环境里，运行 Gradle 的runServer任务可以快速启动一个测试服务端：

./gradlew runServer

启动后，日志里会出现 Fabric Loader 加载模组的信息。如果看到类似：

[main/INFO]: Loading 1 mods: aichatbot [main/INFO]: AI Chat Bot mod initialized.

说明模组已经加载成功。

然后进入游戏，用本地客户端连接localhost。在聊天框输入：

!ai 服务器怎么传送到 spawn？

如果一切正常，服务器会广播一条[AI]开头的回复。

6.2 配置不生效的排查顺序

6.3 构建发布到正式服务器的注意事项

开发完成并测试通过后，可以执行./gradlew build生成 jar 文件。构建产物位于：

build/libs/aichatbot-1.0.0.jar

把该 jar 放到服务器的mods目录，同时服务器需要安装 Fabric Loader 和 Fabric API。注意：

1. 服务端和客户端都要有 Fabric API，除非你只部署在服务端并把environment设置为server。
2. 配置文件第一次启动后会自动生成，不要在 Mod 压缩包内强行携带玩家私密配置。
3. 如果服务端有多个世界，配置文件只放在根目录的config目录，不要放在单个存档里。
4. 正式部署前，要确认 AI 接口服务商允许在游戏场景中调用，并阅读其内容政策和频率限制。

7. 常见问题与排错实战

7.1 聊天事件没有触发

如果你发现handleMessage完全没有被调用，先检查fabric.mod.json是否声明了server入口点。某些情况下，玩家使用客户端登录，聊天事件在客户端处理，服务端事件没有绑定成功。

检查顺序：

1. 服务端日志是否出现AI Chat Bot mod initialized.。
2. 是否安装了 Fabric API。
3. 是否把模组 jar 放进了正确的mods目录。
4. 在handleMessage第一行加日志，确认事件是否进入。

7.2 AI 回复乱码

Minecraft 默认聊天栏支持 UTF-8，但某些服务端配置或字体资源可能对中文显示有异常。如果 AI 返回的文本出现乱码，检查：

• AI 接口返回的字符编码是否为 UTF-8。
• HTTP 客户端是否正确读取字符集。
• 游戏字体是否支持中文。

在 Java 里读取响应时，可以指定字符集：

HttpResponse<String> response = HTTP_CLIENT.send( request, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8) );

7.3 服务器主线程被阻塞

如果你没有使用异步，而是直接在事件回调里调用send方法，服务器收到聊天消息后就会卡住。判断方法很简单：在聊天输入消息后，如果其他玩家的操作都卡住几秒，说明网络请求阻塞了主线程。

解决方案：

• 使用CompletableFuture.runAsync。
• 不要在异步任务里直接调用客户端相关 API。
• 广播操作通过server.execute(...)回到主线程。

7.4 多个 AI 请求并发导致消息顺序错乱

如果没有做队列控制，多个玩家同时触发请求时，AI 返回顺序可能和提问顺序不一致。此时回复会出现“串台”现象。

简单的处理方案：在CompletableFuture返回结果后，把玩家 UUID 和问题摘要一起带上，广播时显示“回复 XX 的问题”。更严格的方案是使用单线程调度器，让所有 AI 请求按到达顺序排队。

ExecutorService aiExecutor = Executors.newSingleThreadExecutor();

但单线程会降低吞吐，只适合玩家不多的小服务器。

7.5 构建时找不到 Gson 或类冲突

如果你在build.gradle里只写了implementation而没有写include，开发环境能运行，但打出的 jar 发布到服务器时可能报NoClassDefFoundError: com/google/gson/JsonParser。

解决方式：

implementation 'com.google.code.gson:gson:2.10.1' include 'com.google.code.gson:gson:2.10.1'

如果已经引入了include，仍出现冲突，可以检查是否是其他模组也打包了不同版本的 Gson。尽量保持环境干净，只安装必要模组。

8. 最佳实践：从能跑到能用的差距

8.1 安全与隐私清单

聊天机器人会把玩家消息发送给外部 AI 服务，这本身就是数据外发。在正式服务器开放前，至少要确认以下几点：

• 在服务器公告或规则里说明“部分聊天内容可能由 AI 处理”。
• 配置文件中禁止记录明文 API Key 到日志。
• 对发送内容做长度限制。比如超过 200 个字符的消息不发送给 AI。
• 禁止把服务端后台命令、玩家 IP、真实姓名等敏感信息写入 prompt。
• 使用 HTTPS 接口，不要用明文 HTTP。

8.2 成本控制清单

AI 接口按 token 计费时，如果玩家频繁提问，费用可能快速上涨。建议：

8.3 日志与可观测性

日志里至少记录这些信息：

• AI 请求开始时间、玩家名、消息长度。
• 接口返回状态码。
• 接口响应耗时。
• 失败原因和异常堆栈。
• 冷却拦截次数。

在开发环境可以输出到控制台。生产环境建议接入服务端日志文件，按日期轮转，方便追踪问题。

8.4 学习资源扩展方向

如果你还想继续深入，可以按以下顺序扩展：

1. 学习 Fabric 的事件机制，提交其他类型的自定义事件。
2. 学习如何读写 Minecraft 配置文件，使用更友好的 JSON 配置格式。
3. 研究 Fabric API 的ServerPlayNetworking，实现自定义网络包，让客户端发送 AI 请求而不是服务端截获聊天。
4. 学习数据库存储，把玩家和 AI 的历史聊天记录存下来，让 AI 具备多轮上下文记忆。
5. 集成语音识别或 TTS，让 AI 机器人能“说话”，但这一类对性能要求更高，要谨慎。

9. 可复用的玩家提问场景示例

为了让整体效果更好，可以配置更有针对性的 system prompt。下面是一个适合中小型生存服务器的示例：

你是“我的世界”服务器的一名 AI 助手，名叫小方块。 玩家会向你提问关于服务器玩法、建筑、红石、领地、传送、经济等问题。 回答要求： 1. 优先给出具体操作步骤。 2. 如果问题涉及服务器插件，请说明“请咨询管理员确认插件名称”。 3. 每次回复不超过 3 句话。 4. 不要主动要求玩家提供密码、真实姓名或联系方式。 5. 使用中文回答。

在代码里，这个模板写在config/aichatbot.properties的system.prompt中。修改后重启服务端生效。

如果 AI 接口支持流式输出，可以进一步改进体验，让回复逐字显示。但流式输出在 Minecraft 聊天框里实现起来较复杂，需要处理文本动态更新，建议在非实时刷屏场景下谨慎启用。

10. 总结：给这个模组加一个“生产环境心态”

从“我的世界 JAVA1.20.1 fabric 的 aichatbot 模组”这个想法，到一个真正能在服务器里稳定运行的模组，中间隔着的不是 AI 接口接入，而是事件线程模型、配置管理、频率控制和安全边界。单纯用一张 HTTP 请求接上 ChatGPT 很容易，但要让无数真实玩家在服务器里使用时不出问题，才是工程难点。

做完这个最小实现后，建议把它作为学习 Fabric 模组开发的起点。后续可以加入配置热重载、多轮对话记忆、管理员白名单、审核日志、消息队列、持久化聊天记录等功能。每一项功能都会让你对 Minecraft 服务端线程模型、模组加载机制和 Java 并发编程有更深的理解。

最后留一个练习：试着在 mod 里增加一个指令/aichatbot reload，让管理员无需重启服务端就能重新加载配置文件。这个功能涉及命令注册、配置重载和线程安全三个知识点，足够你消化一段时间。