WildFly 服务器重载后状态检测与编程等待机制

import org.jboss.as.controller.client.helpers.ClientConstants;
import org.wildfly.core.cli.command.CliCommandBuilder;
import org.wildfly.core.cli.launcher.Launcher;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class WildFlyReloadWaiter {

    public static void main(String[] args) throws IOException, InterruptedException {
        String wildflyHome = "/opt/wildfly-27.0.0.Final"; // 根据实际WildFly安装路径修改
        String managementHost = "localhost";
        int managementPort = 9990;

        // 1. 构建并执行 reload 命令
        final CliCommandBuilder commandBuilder = CliCommandBuilder.of(wildflyHome)
                .setConnection(managementHost + ":" + managementPort)
                .setCommand("reload");

        System.out.println("正在执行 WildFly 服务器重载命令...");
        final Process process = Launcher.of(commandBuilder)
                .inherit() // 继承父进程的输入输出流
                .setRedirectErrorStream(true)
                .launch();

        // 等待 CLI 进程结束，设置一个超时时间以防万一
        if (!process.waitFor(10, TimeUnit.SECONDS)) {
            // 如果 CLI 进程未在指定时间内终止，可能存在问题
            throw new RuntimeException("CLI 进程未能在指定时间内终止。");
        }
        System.out.println("CLI 进程已终止，WildFly 服务器重载操作已启动。");

        // 此时，WildFly 服务器已开始重载，但尚未完全启动。
        // 接下来需要轮询服务器状态。
        waitForWildFlyServerToStart(managementHost, managementPort);

        System.out.println("WildFly 服务器已成功重载并启动。可以执行后续操作。");
    }

    // ... 下一步骤的方法 ...
}

<dependencies>
    <!-- WildFly CLI 核心库 -->
    <dependency>
        <groupId>org.wildfly.core</groupId>
        <artifactId>wildfly-cli</artifactId>
        <version>20.0.0.Final</version> <!-- 根据您的WildFly版本调整 -->
    </dependency>
    <!-- WildFly 客户端配置 -->
    <dependency>
        <groupId>org.wildfly.core</groupId>
        <artifactId>wildfly-client-config</artifactId>
        <version>2.0.0.Final</version> <!-- 根据您的WildFly版本调整 -->
    </dependency>
    <!-- WildFly 控制器客户端 -->
    <dependency>
        <groupId>org.jboss.as</groupId>
        <artifactId>jboss-as-controller-client</artifactId>
        <version>19.0.0.Final</version> <!-- 根据您的WildFly版本调整 -->
    </dependency>
    <!-- WildFly Maven 插件核心，包含 ServerHelper -->
    <dependency>
        <groupId>org.wildfly.plugins</groupId>
        <artifactId>wildfly-maven-plugin-core</artifactId>
        <version>4.2.1.Final</version> <!-- 根据您的WildFly版本调整 -->
    </dependency>
</dependencies>

import org.jboss.as.controller.client.ModelControllerClient;
import org.jboss.as.controller.client.helpers.Operations;
import org.jboss.dmr.ModelNode;
import org.wildfly.plugins.core.ServerHelper; // 引入 ServerHelper
import org.jboss.as.controller.client.Address; // For PathAddress if needed directly

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class WildFlyReloadWaiter {
    // ... main 方法在上面 ...

    private static void waitForWildFlyServerToStart(String host, int port) throws IOException, InterruptedException {
        System.out.println("正在轮询 WildFly 服务器状态，等待其完全启动...");
        try (ModelControllerClient client = ModelControllerClient.Factory.create(host, port)) {
            long startTime = System.currentTimeMillis();
            final long TIMEOUT_MS = 300 * 1000; // 设置一个合理的超时时间，例如 5 分钟

            // 轮询服务器状态直到其运行
            while (!ServerHelper.isStandaloneRunning(client)) {
                if (System.currentTimeMillis() - startTime > TIMEOUT_MS) {
                    throw new RuntimeException("WildFly 服务器在指定时间内未能启动。");
                }
                TimeUnit.MILLISECONDS.sleep(500L); // 每隔 500 毫秒检查一次
            }
            System.out.println("WildFly 服务器已成功启动并响应。");

            // 服务器已启动，现在可以读取其运行模式或其他详细信息
            // 示例：读取根资源，包含运行时信息
            // Operations.createReadResourceOperation(Address.root(), true)
            // 在 jboss-as-controller-client 19.0.0.Final 中，PathAddress 已被废弃，推荐使用 Address.root()
            ModelNode operation = Operations.createReadResourceOperation(Address.root(), true); // include-runtime=true
            ModelNode response = client.execute(operation);

            if (Operations.isSuccessfulOutcome(response)) {
                ModelNode result = Operations.readResult(response);
                // 提取并打印运行模式
                if (result.hasDefined("running-mode")) {
                    System.out.printf("服务器运行模式: %s%n", result.get("running-mode").asString());
                } else {
                    System.out.println("未能获取服务器运行模式。");
                }
            } else {
                throw new RuntimeException("未能读取服务器详细信息: " + Operations.getFailureDescription(response).asString());
            }

        } catch (Exception e) {
            // 捕获所有可能的异常，包括 IOException、InterruptedException 等
            throw new RuntimeException("等待 WildFly 服务器重载过程中发生错误: " + e.getMessage(), e);
        }
    }
}