使用Maven构建Minecraft插件时自动递增版本号的方案咨询

作为经常处理Minecraft插件构建和版本管理的开发者，我来给你梳理下可行的方案，以及针对你的需求给出具体建议。

一、两种主流方案的对比分析 #

1. Maven Build Number插件 #

这是最常用的Maven构建版本递增方案，核心逻辑是基于本地文件或者版本控制系统（Git/SVN）来维护递增的构建号，不需要额外的外部服务。

• 优势：
  • 轻量到极致，不需要额外依赖数据库，构建环境零负担。
  • 和Maven集成度极高，只需要在pom.xml里加几行配置就能搞定，上手成本极低。
  • 如果结合Git使用，还能把构建号和代码提交记录关联起来，方便追踪每个版本对应的代码变更。
• 局限：
  • 用本地文件存储构建号的话，多人协作构建可能会出现文件冲突（不过把这个文件纳入Git管理就能缓解大部分问题）。
  • 只能在构建阶段自动递增版本号，没法支持插件运行时的版本修改和持久化需求。

2. MySQL数据库存储版本号 #

这种方案是把版本号存在MySQL数据库里，不管是构建时还是插件运行时，都可以读取并递增版本号，然后写回数据库。

• 优势：
  • 版本号集中存储，多人构建或者多服务器部署时，版本号能保持统一，不会出现各搞各的情况。
  • 既能支持构建时递增，也能满足你提到的“插件启动时加1、停止后不重置”的需求。
• 局限：
  • 得额外维护一个MySQL数据库，增加了部署和维护的复杂度，尤其是小项目有点杀鸡用牛刀的感觉。
  • Maven构建时需要配置数据库连接，还得考虑权限问题，一旦数据库不可用，构建就会失败。

二、方案选择建议 #

如果你的需求只是每次Maven构建Jar时自动递增版本号，那毫不犹豫选Maven Build Number插件，简单高效，完全能覆盖你的需求，没必要折腾数据库。

但如果你的需求还包括插件启动时自动加1，且服务器停止后版本号不重置，那单纯的Maven插件就不够用了，得结合持久化存储来实现运行时的版本管理——优先考虑本地文件存储（轻量无依赖），如果是多服务器需要共享统一版本号，再考虑MySQL。

三、具体实现步骤 #

方案1：仅构建时自动递增（Maven Build Number） #

1. 在你的pom.xml中添加插件配置：

<build>
    <plugins>
        <!-- 配置Build Number插件，生成递增的构建号 -->
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>buildnumber-maven-plugin</artifactId>
            <version>1.4</version>
            <executions>
                <execution>
                    <phase>validate</phase>
                    <goals>
                        <goal>create</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <!-- 关闭Git检查，用本地文件存储构建号 -->
                <doCheck>false</doCheck>
                <doUpdate>true</doUpdate>
                <!-- 定义构建号的变量名 -->
                <buildNumberPropertyName>buildNumber</buildNumberPropertyName>
                <format>{0,number}</format>
                <items>
                    <item>buildNumber</item>
                </items>
            </configuration>
        </plugin>
        <!-- 把构建号写入Jar的Manifest文件，方便插件读取 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.3.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                    </manifest>
                    <manifestEntries>
                        <!-- 最终版本号格式：项目版本.构建号 -->
                        <Implementation-Version>${project.version}.${buildNumber}</Implementation-Version>
                    </manifestEntries>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

2. 配置完成后，每次执行mvn package，buildNumber就会自动递增，生成的Jar包版本号会变成类似1.0.0.1、1.0.0.2这样的格式，而且这个版本号会写入Jar的MANIFEST.MF文件中，插件可以通过读取Manifest来获取当前版本。

方案2：支持运行时版本递增且持久化 #

如果要实现“插件启动时自动加1，停止后不重置”，需要分两步：构建阶段可以先用Maven生成初始版本，运行阶段则要把版本号持久化存储起来。

子方案A：本地文件存储（轻量首选）

用一个本地文本文件来保存版本号，插件启动时读取文件内容，加1后写回文件，这样不需要数据库，非常简单：

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;

public class LocalVersionManager {
    private static int currentVersion;

    // 插件启动时调用，传入插件的数据文件夹
    public static void initVersion(File dataFolder) {
        File versionFile = new File(dataFolder, "version.txt");
        try {
            if (!versionFile.exists()) {
                // 首次运行，初始化版本为1
                versionFile.createNewFile();
                currentVersion = 1;
                writeVersion(versionFile, currentVersion);
            } else {
                // 读取现有版本，加1
                BufferedReader reader = new BufferedReader(new FileReader(versionFile));
                String versionStr = reader.readLine();
                currentVersion = Integer.parseInt(versionStr) + 1;
                reader.close();
                // 写回文件
                writeVersion(versionFile, currentVersion);
            }
            System.out.println("当前插件运行版本：" + currentVersion);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void writeVersion(File file, int version) {
        try (FileWriter writer = new FileWriter(file)) {
            writer.write(String.valueOf(version));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 获取当前版本号
    public static int getCurrentVersion() {
        return currentVersion;
    }
}

然后在插件主类的onEnable()方法中调用：

@Override
public void onEnable() {
    // 初始化版本号
    LocalVersionManager.initVersion(this.getDataFolder());
    // 其他插件初始化逻辑...
}

子方案B：MySQL数据库存储（多服务器共享版本）

如果是多台服务器需要共享统一的版本号，就用MySQL来存储：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class DBVersionManager {
    // 替换成你的数据库信息
    private static final String DB_URL = "jdbc:mysql://localhost:3306/your_plugin_db";
    private static final String DB_USER = "db_user";
    private static final String DB_PASS = "db_password";
    private static int currentVersion;

    public static void initVersion() {
        try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASS)) {
            // 先查询当前版本
            String querySql = "SELECT version FROM plugin_version WHERE id = 1";
            try (PreparedStatement stmt = conn.prepareStatement(querySql);
                 ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    currentVersion = rs.getInt("version") + 1;
                } else {
                    // 首次运行，初始化版本
                    currentVersion = 1;
                    String insertSql = "INSERT INTO plugin_version (id, version) VALUES (1, ?)";
                    try (PreparedStatement insertStmt = conn.prepareStatement(insertSql)) {
                        insertStmt.setInt(1, currentVersion);
                        insertStmt.executeUpdate();
                    }
                }
            }
            // 更新数据库中的版本号
            String updateSql = "UPDATE plugin_version SET version = ? WHERE id = 1";
            try (PreparedStatement stmt = conn.prepareStatement(updateSql)) {
                stmt.setInt(1, currentVersion);
                stmt.executeUpdate();
            }
            System.out.println("当前插件运行版本：" + currentVersion);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static int getCurrentVersion() {
        return currentVersion;
    }
}

同样在插件主类的onEnable()中调用DBVersionManager.initVersion()即可。

四、总结 #

• 只需要构建时递增版本：选Maven Build Number插件，简单高效无负担。
• 需要运行时递增且持久化：优先用本地文件存储，轻量易维护；多服务器共享版本号的话再考虑MySQL。

内容的提问来源于stack exchange，提问作者SunnyLo