Minecraft Forge模组开发入门与实践指南-代码聚汇网

Minecraft Forge模组开发入门与实践指南

永远雪山·2026-08-08·阅读 22 GEO检测（免费）

Minecraft模组开发Forge框架Java游戏开发

|难度：普通|阅读约 46 分钟

1. 为什么选择Forge作为Minecraft模组开发框架

Forge作为Minecraft Java版最主流的模组开发框架，已经存在超过10年历史。我最初接触Forge是在1.4.7版本时期，当时就被它完善的API设计和活跃的社区所吸引。相比其他模组框架，Forge最大的优势在于：

版本覆盖全面：从早期的1.4.7到最新的1.20.1，几乎所有主流Minecraft版本都有对应的Forge支持
API设计成熟：事件系统、注册机制、网络通信等核心功能都有完善的封装
社区生态丰富：CurseForge平台上有超过5万个Forge模组，开发者可以轻松找到现成的解决方案

提示：虽然Fabric框架近年来发展迅速，但Forge仍然是功能最全面、文档最完善的模组开发选择，特别适合需要深度修改游戏机制的模组。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 开发环境准备

2.1 JDK安装与配置

Forge开发需要Java 8或更高版本。我推荐使用Amazon Corretto JDK 17，这是目前Forge官方推荐的长期支持版本：

bash复制# 在Ubuntu上安装
sudo apt install -y wget
wget https://corretto.aws/downloads/latest/amazon-corretto-17-x64-linux-jdk.deb
sudo dpkg -i amazon-corretto-17-x64-linux-jdk.deb

# 验证安装
java -version

Windows用户可以直接从Amazon Corretto官网下载安装包。安装完成后需要设置JAVA_HOME环境变量：

bash复制# Linux/MacOS
export JAVA_HOME=$(dirname $(dirname $(readlink -f $(which java))))

# Windows
# 在系统环境变量中添加JAVA_HOME，指向JDK安装目录

2.2 IDE选择与配置

IntelliJ IDEA是Forge开发的首选IDE。社区版就足够使用，但终极版对Gradle的支持更好。安装后需要：

安装Minecraft Development插件
配置Gradle使用本地分发（避免每次新建项目都下载）
调整JVM参数：Help -> Edit Custom VM Options，添加-Xmx4G（至少分配4GB内存）

2.3 Forge MDK获取

Forge提供了专门的Mod Development Kit（MDK），我们可以从官方站点下载：

bash复制# 以1.20.1版本为例
wget https://maven.minecraftforge.net/net/minecraftforge/forge/1.20.1-47.1.0/forge-1.20.1-47.1.0-mdk.zip
unzip forge-1.20.1-47.1.0-mdk.zip

解压后会得到以下关键文件结构：

code复制forge-mdk/
├── build.gradle       # 项目构建配置
├── gradle/            # Gradle包装器
├── src/
│   ├── main/
│   │   ├── java/      # 模组源代码
│   │   └── resources/ # 资源文件
│   └── test/          # 测试代码
└── gradlew            # Gradle执行脚本

3. 项目初始化与配置

3.1 build.gradle关键配置

打开build.gradle文件，有几个关键配置需要修改：

groovy复制version = '1.0'  // 模组版本号
group = 'com.yourname.modid' // 包名前缀

// 修改模组ID（必须全小写无空格）
minecraft {
    mappings channel: 'official', version: '1.20.1'
    
    runs {
        client {
            workingDirectory project.file('run')
            property 'forge.logging.markers', 'REGISTRIES'
            property 'forge.logging.console.level', 'debug'
            mods {
                examplemod {
                    source sourceSets.main
                }
            }
        }
    }
}

注意：模组ID应该全局唯一，建议使用反向域名格式（如com.yourname.modid），避免与其他模组冲突。

3.2 模组主类创建

在src/main/java下创建你的包结构，然后新建主类：

java复制package com.yourname.examplemod;

import net.minecraftforge.fml.common.Mod;

@Mod("examplemod")
public class ExampleMod {
    public ExampleMod() {
        // 模组初始化代码
    }
}

3.3 mods.toml元数据配置

src/main/resources/META-INF/mods.toml是模组的元数据文件：

toml复制modLoader="javafml"
loaderVersion="[47,)"
license="All rights reserved"

[[mods]]
modId="examplemod"
version="${file.jarVersion}"
displayName="Example Mod"
authors="YourName"
description='''
A simple example mod for Minecraft Forge.
'''

4. 核心开发实践

4.1 物品注册与添加

创建一个新物品是模组开发的基础操作。首先创建ItemInit类：

java复制public class ItemInit {
    public static final DeferredRegister<Item> ITEMS = 
        DeferredRegister.create(ForgeRegistries.ITEMS, ExampleMod.MOD_ID);
    
    public static final RegistryObject<Item> EXAMPLE_ITEM = ITEMS.register(
        "example_item", 
        () -> new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC))
    );
    
    public static void register(IEventBus eventBus) {
        ITEMS.register(eventBus);
    }
}

然后在主类的构造函数中注册：

java复制public ExampleMod() {
    ItemInit.register(FMLJavaModLoadingContext.get().getModEventBus());
}

4.2 方块与方块实体

创建自定义方块需要同时注册方块和对应的物品：

java复制public class BlockInit {
    public static final DeferredRegister<Block> BLOCKS = 
        DeferredRegister.create(ForgeRegistries.BLOCKS, ExampleMod.MOD_ID);
    
    public static final RegistryObject<Block> EXAMPLE_BLOCK = BLOCKS.register(
        "example_block",
        () -> new Block(BlockBehaviour.Properties.of(Material.STONE)
            .strength(3.5f)
            .requiresCorrectToolForDrops()
        )
    );
    
    public static final RegistryObject<Item> EXAMPLE_BLOCK_ITEM = ItemInit.ITEMS.register(
        "example_block",
        () -> new BlockItem(EXAMPLE_BLOCK.get(), 
            new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS))
    );
}

4.3 事件处理系统

Forge的事件系统是其核心特性之一。例如监听玩家右键点击事件：

java复制@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE)
public class EventHandler {
    @SubscribeEvent
    public static void onRightClickItem(PlayerInteractEvent.RightClickItem event) {
        Player player = event.getPlayer();
        ItemStack stack = event.getItemStack();
        
        if(stack.getItem() == ItemInit.EXAMPLE_ITEM.get()) {
            player.displayClientMessage(
                Component.literal("You used the example item!"), 
                true
            );
            event.setCanceled(true);
        }
    }
}

5. 调试与测试

5.1 运行客户端

在IntelliJ IDEA中：

打开Gradle面板（右侧边栏）
展开Tasks -> forge -> runClient
双击执行，会自动下载依赖并启动游戏

提示：首次运行会下载大量资源，建议保持网络通畅。可以通过修改gradle.properties中的org.gradle.jvmargs来增加内存分配。

5.2 热重载开发

Forge支持开发时的热重载功能：

在游戏中按下F3+T重新加载资源
对于代码修改，使用IntelliJ的Build -> Rebuild Project
在游戏内执行/reload命令

5.3 常见问题排查

游戏崩溃无日志：查看.minecraft/crash-reports目录下的最新文件
模组未加载：检查是否遗漏了@Mod注解或mods.toml配置错误
物品/方块显示异常：确认资源路径正确（assets/modid/textures/item/...）
ClassNotFound错误：通常是因为Gradle依赖未正确同步，执行gradlew --refresh-dependencies

6. 构建与发布

6.1 生成发布包

执行Gradle构建任务：

bash复制./gradlew build

构建产物位于build/libs目录下，命名格式为modid-version.jar。

6.2 Gitee仓库管理

将项目上传到Gitee的步骤：

在Gitee上创建新仓库（不要初始化README）
本地初始化Git仓库：

bash复制git init
git add .
git commit -m "Initial commit"
git remote add origin https://gitee.com/yourname/example-mod.git
git push -u origin master

配置.gitignore文件（重要）：

code复制.gradle/
build/
run/
out/
*.iml
.idea/

6.3 开源许可证选择

在Gitee创建仓库时可以选择许可证，对于模组开发常见的有：

MIT：最宽松，允许商业使用
LGPL-3.0：要求修改部分开源
All Rights Reserved：保留所有权利

建议选择MIT许可证，在根目录添加LICENSE文件：

text复制MIT License

Copyright (c) [year] [fullname]

Permission is hereby granted...

7. 进阶开发技巧

7.1 跨版本兼容

通过Gradle配置支持多版本开发：

groovy复制sourceSets {
    main {
        java {
            srcDirs = ['src/main/java']
        }
        resources {
            srcDirs = ['src/main/resources']
        }
    }
    api {
        java {
            srcDirs = ['src/api/java']
        }
    }
}

7.2 混合使用客户端/服务端代码

使用@OnlyIn注解标记特定端代码：

java复制@OnlyIn(Dist.CLIENT)
public void clientOnlyMethod() {
    // 仅客户端执行的代码
}

@OnlyIn(Dist.DEDICATED_SERVER)
public void serverOnlyMethod() {
    // 仅服务端执行的代码
}

7.3 性能优化建议

避免在tick事件中进行复杂计算
使用Capability系统代替大量NBT数据
对频繁调用的方法添加@SubscribeEvent(priority=EventPriority.HIGHEST)
使用LazyOptional延迟加载资源

8. 资源文件与本地化

8.1 纹理与模型

标准资源目录结构：

code复制resources/
├── assets/
│   └── examplemod/
│       ├── lang/          # 多语言文件
│       ├── models/        # 模型定义
│       ├── shaders/       # 着色器
│       ├── sounds/        # 音效
│       ├── textures/      # 纹理图片
│       └── blockstates/   # 方块状态
└── pack.mcmeta           # 资源包元数据

8.2 多语言支持

创建en_us.json（英文）和zh_cn.json（中文）等语言文件：

json复制// zh_cn.json
{
  "item.examplemod.example_item": "示例物品",
  "block.examplemod.example_block": "示例方块",
  "itemGroup.examplemod": "示例模组"
}

8.3 自定义音效

将音效文件放入assets/examplemod/sounds/
注册音效事件：

java复制public static final RegistryObject<SoundEvent> EXAMPLE_SOUND = SOUND_EVENTS.register(
    "example_sound",
    () -> SoundEvent.createVariableRangeEvent(
        new ResourceLocation(ExampleMod.MOD_ID, "example_sound")
    )
);

播放音效：

java复制player.playSound(EXAMPLE_SOUND.get(), 1.0F, 1.0F);

9. 网络通信实现

9.1 简单数据包示例

创建消息类：

java复制public class ExamplePacket {
    private final String message;
    
    public ExamplePacket(String msg) {
        this.message = msg;
    }
    
    public ExamplePacket(FriendlyByteBuf buf) {
        this.message = buf.readUtf();
    }
    
    public void encode(FriendlyByteBuf buf) {
        buf.writeUtf(message);
    }
    
    public void handle(Supplier<NetworkEvent.Context> ctx) {
        ctx.get().enqueueWork(() -> {
            // 客户端处理
            if(ctx.get().getDirection() == NetworkDirection.PLAY_TO_CLIENT) {
                Minecraft.getInstance().player.displayClientMessage(
                    Component.literal(message), false);
            }
        });
        ctx.get().setPacketHandled(true);
    }
}

9.2 注册消息通道

在主类中初始化：

java复制private static final String PROTOCOL_VERSION = "1";
public static final SimpleChannel INSTANCE = NetworkRegistry.newSimpleChannel(
    new ResourceLocation(MOD_ID, "main"),
    () -> PROTOCOL_VERSION,
    PROTOCOL_VERSION::equals,
    PROTOCOL_VERSION::equals
);

public ExampleMod() {
    INSTANCE.registerMessage(0, ExamplePacket.class, 
        ExamplePacket::encode, ExamplePacket::new, ExamplePacket::handle);
}

9.3 发送消息

从服务端向客户端发送：

java复制INSTANCE.send(PacketDistributor.PLAYER.with(() -> player), 
    new ExamplePacket("Hello from server!"));

10. 配置系统

10.1 创建配置文件

使用Forge的Config系统：

java复制@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
public class Config {
    public static final ForgeConfigSpec SERVER_CONFIG;
    public static final ForgeConfigSpec.IntValue EXAMPLE_INT;
    
    static {
        ForgeConfigSpec.Builder builder = new ForgeConfigSpec.Builder();
        
        builder.push("General");
        EXAMPLE_INT = builder
            .comment("An example integer configuration")
            .defineInRange("exampleInt", 10, 1, 100);
        builder.pop();
        
        SERVER_CONFIG = builder.build();
    }
}

10.2 热重载配置

监听配置重载事件：

java复制@SubscribeEvent
public static void onConfigReloading(ModConfigEvent.Reloading event) {
    if(event.getConfig().getModId().equals(ExampleMod.MOD_ID)) {
        // 处理配置变更
    }
}

10.3 客户端专用配置

创建客户端专用配置：

java复制public static final ForgeConfigSpec CLIENT_CONFIG;
public static final ForgeConfigSpec.BooleanValue SHOW_DEBUG;

static {
    ForgeConfigSpec.Builder builder = new ForgeConfigSpec.Builder();
    
    builder.push("Client");
    SHOW_DEBUG = builder
        .comment("Whether to show debug information")
        .define("showDebug", false);
    builder.pop();
    
    CLIENT_CONFIG = builder.build();
}

11. 兼容性处理

11.1 检测其他模组

使用ModList.get().isLoaded()检测模组是否存在：

java复制if(ModList.get().isLoaded("jei")) {
    // JEI模组已加载
}

11.2 跨模组交互

通过Capability系统实现模组间交互：

java复制public interface IExampleCapability {
    int getValue();
    void setValue(int value);
}

public class ExampleCapability implements IExampleCapability {
    private int value;
    
    @Override public int getValue() { return value; }
    @Override public void setValue(int value) { this.value = value; }
}

11.3 版本兼容注解

使用@Mod.EventBusSubscriber的modid和bus参数确保正确加载：

java复制@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
public class CommonSetup {
    @SubscribeEvent
    public static void commonSetup(FMLCommonSetupEvent event) {
        // 通用设置代码
    }
}

12. 性能监控与调试

12.1 使用JFR监控

Java Flight Recorder是强大的性能分析工具：

启动游戏时添加JVM参数：

code复制-XX:+UnlockDiagnosticVMOptions -XX:+DebugNonSafepoints -XX:+FlightRecorder

使用jcmd命令开始记录：

code复制jcmd <pid> JFR.start duration=60s filename=recording.jfr

12.2 内存分析

使用VisualVM或YourKit分析内存使用：

添加JVM参数启用JMX：

code复制-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=9010 -Dcom.sun.management.jmxremote.local.only=false -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false

使用VisualVM连接localhost:9010

12.3 日志分级

在log4j2.xml中配置日志级别：

xml复制<Loggers>
    <Root level="info">
        <Filters>
            <MarkerFilter marker="MODLOADING" onMatch="DENY" onMismatch="NEUTRAL"/>
        </Filters>
    </Root>
    <Logger name="com.yourname.examplemod" level="debug" additivity="false">
        <AppenderRef ref="File"/>
        <AppenderRef ref="Console"/>
    </Logger>
</Loggers>

13. 持续集成与自动化

13.1 GitHub Actions配置

创建.github/workflows/build.yml：

yaml复制name: Java CI

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up JDK 17
      uses: actions/setup-java@v2
      with:
        java-version: '17'
        distribution: 'adopt'
    - name: Grant execute permission for gradlew
      run: chmod +x gradlew
    - name: Build with Gradle
      run: ./gradlew build
    - name: Upload Artifact
      uses: actions/upload-artifact@v2
      with:
        name: build-artifacts
        path: build/libs/*.jar

13.2 自动化发布

使用Gradle插件自动化发布到CurseForge：

groovy复制curseforge {
    apiKey = System.getenv("CURSEFORGE_KEY")
    project {
        id = "your-project-id"
        releaseType = "release"
        changelogType = "markdown"
        changelog = file("CHANGELOG.md")
        addGameVersion "1.20.1"
    }
}

13.3 代码质量检查

配置SpotBugs和Checkstyle：

groovy复制plugins {
    id 'com.github.spotbugs' version '5.0.13'
    id 'checkstyle'
}

spotbugs {
    toolVersion = '4.7.3'
    ignoreFailures = false
    showProgress = true
}

checkstyle {
    toolVersion '10.3.3'
    configFile file("config/checkstyle/checkstyle.xml")
}

14. 社区资源与支持

14.1 官方文档资源

Forge官方文档：https://mcforge.readthedocs.io
Minecraft Wiki：https://minecraft.fandom.com
Forge社区论坛：https://forums.minecraftforge.net

14.2 实用工具推荐

MCreator：可视化模组创作工具（适合初学者）
BlockBench：3D模型编辑工具
VS Code插件：Minecraft Development for VS Code

14.3 调试辅助模组

JEI：物品和配方查看
The One Probe：方块信息查看
Jade：实体信息查看
MixinBooter：Mixin调试工具

15. 实战案例：创建一个简单魔法系统

15.1 法术能力设计

创建基础法术接口：

java复制public interface ISpell {
    void cast(Player player, Level level);
    int getManaCost();
    ResourceLocation getTexture();
}

15.2 法术注册系统

使用Forge注册表：

java复制public class SpellRegistry {
    private static final DeferredRegister<ISpell> SPELLS = 
        DeferredRegister.create(new ResourceLocation(ExampleMod.MOD_ID, "spells"), MOD_ID);
    
    public static final RegistryObject<ISpell> FIREBALL = SPELLS.register(
        "fireball", 
        () -> new SimpleSpell(10, new ResourceLocation(MOD_ID, "textures/spell/fireball.png")) {
            @Override
            public void cast(Player player, Level level) {
                // 实现火球法术逻辑
            }
        }
    );
}

15.3 客户端渲染

创建法术HUD渲染器：

java复制@OnlyIn(Dist.CLIENT)
public class SpellHUD {
    public static void render(PoseStack poseStack) {
        Minecraft mc = Minecraft.getInstance();
        if(mc.player == null) return;
        
        ISpell spell = getSelectedSpell(mc.player);
        if(spell != null) {
            RenderSystem.setShaderTexture(0, spell.getTexture());
            GuiComponent.blit(poseStack, 10, 10, 0, 0, 16, 16, 16, 16);
        }
    }
}

16. 安全与最佳实践

16.1 输入验证

对所有网络数据包进行验证：

java复制public ExamplePacket(FriendlyByteBuf buf) {
    this.message = buf.readUtf(256); // 限制最大长度
}

public void handle(Supplier<NetworkEvent.Context> ctx) {
    if(message == null || message.length() > 256) {
        return; // 丢弃非法数据包
    }
    // 处理逻辑
}

16.2 防作弊措施

服务端验证客户端操作：

java复制@SubscribeEvent
public static void onBlockBreak(BlockEvent.BreakEvent event) {
    Player player = event.getPlayer();
    if(player.level.isClientSide) return;
    
    if(!canPlayerBreakBlock(player, event.getPos())) {
        event.setCanceled(true);
    }
}

16.3 内存管理

使用WeakReference管理大对象：

java复制private static final Map<ResourceLocation, WeakReference<Texture>> TEXTURE_CACHE = 
    new HashMap<>();

public static Texture getTexture(ResourceLocation location) {
    WeakReference<Texture> ref = TEXTURE_CACHE.get(location);
    Texture texture = ref != null ? ref.get() : null;
    
    if(texture == null) {
        texture = loadTexture(location);
        TEXTURE_CACHE.put(location, new WeakReference<>(texture));
    }
    
    return texture;
}

17. 模组本地化与发布

17.1 多语言支持增强

使用格式化字符串：

json复制{
  "message.examplemod.welcome": "欢迎, %s!",
  "message.examplemod.level": "你的等级是 %d"
}

代码中使用：

java复制player.sendMessage(Component.translatable(
    "message.examplemod.welcome", 
    player.getDisplayName()
));

17.2 发布到CurseForge

注册CurseForge开发者账号
创建项目页面
准备高质量的展示图片和详细说明
上传构建的jar文件
设置合适的分类和游戏版本

17.3 版本更新策略

使用语义化版本控制（MAJOR.MINOR.PATCH）
维护详细的变更日志（CHANGELOG.md）
为每个Minecraft版本创建独立分支
使用Git标签标记发布版本

18. 性能优化深度技巧

18.1 区块加载优化

使用懒加载策略：

java复制private final LazyOptional<ICapability> lazyCap = LazyOptional.of(() -> new CapImpl());

@Nonnull
@Override
public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
    return cap == EXAMPLE_CAP ? lazyCap.cast() : LazyOptional.empty();
}

18.2 渲染批处理

使用IVertexBuilder进行批量渲染：

java复制public void render(PoseStack poseStack, MultiBufferSource buffer, int packedLight) {
    IVertexBuilder vb = buffer.getBuffer(RenderType.entityCutout(TEXTURE));
    Matrix4f matrix = poseStack.last().pose();
    
    // 批量添加顶点
    for(int i = 0; i < count; i++) {
        vb.vertex(matrix, x, y, z)
          .color(r, g, b, a)
          .uv(u, v)
          .uv2(packedLight)
          .normal(nx, ny, nz)
          .endVertex();
    }
}

18.3 网络通信压缩

对大数据包进行压缩：

java复制public void encode(FriendlyByteBuf buf) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try(GZIPOutputStream gzos = new GZIPOutputStream(baos)) {
        gzos.write(data.getBytes(StandardCharsets.UTF_8));
    }
    buf.writeByteArray(baos.toByteArray());
}

19. 测试驱动开发

19.1 单元测试框架

配置JUnit 5测试：

groovy复制dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
}

test {
    useJUnitPlatform()
}

19.2 模拟游戏环境

使用MCJUnitLib进行集成测试：

java复制@ExtendWith(MCExtension.class)
@MCTest
class ExampleModTest {
    @Test
    void testItemRegistration(GameTestHelper helper) {
        Item item = ItemInit.EXAMPLE_ITEM.get();
        helper.assertTrue(item != null, "Item not registered");
        helper.succeed();
    }
}

19.3 自动化UI测试

使用jNativeHook模拟用户输入：

java复制public class UITest {
    public static void main(String[] args) throws Exception {
        GlobalScreen.registerNativeHook();
        GlobalScreen.addNativeKeyListener(new NativeKeyAdapter() {
            @Override
            public void nativeKeyPressed(NativeKeyEvent e) {
                // 模拟按键测试UI响应
            }
        });
    }
}

20. 未来扩展方向

20.1 数据驱动开发

使用JSON定义游戏内容：

json复制{
  "spells": [
    {
      "id": "fireball",
      "mana_cost": 10,
      "texture": "examplemod:textures/spell/fireball.png"
    }
  ]
}

20.2 动态资源加载

运行时加载资源包：

java复制public void loadDynamicResources(AddPackFindersEvent event) {
    if(event.getPackType() == PackType.CLIENT_RESOURCES) {
        event.addRepositorySource(consumer -> {
            consumer.accept(Pack.create(
                "examplemod:dynamic",
                Component.literal("Dynamic Resources"),
                true,
                id -> new DynamicResourcePack(id, dynamicResources),
                Pack.PackInfo.deserialize("Dynamic resources", 8),
                Pack.Position.TOP,
                false,
                PackSource.BUILT_IN
            ));
        });
    }
}

20.3 跨平台兼容

使用Architectury API支持Fabric和Forge：

java复制public class ExampleMod {
    public static final String MOD_ID = "examplemod";
    
    public static void init() {
        // 通用初始化代码
        
        if(Platform.isForge()) {
            // Forge特有代码
        } else if(Platform.isFabric()) {
            // Fabric特有代码
        }
    }
}