Develop your first in Java Fabric module

Mission 01 · What can you do after learning?

It's not about "beating it and finishing it", but establishing a development map that can continue to grow.

Many beginner tutorials copy dozens of lines of registration code as soon as they start. Although students see that there are many things in the game, they do not know what JDK, Gradle, Fabric Loader and Fabric API are responsible for. Once the version is different, the package name is changed, or the dependency download fails, you have no idea where to check. In this lesson, you first build a model and then complete a small but complete work. You'll know why each file exists, which level each command is run on, and which line to start reading error messages from.

Version strategy · Fix the version first

The biggest fear in module development is not the difficulty of coding, but putting together tutorials from different eras.

Fabric, Minecraft, Java, Loader, Loom, and the Fabric API all have their own versions. The class names and resource formats may be different between 1.20.1, 1.21.1, 1.21.11 and 26.x on the network. Upgrading everything when you see the "latest version" often makes an otherwise correct example unable to compile. In order to allow students to reproduce stably, this lesson focuses on Minecraft Java 1.21.1 and JDK 21, and uses the dependency combination currently provided by the Fabric official example project for the 1.21.1 branch.

Please prepare before starting

• A Windows computer that can run Minecraft Java Edition, and a legitimate game account that you have access to.
• At least 8 GB memory; the first Gradle sync depends on a network download, and speed depends on the network.
• JDK 21. Note that JRE can only "run", JDK only contains javac and other development tools.
• IntelliJ IDEA Community Edition. It is sufficient for Fabric Java development without the need to purchase Ultimate.
• A pure English, no spaces, non-OneDrive project path, for example C:\Projects\teacherma-fabric-intro.

Mental model · What exactly is Fabric?

It is not a "make a mod button", but a composable Java tool chain.

Fabric Loader Is the loader: reads each module when starting the game fabric.mod.jsonCheck ID, dependency and entrance classes and call your code.Fabric API It is a collection of commonly used development interfaces: providing more stable access points for command registration, events, item groups, network communications, etc.Fabric Loom It is a Gradle plug-in: helps you download games and mappings, generate run configurations, start development clients, remap and build JARs.IntelliJ IDEA It is your workbench for writing code and debugging.

Setup · Installation and creation project

Verify the tool before generating a template; do not write Gradle configurations by memory in an empty folder.

1

Confirm JDK 21, not just "Java installed"

Open PowerShell and run the following two commands respectively. The first checks the running environment, and the second checks the compiler. Both should display 21. if javac does not exist, usually it means that only JRE is installed, or the system PATH does not point to JDK.

PowerShellCopy

java -version
javac -version

2

Use JDK 21 for Project SDK and Gradle JVM of IntelliJ

Open File → Project Structure → Project, set SDK to 21; re-entry Settings → Build, Execution, Deployment → Build Tools → Gradle, also set the Gradle JVM as the same JDK 21. In one place only, there may still be "editor looks normal but construction fails."

3

Generate project from Fabric Template Mod Generator

Open the official generator and fill in: Mod Name is TeacherMa Fabric Intro, Mod ID is teacherma_fabric_intro, PackageName dev.teacherma.fabricintro,MinecraftVersion Selection 1.21.1, language maintains Java. The lesson proposes to keep " split client and main source " , which will detect early errors in writing the client class into the service code.

Open Fabric official generator

4

Unlock to a simple path and open the Project Root Directory in IntelliJ

The recommended path is C:\Projects\teacherma-fabric-intro. choose File → Open should be opened containing build.gradle,gradlew.bat and src layer of folders, don’t just open src. Select Import when prompted by the Gradle build script, and wait for the index and dependencies to download to complete.

5

Quick comparison using course Starter project

If you want to run through it first and then compare it item by item, you can download the projects that have been verified in this lesson. It retains the official Gradle Wrapper and version combinations, and adds the final command code. Open it in a separate folder and don't overwrite your own practice project.

TeacherMa Fabric Intro Starter

Contains complete source code, Gradle Wrapper, version configuration and Chinese README. The download interface is protected by course permissions.

Download ZIP

Project map · Understand the project structure

The responsibility for these documents can be described as truly “opening the project”.

teacherma-fabric-intro/
├─ gradle/                         # Gradle Wrapper 运行文件
├─ src/
│  ├─ main/
│  │  ├─ java/
│  │  │  └─ dev/teacherma/fabricintro/
│  │  │     └─ FabricIntroMod.java # 通用/服务端入口逻辑
│  │  └─ resources/
│  │     └─ fabric.mod.json         # 模组说明书
│  └─ client/                       # 仅客户端代码与资源
├─ build.gradle                     # 插件、依赖与构建规则
├─ gradle.properties                # Minecraft/Fabric 版本
├─ settings.gradle                  # 工程名称与插件仓库
└─ gradlew.bat                      # Windows 下执行 Gradle

fabric.mod.json: Loger first read module instructions

Here. id is the namespace of the entire module and must use safe characters such as lowercase letters, numbers, and underscores; it will also appear in item IDs, resource paths, and logs.entrypoints.main It must be completely consistent with the complete package name of the Java class. Any inconsistency in any letter will result in the entry class not being found.depends then declare the minimum Loader version, target Minecraft, Java and Fabric API.

{
  "schemaVersion": 1,
  "id": "teacherma_fabric_intro",
  "name": "TeacherMa Fabric Intro",
  "environment": "*",
  "entrypoints": {
    "main": ["dev.teacherma.fabricintro.FabricIntroMod"]
  },
  "depends": {
    "fabricloader": ">=0.19.3",
    "minecraft": "~1.21.1",
    "java": ">=21",
    "fabric-api": "*"
  }
}

gradle.properties: Version to appear

The newer the versions, the better, but they must be compatible with each other. The Minecraft version determines which set of game code you face; Loader is responsible for loading; Fabric API must have a suffix that adapts to the target game. The Loom version is given by the same template generator. When upgrading, don’t just minecraft_version Change to the new number and expect all dependencies to be automatically compatible.

Code · Write the first visible function

Register a command to let the Java code actually change the player state on the server side.

We choose command as the first function because it simultaneously displays the entry life cycle, Fabric API events, command tree, execution context, server player object and game item object, and does not require processing of textures, models and language files first. input /hello_fabric Finally, the command is executed on the logical server, adds an emerald to the current player's inventory, and sends a success message.

package dev.teacherma.fabricintro;

import net.fabricmc.api.ModInitializer;
import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
import net.minecraft.commands.Commands;
import net.minecraft.network.chat.Component;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.Items;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class FabricIntroMod implements ModInitializer {
    public static final String MOD_ID = "teacherma_fabric_intro";
    public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);

    @Override
    public void onInitialize() {
        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) ->
                dispatcher.register(Commands.literal("hello_fabric")
                        .executes(context -> {
                            var player = context.getSource().getPlayerOrException();
                            player.addItem(new ItemStack(Items.EMERALD));
                            context.getSource().sendSuccess(
                                    () -> Component.literal("Hello Fabric! Java 已经改变了游戏世界。"),
                                    false
                            );
                            return 1;
                        }))
        );

        LOGGER.info("TeacherMa Fabric Intro loaded successfully.");
    }
}

Run & verify·Run and acceptance

It is normal to start slowly for the first time; after "being able to enter the game", four verifications need to be done.

Open the Gradle tool window on the right side of IntelliJ, find the Fabric related running tasks and execute them runClient. You can also open PowerShell in the project root directory and use Wrapper to start it. Wrapper will ensure that the project uses the specified Gradle version and does not require students to install Gradle globally.

./gradlew.bat runClient

Debug clinic · Common errors

First determine which layer the error occurs, and then decide whether to change settings, dependencies or Java.

Use IntelliJ breakpoints to observe command execution

Click var player = ... Add a red breakpoint to the line number on the left, and then start the client in Debug mode. When entering the world to execute a command, the program will pause. View it in the Variables window at this time context,player With player inventory. Press F8 to step through and you will see for yourself the sequence of "get player → add item → send message → return 1". This is a better way to model program execution than memorizing an API.

Build & install · Build and install

It can run in the development environment, and finally it will become a JAR that can be loaded by the ordinary launcher.

Close the development client and execute the build in the project root directory. Gradle compiles Java, processes resources, remaps names, and generates publishable files. Open after successful build build/libs, select the shortest filename and do not contain sources JAR;sources The package is for developers to read the source code, not for ordinary players to install the package.

./gradlew.bat clean build

Practice·Practice and Self-Assessment

Turn "understand" into "can change independently": complete three small tasks with increasing difficulty.

Five-minute self-test

Terminology card