处理已启动的 JavaFX 应用程序

Question

如何使用以下代码获取 JavaFX 应用程序的句柄？

CPUUsageChart.launch(CPUUsageChart.class);

CPUUsageChart 从 JavaFX 扩展应用程序，我从一个简单的 Java 项目的主要方法启动它。

我最终想要实现的是，我可以在简单的 Java 代码中启动应用程序并使用它的方法，这样我就不必在扩展应用程序的构造函数中进行调用class。我只想使用 JavaFX 的功能来绘制图表并将它们保存到 HDD 以备后用，但我不需要看到 JavaFX 中制作的任何 GUI。

Answer 1

建议的解决方案

您可以 only launch an application once，因此您的应用程序将永远只有一个实例 class。

由于应用程序只有一个实例，所以可以在应用程序启动时将实例的引用存储在应用程序的静态变量中，并根据需要从静态方法（a一种单例模式）。

注意事项

必须注意确保：

实例在您尝试使用之前可用。
正确遵守线程规则。
JavaFX 平台在不再需要时适当关闭。

示例解决方案

下面的示例代码使用锁和条件来确保应用程序实例在您尝试使用它之前可用。当不再需要时，它还需要明确关闭 JavaFX 平台。

感谢 Whosebug 用户 James-D 对这段代码的编辑帮助。

import javafx.application.Application;
import javafx.application.Platform;
import javafx.collections.ObservableList;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.Scene;
import javafx.scene.chart.LineChart;
import javafx.scene.chart.NumberAxis;
import javafx.scene.chart.XYChart;
import javafx.stage.Stage;
import javax.imageio.ImageIO;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CPUUsageChart extends Application {
    private static CPUUsageChart appInstance;

    private static final Lock lock = new ReentrantLock();
    private static final Condition appStarted = lock.newCondition();

    /**
     * Starts the application and records the instance.
     * Sets the JavaFX platform not to exit implicitly. 
     * (e.g. an explicit call to Platform.exit() is required
     *       to exit the JavaFX Platform).
     */
    @Override 
    public void start(Stage primaryStage) {
        lock.lock();

        try {
            Platform.setImplicitExit(false);
            appInstance = this;
            appStarted.signalAll();
        } finally {
            lock.unlock();
        }
    }

    /**
     * Get an instance of the application.
     * If the application has not already been launched it will be launched.
     * This method will block the calling thread until the
     * start method of the application has been invoked and the instance set. 
     * @return application instance (will not return null).
     */
    public static CPUUsageChart getInstance() throws InterruptedException {
        lock.lock();

        try {
            if (appInstance == null) {
                Thread launchThread = new Thread(
                        () -> launch(CPUUsageChart.class), 
                        "chart-launcher"
                );
                launchThread.setDaemon(true);
                launchThread.start();
                appStarted.await();
            }
        } finally {
            lock.unlock();
        }

        return appInstance;
    } 

    /**
     * Public method which can be called to perform the main operation 
     * for this application.
     * (render a chart and store the chart image to disk).
     * This method can safely be called from any thread.
     * Once this method is invoked, the data list should not be modified
     * off of the JavaFX application thread.
     */
    public void renderChart(
        ObservableList<XYChart.Data<Number, Number>> data
    ) {
        // ensure chart is rendered on the JavaFX application thread.
        if (!Platform.isFxApplicationThread()) {
            Platform.runLater(() -> this.renderChartImpl(data));
        } else {
            this.renderChartImpl(data);
        } 
    }

    /**
     * Private method which can be called to perform the main operation 
     * for this application.
     * (render a chart and store the chart image to disk).
     * This method must be invoked on the JavaFX application thread.
     */
    private void renderChartImpl(
        ObservableList<XYChart.Data<Number, Number>> data
    ) {
        LineChart<Number, Number> chart = new LineChart<>(
                new NumberAxis(),
                new NumberAxis(0, 100, 10)
        );
        chart.setAnimated(false);
        chart.getData().add(
                new XYChart.Series<>("CPU Usage", data)
        );

        Scene scene = new Scene(chart);

        try {
            LocalDateTime now = LocalDateTime.now();
            File file = Paths.get(
                    System.getProperty("user.dir"),
                    "cpu-usage-chart-" + now + ".png"
            ).toFile();
            ImageIO.write(
                    SwingFXUtils.fromFXImage(
                            chart.snapshot(null, null),
                            null
                    ),
                    "png",
                    file
            );

            System.out.println("Chart saved as: " + file);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

要使用它（从任何线程）：

try {
     // get chartApp instance, blocking until it is available.
     CPUUsageChart chartApp = CPUUsageChart.getInstance();
     // call render chart as many times as you want
     chartApp.renderChart(cpuUsageData);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
} finally {
     // note your program should only ever exit the platform once.
     Platform.exit(); 
}

完整的示例应用程序创建了 cpu 使用数据的五个图表，每个图表中有十个样本，每个样本间隔 100 毫秒。当示例调用图表应用程序呈现图表时，它将在当前 java 工作目录中创建图表 png 图像文件，文件名将输出到系统控制台。没有显示 JavaFX 阶段或 window。

示例代码 CPU 用法复制自：How to get percentage of CPU usage of OS from java

import javafx.application.Platform;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.chart.XYChart;

import javax.management.*;
import java.lang.management.ManagementFactory;

public class ChartTest {
    public static void main(String[] args) {
        try {
            CPUUsageChart chart = CPUUsageChart.getInstance();
            for (int i = 0; i < 5; i++) {
                ObservableList<XYChart.Data<Number, Number>> cpuUsageData = FXCollections.observableArrayList();
                for (int j = 0; j < 10; j++) {
                    cpuUsageData.add(
                           new XYChart.Data<>(
                                   j / 10.0, 
                                   getSystemCpuLoad()
                           )
                    );
                    Thread.sleep(100);
                }
                chart.renderChart(cpuUsageData);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (MalformedObjectNameException | ReflectionException | InstanceNotFoundException e) {
            e.printStackTrace();
        } finally {
            Platform.exit();
        }
    }

    public static double getSystemCpuLoad() throws MalformedObjectNameException, ReflectionException, InstanceNotFoundException {
        MBeanServer mbs    = ManagementFactory.getPlatformMBeanServer();
        ObjectName name    = ObjectName.getInstance("java.lang:type=OperatingSystem");
        AttributeList list = mbs.getAttributes(name, new String[]{ "SystemCpuLoad" });

        if (list.isEmpty())     return Double.NaN;

        Attribute att = (Attribute)list.get(0);
        Double value  = (Double)att.getValue();

        if (value == -1.0)      return Double.NaN;  // usually takes a couple of seconds before we get real values

        return ((int)(value * 1000) / 10.0);        // returns a percentage value with 1 decimal point precision
    }
}

示例输出（Y 轴上的使用百分比 CPU，X 轴上的时间为十分之一秒的采样间隔）。

背景信息

Application javadoc 进一步了解 JavaFX 应用程序生命周期。
相关问题：How do I start again an external JavaFX program? Launch prevents this, even if the JavaFX program ended with Platform.Exit

替代实现

您可以使用 JFXPanel 而不是扩展应用程序的 class。但是，那么您的应用程序也会依赖于 Swing。
您可以让您的应用程序的主要 class 扩展应用程序，这样当您的应用程序启动时该应用程序会自动启动，而不是只为您的使用情况表创建一个单独的应用程序。
如果你有很多图表要渲染，你可以看看这个 off screen chart renderer implementation。

处理已启动的 JavaFX 应用程序

Handle on launched JavaFX Application

java

charts

javafx

launch