JavaFX软件设计

Question

在 JavaFX 应用程序中，必须对 javafx.application.Application 进行子类化，并且继承的 launch() 方法虽然是公共(public)的，但必须从该派生类中调用，否则会引发异常。然后，launch() 方法使用反射来实例化派生类，这使得在启动时很难在不丢失类成员的情况下设置它们的值。所有这些对我来说都是完全不寻常的，我想知道为什么启动 JavaFX 应用程序如此复杂，如果这种软件设计(设计模式？)有名字，或者它只是糟糕的设计？

编辑:

更具体地说，我想使用观察者模式，这样我的 java 应用程序就会在加载文档时收到通知，如下所示:

public class MyDocumentLoader extends Application
{
    private ChangeListener<Worker.State> changeListener;

    public void setChangeListener(ChangeListener<Worker.State> changeListener)
    {
        this.changeListener = changeListener;
    }

    ...

    public void loadDocument(String url)
    {
        webEngine.getLoadWorker().stateProperty().addListener(changeListener);
        webEngine.load(url);
    }

    ...

}

我需要在多种方法中使用回调成员，理想情况下我可以拥有多个加载文档的类实例，这样我就可以为不同的 URL 设置不同的 ChangeListener。

Answer 1

我的猜测是，这种设计的动机是(大量)Swing 应用程序编写不正确，“主”JFrame 被实例化并显示在错误的线程上(即不是在 AWT 事件调度线程上)。我的猜测是，如此多的 Swing 应用程序编写不正确，以至于他们必须对框架进行防御性编码以防止错误的使用，并且他们希望使用 JavaFX 来避免这种情况。

强制(好吧，几乎是强制，有一些破解方法)FX 应用程序以这种方式启动，使得以类似的方式错误地编写应用程序变得更加困难。 launch 方法(以及等效的 Oracle JVM 启动过程，如果您有一个没有 main 方法且没有调用 launch 的 Application 子类)做了相当多的样板工作:它启动 FX 工具包，实例化 Application 子类并调用其 init() 方法，然后在 FX Application 上Thread 实例化主 Stage 并将其传递给 Application 子类的 start(...) 方法。这样可以确保一切都在正确的线程上运行。

您基本上应该将 JavaFX 应用程序中的 start(...) 方法视为“传统”应用程序中 main(...) 方法的替代品Java 应用程序，据了解，它是在 FX 应用程序线程上调用的。

我的建议是 Application 子类应该尽可能小；它应该委托(delegate)给其他东西来实际创建 UI，然后应该将其放置在主阶段并显示它。包含一个 main 方法，该方法除了调用 launch(...) 之外什么也不做，作为不支持 JavaFX 的 JVM 的后备。任何 JVM 中都应该只存在一个 Application 子类的一个实例。这样您的 Application 子类就没有需要设置的类成员，因此您描述的问题就不会出现。

如果您使用 FXML，这实际上是相当自然的:start(...) 方法本质上只是委托(delegate)给 FXML Controller 对来完成实际工作。如果您不使用 FXML，请创建一个单独的类来执行实际布局等，并委托(delegate)给它。请参阅this related question这得到了同样的想法。

另请注意您的陈述

the inherited launch() method, although it's public, must be called from within this derived class

并不完全准确，因为有一个 overloaded form of the launch(...) method您可以在其中指定应用程序子类。因此，如果您确实需要，您可以创建一个用于启动 FX 工具包的 stub :

public class FXStarter extends Application {

    @Override
    public void start(Stage primaryStage) {
        // no-op
    }
}

现在你可以做:

public class MyRegularApplication {

    public static void main(String[] args) {
        // start FX toolkit:
        new Thread(() -> Application.launch(FXStarter.class)).start();
        // other stuff here...
    }
}

请注意，launch 在 FX 工具包关闭之前不会返回，因此必须将此调用放入另一个线程中。这可能会产生竞争条件，您可能会在 launch(...) 实际初始化它之前尝试执行需要 FX 工具包的操作，因此您应该防止这种情况:

public class FXStarter extends Application {

    private static final CountDownLatch latch = new CountDownLatch(1);

    public static void awaitFXToolkit() throws InterruptedException {
       latch.await();
    }

    @Override
    public void init() {
        latch.countDown();
    }

    @Override
    public void start(Stage primaryStage) {
        // no-op
    }
}

然后

public class MyRegularApplication {

    public static void main(String[] args) throws InterruptedException {
        // start FX toolkit:
        new Thread(() -> Application.launch(FXStarter.class)).start();
        FXStarter.awaitFXToolkit();
        // other stuff here...
    }
}

SSCCE(我只是将内部类用于所有内容，因此运行起来很方便，但在现实生活中这些将是独立的类):

import java.util.Random;
import java.util.concurrent.CountDownLatch;

import javafx.application.Application;
import javafx.application.Platform;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class BackgroundProcessDrivenApp {

    public static void main(String[] args) throws InterruptedException {
        Platform.setImplicitExit(false);
        new Thread(() -> Application.launch(FXStarter.class)).start();
        FXStarter.awaitFXToolkit();
        new MockProcessor().doStuff() ;
    }

    public static class FXStarter extends Application {

        private static final CountDownLatch latch = new CountDownLatch(1);

        @Override
        public void init() {
            latch.countDown();
        }

        public static void awaitFXToolkit() throws InterruptedException {
            latch.await();
        }

        @Override
        public void start(Stage primaryStage) { }
    }

    public static class MockProcessor {

        private final int numEvents = 10 ;

        public void doStuff() {
            Random rng = new Random();
            try {
                for (int event = 1 ; event <= numEvents; event++) {
                    // just sleep to mimic waiting for background service...
                    Thread.sleep(rng.nextInt(5000) + 5000);
                    String message = "Event " + event + " occurred" ;
                    Platform.runLater(() -> new Messager(message).showMessageInNewWindow());
                }
            } catch (InterruptedException exc) {
                Thread.currentThread().interrupt();
            } finally {
                Platform.setImplicitExit(true);
            }
        }
    }

    public static class Messager {
        private final String message ;

        public Messager(String message) {
            this.message = message ;
        }

        public void showMessageInNewWindow() {
            Stage stage = new Stage();
            Label label = new Label(message);
            Button button = new Button("OK");
            button.setOnAction(e -> stage.hide());
            VBox root = new VBox(10, label, button);
            root.setAlignment(Pos.CENTER);
            Scene scene = new Scene(root, 350, 120);
            stage.setScene(scene);
            stage.setAlwaysOnTop(true);
            stage.show();
        }
    }
}