传递JavaFX FXML参数

Question

传递JavaFX FXML参数

javafxparametersdependency-injectionparameter-passingfxml

225

如何在JavaFX中向辅助窗口传递参数？有没有一种方法可以与相应的控制器进行通信？

例如：用户从 TableView 中选择一个客户，然后打开一个新窗口，展示该客户的信息。

Stage newStage = new Stage();
try 
{
    AnchorPane page = (AnchorPane) FXMLLoader.load(HectorGestion.class.getResource(fxmlResource));
    Scene scene = new Scene(page);
    newStage.setScene(scene);
    newStage.setTitle(windowTitle);
    newStage.setResizable(isResizable);
    if(showRightAway) 
    {
        newStage.show();
    }
}

newStage 将成为新窗口。问题是，我找不到一种方法告诉控制器在哪里查找客户信息（通过将ID作为参数传递）。

有任何想法吗？

- Alvaro

请检查一下这个是否有效：https://dev59.com/SmYq5IYBdhLWcg3wkRi_#14432578 - Dynelight

@Alvaro：你解决了吗？你能把参数从一个控制器传递到另一个控制器文件吗？ - Java Man

3

是的，jewelsea 给出了一本书级别的解释。这就是为什么我接受了他的答案。 - Alvaro

10个回答

18

我知道这篇文章已经很老了，而且已经有一些很好的答案了，但我想制作一个简单的MCVE来演示一种方法，并让新手程序员快速了解概念。

在这个例子中，我们将使用5个文件：

Main.java - 用于启动应用程序并调用第一个控制器。
Controller1.java - 第一个FXML布局的控制器。
Controller2.java - 第二个FXML布局的控制器。
Layout1.fxml - 第一个场景的FXML布局。
Layout2.fxml - 第二个场景的FXML布局。

所有文件都完整列在本文底部。

目标：演示从Controller1向Controller2以及相反方向传递值。

程序流程：

第一个场景包含一个TextField、一个Button和一个Label。当单击Button时，加载并显示第二个窗口，包括在TextField中输入的文本。
在第二个场景中，也有一个TextField、一个Button和一个Label。Label将显示在第一个场景中输入的文本。
在第二个场景的TextField中输入文本并单击其Button后，第一个场景的Label将更新以显示输入的文本。

这是一个非常简单的演示，肯定可以进行改进，但应该可以非常清楚地表明概念。

代码本身也带有一些细节注释，说明正在发生什么以及如何进行操作。

代码

Main.java:

import javafx.application.Application;
import javafx.stage.Stage;

public class Main extends Application {

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {

        // Create the first controller, which loads Layout1.fxml within its own constructor
        Controller1 controller1 = new Controller1();

        // Show the new stage
        controller1.showStage();

    }
}

Controller1.java：

import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.stage.Stage;

import java.io.IOException;

public class Controller1 {

    // Holds this controller's Stage
    private final Stage thisStage;

    // Define the nodes from the Layout1.fxml file. This allows them to be referenced within the controller
    @FXML
    private TextField txtToSecondController;
    @FXML
    private Button btnOpenLayout2;
    @FXML
    private Label lblFromController2;

    public Controller1() {

        // Create the new stage
        thisStage = new Stage();

        // Load the FXML file
        try {
            FXMLLoader loader = new FXMLLoader(getClass().getResource("Layout1.fxml"));

            // Set this class as the controller
            loader.setController(this);

            // Load the scene
            thisStage.setScene(new Scene(loader.load()));

            // Setup the window/stage
            thisStage.setTitle("Passing Controllers Example - Layout1");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Show the stage that was loaded in the constructor
     */
    public void showStage() {
        thisStage.showAndWait();
    }

    /**
     * The initialize() method allows you set setup your scene, adding actions, configuring nodes, etc.
     */
    @FXML
    private void initialize() {

        // Add an action for the "Open Layout2" button
        btnOpenLayout2.setOnAction(event -> openLayout2());
    }

    /**
     * Performs the action of loading and showing Layout2
     */
    private void openLayout2() {

        // Create the second controller, which loads its own FXML file. We pass a reference to this controller
        // using the keyword [this]; that allows the second controller to access the methods contained in here.
        Controller2 controller2 = new Controller2(this);

        // Show the new stage/window
        controller2.showStage();

    }

    /**
     * Returns the text entered into txtToSecondController. This allows other controllers/classes to view that data.
     */
    public String getEnteredText() {
        return txtToSecondController.getText();
    }

    /**
     * Allows other controllers to set the text of this layout's Label
     */
    public void setTextFromController2(String text) {
        lblFromController2.setText(text);
    }
}

Controller2.java：

import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.stage.Stage;

import java.io.IOException;

public class Controller2 {

    // Holds this controller's Stage
    private Stage thisStage;

    // Will hold a reference to the first controller, allowing us to access the methods found there.
    private final Controller1 controller1;

    // Add references to the controls in Layout2.fxml
    @FXML
    private Label lblFromController1;
    @FXML
    private TextField txtToFirstController;
    @FXML
    private Button btnSetLayout1Text;

    public Controller2(Controller1 controller1) {
        // We received the first controller, now let's make it usable throughout this controller.
        this.controller1 = controller1;

        // Create the new stage
        thisStage = new Stage();

        // Load the FXML file
        try {
            FXMLLoader loader = new FXMLLoader(getClass().getResource("Layout2.fxml"));

            // Set this class as the controller
            loader.setController(this);

            // Load the scene
            thisStage.setScene(new Scene(loader.load()));

            // Setup the window/stage
            thisStage.setTitle("Passing Controllers Example - Layout2");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Show the stage that was loaded in the constructor
     */
    public void showStage() {
        thisStage.showAndWait();
    }

    @FXML
    private void initialize() {

        // Set the label to whatever the text entered on Layout1 is
        lblFromController1.setText(controller1.getEnteredText());

        // Set the action for the button
        btnSetLayout1Text.setOnAction(event -> setTextOnLayout1());
    }

    /**
     * Calls the "setTextFromController2()" method on the first controller to update its Label
     */
    private void setTextOnLayout1() {
        controller1.setTextFromController2(txtToFirstController.getText());
    }

}

布局1.fxml：

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.geometry.Insets?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.HBox?>
<?import javafx.scene.layout.VBox?>
<AnchorPane xmlns="http://javafx.com/javafx/9.0.1" xmlns:fx="http://javafx.com/fxml/1">
    <VBox alignment="CENTER" spacing="10.0">
        <padding>
            <Insets bottom="10.0" left="10.0" right="10.0" top="10.0"/>
        </padding>
        <Label style="-fx-font-weight: bold;" text="This is Layout1!"/>
        <HBox alignment="CENTER_LEFT" spacing="10.0">
            <Label text="Enter Text:"/>
            <TextField fx:id="txtToSecondController"/>
            <Button fx:id="btnOpenLayout2" mnemonicParsing="false" text="Open Layout2"/>
        </HBox>
        <VBox alignment="CENTER">
            <Label text="Text From Controller2:"/>
            <Label fx:id="lblFromController2" text="Nothing Yet!"/>
        </VBox>
    </VBox>
</AnchorPane>

Layout2.fxml:

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.geometry.Insets?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.HBox?>
<?import javafx.scene.layout.VBox?>
<AnchorPane xmlns="http://javafx.com/javafx/9.0.1" xmlns:fx="http://javafx.com/fxml/1">
    <VBox alignment="CENTER" spacing="10.0">
        <padding>
            <Insets bottom="10.0" left="10.0" right="10.0" top="10.0"/>
        </padding>
        <Label style="-fx-font-weight: bold;" text="Welcome to Layout 2!"/>
        <VBox alignment="CENTER">
            <Label text="Text From Controller1:"/>
            <Label fx:id="lblFromController1" text="Nothing Yet!"/>
        </VBox>
        <HBox alignment="CENTER_LEFT" spacing="10.0">
            <Label text="Enter Text:"/>
            <TextField fx:id="txtToFirstController"/>
            <Button fx:id="btnSetLayout1Text" mnemonicParsing="false" text="Set Text on Layout1"/>
        </HBox>
    </VBox>
</AnchorPane>

- Zephyr

1

能否在FXML文件中设置控制器？因为删除loader.setController(this)这行代码并在FXML文件中添加控制器会导致应用程序崩溃。 - Halfacht

1

如果FXML是从控制器本身加载的，则不需要这样做。例如，如果您从Main类中加载FXML，则可以在FXML文件中定义控制器，并使用loader.getController()获取对其的引用。 - Zephyr

最终我成功找到了解决方案，这是一个很好的例子。我将其实现到我的项目中，现在我正在尝试让两个窗口同时打开，并使其中一个成为模态窗口。不幸的是，只有一个窗口打开了。有人能帮忙吗？ - jabba

11

这里有一个通过命名空间向fxml文档传递参数的示例。

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.layout.BorderPane?>
<?import javafx.scene.layout.VBox?>
<VBox xmlns="http://javafx.com/javafx/null" xmlns:fx="http://javafx.com/fxml/1">
    <BorderPane>
        <center>
            <Label text="$labelText"/>
        </center>
    </BorderPane>
</VBox>

为命名空间变量 labelText 定义值为 External Text：

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

import java.io.IOException;

public class NamespaceParameterExampleApplication extends Application {

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) throws IOException {
        final FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("namespace-parameter-example.fxml"));

        fxmlLoader.getNamespace()
                  .put("labelText", "External Text");

        final Parent root = fxmlLoader.load();

        primaryStage.setTitle("Namespace Parameter Example");
        primaryStage.setScene(new Scene(root, 400, 400));
        primaryStage.show();
    }
}

- user1503636

需要注意的是，有些键是在内部使用的：例如 FXMLLoader.CONTROLLER_KEYWORD、FXMLLoader.LOCATION_KEY、FXMLLoader.RESOURCES_KEY 和作为 fx:id 属性值使用的任何字符串。 - fabian

谢谢这个，我的另一个场景只是一个容器，显示了之前在我的主场景上显示的文本。现在我可以有一个fxml文件，通过命名空间变量初始化内容，可以在多个地方重复使用。我不需要创建任何新方法或更改我的构造函数或初始化程序 - 只需在我的FXML中添加变量，并在主控制器中的fxmloader代码中添加一行即可。 - SystemsInCode

7

javafx.scene.Node类有一对方法setUserData(Object)和Object getUserData()，您可以使用它们将信息添加到节点中。因此，您可以调用page.setUserData(info);控制器可以检查是否设置了info。如果需要，还可以使用ObjectProperty进行前后数据传输。

请参阅文档：http://docs.oracle.com/javafx/2/api/javafx/fxml/doc-files/introduction_to_fxml.html在“第一个版本中，handleButtonAction()标记为@FXML，以允许在控制器文档中定义的标记调用它。在第二个示例中，按钮字段被注释以允许加载器设置其值。initialize()方法也被类似地注释。”

所以，您需要将控制器与节点相关联，并向节点设置用户数据。

- Alexander Kirov

Stage.getScene() -> Scene.getRoot() -> 使用Parent.getChildrenUnmodifiable()进行递归搜索。这种方法非常不优雅。如果有人能提供更好的建议，那就太好了。 - Alexander Kirov

看起来 Stage.getScene().getRoot() 是正确的方式！谢谢 - Alvaro

4

这个有效..

记住第一次打印传递值时会得到null，你可以在Windows加载后使用它，对于任何其他组件你想编写的代码也是如此。

第一个控制器

try {
    Stage st = new Stage();
    FXMLLoader loader = new FXMLLoader(getClass().getResource("/com/inty360/free/form/MainOnline.fxml"));

    Parent sceneMain = loader.load();

    MainOnlineController controller = loader.<MainOnlineController>getController();
    controller.initVariable(99L);

    Scene scene = new Scene(sceneMain);
    st.setScene(scene);
    st.setMaximized(true);
    st.setTitle("My App");
    st.show();
} catch (IOException ex) {
    Logger.getLogger(LoginController.class.getName()).log(Level.SEVERE, null, ex);
}

另一个控制器

public void initVariable(Long id_usuario){
    this.id_usuario = id_usuario;
    label_usuario_nombre.setText(id_usuario.toString());
}

- diego matos - keke

1

当您从第一个控制器传递参数到第二个控制器时，这项工作是有效的，但如何从第二个控制器传递参数到第一个控制器呢？我的意思是在 first.fxml 加载后。 - Menai Ala Eddine - Aladdin

@XlintXms请参考相关问题JavaFX FXML从控制器A传递参数到B并返回，该问题解答了您的附加问题。 - jewelsea

3

您需要创建一个上下文类。

public class Context {
    private final static Context instance = new Context();
    public static Context getInstance() {
        return instance;
    }

    private Connection con;
    public void setConnection(Connection con)
    {
        this.con=con;
    }
    public Connection getConnection() {
        return con;
    }

    private TabRoughController tabRough;
    public void setTabRough(TabRoughController tabRough) {
        this.tabRough=tabRough;
    }

    public TabRoughController getTabRough() {
        return tabRough;
    }
}

你只需要在初始化时设置控制器的实例，使用以下代码：

Context.getInstance().setTabRough(this);

你可以在整个应用程序中使用它，只需使用以下方式：

TabRoughController cont=Context.getInstance().getTabRough();

现在，您可以从整个应用程序向任何控制器传递参数。

- CTN

我们使用这种方法，效果非常好。我喜欢在构造函数或初始化方法中访问数据，而不必在控制器构建后设置数据。 - Bob

2

你可以这样做。你需要在第一个控制器中添加以下内容：

YourController controller = loader.getController();     
controller.setclient(client);

在第二个中声明一个客户端，然后在您的控制器底部：最初的回答。

public void setclien(Client c) {
    this.client = c;
}

- Montassar Bouajina

1

这里有一个使用Guice注入的控制器的示例。

/**
 * Loads a FXML file and injects its controller from the given Guice {@code Provider}
 */
public abstract class GuiceFxmlLoader {

   public GuiceFxmlLoader(Stage stage, Provider<?> provider) {
      mStage = Objects.requireNonNull(stage);
      mProvider = Objects.requireNonNull(provider);
   }

   /**
    * @return the FXML file name
    */
   public abstract String getFileName();

   /**
    * Load FXML, set its controller with given {@code Provider}, and add it to {@code Stage}.
    */
   public void loadView() {
      try {
         FXMLLoader loader = new FXMLLoader(getClass().getClassLoader().getResource(getFileName()));
         loader.setControllerFactory(p -> mProvider.get());
         Node view = loader.load();
         setViewInStage(view);
      }
      catch (IOException ex) {
         LOGGER.error("Failed to load FXML: " + getFileName(), ex);
      }
   }

   private void setViewInStage(Node view) {
      BorderPane pane = (BorderPane)mStage.getScene().getRoot();
      pane.setCenter(view);
   }

   private static final Logger LOGGER = Logger.getLogger(GuiceFxmlLoader.class);

   private final Stage mStage;
   private final Provider<?> mProvider;
}

这里是一个加载器的具体实现：

public class ConcreteViewLoader extends GuiceFxmlLoader {

   @Inject
   public ConcreteViewLoader(Stage stage, Provider<MyController> provider) {
      super(stage, provider);
   }

   @Override
   public String getFileName() {
      return "my_view.fxml";
   }
}

注意，此示例将视图加载到BorderPane的中心，该BorderPane是Scene在Stage中的根节点。这与示例无关（是我特定用例的实现细节），但决定保留它，因为一些人可能会发现它有用。

- jenglert

-3

你可以决定使用公共可观察列表来存储公共数据，或者只需创建一个公共设置器方法来存储数据并从相应的控制器中检索。

- Nospaniol Noah

-4

为什么要回答一个六年前的问题？
任何编程语言中最基本的概念之一是如何在不同的（窗口、表单或页面）之间进行导航。同时，在进行这种导航时，开发人员经常希望从一个（窗口、表单或页面）传递数据并显示或使用传递的数据。
虽然这里的大多数答案提供了如何完成此操作的良好至优秀的示例，但我们认为我们应该再加强一两个方面。
我们说三个方面，因为我们将在三个（窗口、表单或页面）之间导航，并使用静态变量的概念来传递数据到（窗口、表单或页面）周围。
我们还将在导航时包括一些决策代码。

public class Start extends Application {

    @Override
    public void start(Stage stage) throws Exception {
        // This is MAIN Class which runs first
        Parent root = FXMLLoader.load(getClass().getResource("start.fxml"));
        Scene scene = new Scene(root);
        stage.setScene(scene);
        stage.setResizable(false);// This sets the value for all stages
        stage.setTitle("Start Page"); 
        stage.show();
        stage.sizeToScene();
    }

    public static void main(String[] args) {
        launch(args);
    } 
}

启动控制器

public class startController implements Initializable {

@FXML Pane startPane,pageonePane;
@FXML Button btnPageOne;
@FXML TextField txtStartValue;
public Stage stage;
public static int intSETonStartController;
String strSETonStartController;

@FXML
private void toPageOne() throws IOException{

    strSETonStartController = txtStartValue.getText().trim();


        // yourString != null && yourString.trim().length() > 0
        // int L = testText.length();
        // if(L == 0){
        // System.out.println("LENGTH IS "+L);
        // return;
        // }
        /* if (testText.matches("[1-2]") && !testText.matches("^\\s*$")) 
           Second Match is regex for White Space NOT TESTED !
        */

        String testText = txtStartValue.getText().trim();
        // NOTICE IF YOU REMOVE THE * CHARACTER FROM "[1-2]*"
        // NO NEED TO CHECK LENGTH it also permited 12 or 11 as valid entry 
        // =================================================================
        if (testText.matches("[1-2]")) {
            intSETonStartController = Integer.parseInt(strSETonStartController);
        }else{
            txtStartValue.setText("Enter 1 OR 2");
            return;
        }

        System.out.println("You Entered = "+intSETonStartController);
        stage = (Stage)startPane.getScene().getWindow();// pane you are ON
        pageonePane = FXMLLoader.load(getClass().getResource("pageone.fxml"));// pane you are GOING TO
        Scene scene = new Scene(pageonePane);// pane you are GOING TO
        stage.setScene(scene);
        stage.setTitle("Page One"); 
        stage.show();
        stage.sizeToScene();
        stage.centerOnScreen();  
}

private void doGET(){
    // Why this testing ?
    // strSENTbackFROMPageoneController is null because it is set on Pageone
    // =====================================================================
    txtStartValue.setText(strSENTbackFROMPageoneController);
    if(intSETonStartController == 1){
      txtStartValue.setText(str);  
    }
    System.out.println("== doGET WAS RUN ==");
    if(txtStartValue.getText() == null){
       txtStartValue.setText("");   
    }
}

@Override
public void initialize(URL url, ResourceBundle rb) {
    // This Method runs every time startController is LOADED
     doGET();
}    
}

页面一控制器

public class PageoneController implements Initializable {

@FXML Pane startPane,pageonePane,pagetwoPane;
@FXML Button btnOne,btnTwo;
@FXML TextField txtPageOneValue;
public static String strSENTbackFROMPageoneController;
public Stage stage;

    @FXML
private void onBTNONE() throws IOException{

        stage = (Stage)pageonePane.getScene().getWindow();// pane you are ON
        pagetwoPane = FXMLLoader.load(getClass().getResource("pagetwo.fxml"));// pane you are GOING TO
        Scene scene = new Scene(pagetwoPane);// pane you are GOING TO
        stage.setScene(scene);
        stage.setTitle("Page Two"); 
        stage.show();
        stage.sizeToScene();
        stage.centerOnScreen();
}

@FXML
private void onBTNTWO() throws IOException{
    if(intSETonStartController == 2){
        Alert alert = new Alert(AlertType.CONFIRMATION);
        alert.setTitle("Alert");
        alert.setHeaderText("YES to change Text Sent Back");
        alert.setResizable(false);
        alert.setContentText("Select YES to send 'Alert YES Pressed' Text Back\n"
                + "\nSelect CANCEL send no Text Back\r");// NOTE this is a Carriage return\r
        ButtonType buttonTypeYes = new ButtonType("YES");
        ButtonType buttonTypeCancel = new ButtonType("CANCEL", ButtonData.CANCEL_CLOSE);

        alert.getButtonTypes().setAll(buttonTypeYes, buttonTypeCancel);

        Optional<ButtonType> result = alert.showAndWait();
        if (result.get() == buttonTypeYes){
            txtPageOneValue.setText("Alert YES Pressed");
        } else {
            System.out.println("canceled");
            txtPageOneValue.setText("");
            onBack();// Optional
        }
    }
}

@FXML
private void onBack() throws IOException{

    strSENTbackFROMPageoneController = txtPageOneValue.getText();
    System.out.println("Text Returned = "+strSENTbackFROMPageoneController);
    stage = (Stage)pageonePane.getScene().getWindow();
    startPane = FXMLLoader.load(getClass().getResource("start.fxml")); 
    Scene scene = new Scene(startPane);
    stage.setScene(scene);
    stage.setTitle("Start Page"); 
    stage.show();
    stage.sizeToScene();
    stage.centerOnScreen(); 
}

private void doTEST(){
    String fromSTART = String.valueOf(intSETonStartController);
    txtPageOneValue.setText("SENT  "+fromSTART);
    if(intSETonStartController == 1){
       btnOne.setVisible(true);
       btnTwo.setVisible(false);
       System.out.println("INTEGER Value Entered = "+intSETonStartController);  
    }else{
       btnOne.setVisible(false);
       btnTwo.setVisible(true);
       System.out.println("INTEGER Value Entered = "+intSETonStartController); 
    }  
}

@Override
public void initialize(URL url, ResourceBundle rb) {
    doTEST();
}    

}

页面二控制器

public class PagetwoController implements Initializable {

@FXML Pane startPane,pagetwoPane;
public Stage stage;
public static String str;

@FXML
private void toStart() throws IOException{

    str = "You ON Page Two";
    stage = (Stage)pagetwoPane.getScene().getWindow();// pane you are ON
    startPane = FXMLLoader.load(getClass().getResource("start.fxml"));// pane you are GOING TO
    Scene scene = new Scene(startPane);// pane you are GOING TO
    stage.setScene(scene);
    stage.setTitle("Start Page"); 
    stage.show();
    stage.sizeToScene();
    stage.centerOnScreen();  
}

@Override
public void initialize(URL url, ResourceBundle rb) {

}    

}

Below are all the FXML files

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.control.Button?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.text.Font?>

<AnchorPane id="AnchorPane" fx:id="pagetwoPane" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/8.0.60" xmlns:fx="http://javafx.com/fxml/1" fx:controller="atwopage.PagetwoController">
   <children>
      <Button layoutX="227.0" layoutY="62.0" mnemonicParsing="false" onAction="#toStart" text="To Start Page">
         <font>
            <Font name="System Bold" size="18.0" />
         </font>
      </Button>
   </children>
</AnchorPane>

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.text.Font?>

<AnchorPane id="AnchorPane" fx:id="startPane" prefHeight="200.0" prefWidth="400.0" xmlns="http://javafx.com/javafx/8.0.60" xmlns:fx="http://javafx.com/fxml/1" fx:controller="atwopage.startController">
   <children>
      <Label focusTraversable="false" layoutX="115.0" layoutY="47.0" text="This is the Start Pane">
         <font>
            <Font size="18.0" />
         </font>
      </Label>
      <Button fx:id="btnPageOne" focusTraversable="false" layoutX="137.0" layoutY="100.0" mnemonicParsing="false" onAction="#toPageOne" text="To Page One">
         <font>
            <Font size="18.0" />
         </font>
      </Button>
      <Label focusTraversable="false" layoutX="26.0" layoutY="150.0" text="Enter 1 OR 2">
         <font>
            <Font size="18.0" />
         </font>
      </Label>
      <TextField fx:id="txtStartValue" layoutX="137.0" layoutY="148.0" prefHeight="28.0" prefWidth="150.0" />
   </children>
</AnchorPane>

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.text.Font?>

<AnchorPane id="AnchorPane" fx:id="pageonePane" prefHeight="200.0" prefWidth="400.0" xmlns="http://javafx.com/javafx/8.0.60" xmlns:fx="http://javafx.com/fxml/1" fx:controller="atwopage.PageoneController">
   <children>
      <Label focusTraversable="false" layoutX="111.0" layoutY="35.0" text="This is Page One Pane">
         <font>
            <Font size="18.0" />
         </font>
      </Label>
      <Button focusTraversable="false" layoutX="167.0" layoutY="97.0" mnemonicParsing="false" onAction="#onBack" text="BACK">
         <font>
            <Font size="18.0" />
         </font></Button>
      <Button fx:id="btnOne" focusTraversable="false" layoutX="19.0" layoutY="97.0" mnemonicParsing="false" onAction="#onBTNONE" text="Button One" visible="false">
         <font>
            <Font size="18.0" />
         </font>
      </Button>
      <Button fx:id="btnTwo" focusTraversable="false" layoutX="267.0" layoutY="97.0" mnemonicParsing="false" onAction="#onBTNTWO" text="Button Two">
         <font>
            <Font size="18.0" />
         </font>
      </Button>
      <Label focusTraversable="false" layoutX="19.0" layoutY="152.0" text="Send Anything BACK">
         <font>
            <Font size="18.0" />
         </font>
      </Label>
      <TextField fx:id="txtPageOneValue" layoutX="195.0" layoutY="150.0" prefHeight="28.0" prefWidth="150.0" />
   </children>
</AnchorPane>

- Vector

9

抱歉，仅张贴一百行代码而没有解释其功能或为何以此方式执行的答案并不是很好。此外，您张贴的代码组织很差，难以跟踪。 - Zephyr

3

不必对提问者粗鲁无礼。我们在这里都是为了学习。 - Zeyad

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- jewelsea · Accepted Answer

使用MVC

这个回答的大部分内容都集中在直接调用来将参数从调用类传递到控制器。

如果您想要解耦调用方和控制器，并使用更通用的体系结构，涉及到一个具有可设置和可监听属性的模型类以实现控制器间通信，请参阅以下基本概述：

Applying MVC With JavaFx

推荐方法

此答案列举了将参数传递给FXML控制器的不同机制。

对于小型应用程序，我强烈建议直接从调用方传递参数到控制器 - 这是简单、直接的，不需要额外的框架。

对于更大、更复杂的应用程序，值得研究是否要在应用程序中使用Dependency Injection或Event Bus机制。

直接从调用方传递参数到控制器

通过从FXML加载器实例中检索控制器并调用控制器上的方法将自定义数据传递给FXML控制器，以使用所需的数据值对其进行初始化。

类似以下代码：

public Stage showCustomerDialog(Customer customer) {
  FXMLLoader loader = new FXMLLoader(
    getClass().getResource(
      "customerDialog.fxml"
    )
  );

  Stage stage = new Stage(StageStyle.DECORATED);
  stage.setScene(
    new Scene(loader.load())
  );

  CustomerDialogController controller = loader.getController();
  controller.initData(customer);

  stage.show();

  return stage;
}

...

class CustomerDialogController {
  @FXML private Label customerName;
  void initialize() {}
  void initData(Customer customer) {
    customerName.setText(customer.getName());
  }
}

示例代码中构造了一个新的FXMLLoader，即new FXMLLoader(location)。location是一个URL，您可以通过以下方式从FXML资源生成这样的URL：

new FXMLLoader(getClass().getResource("sample.fxml"));

注意不要在FXMLLoader上使用静态负载函数，否则您将无法从加载程序实例中获取控制器。

FXMLLoader实例本身永远不知道任何关于域对象的信息。您不会直接将应用程序特定的域对象传递到FXMLLoader构造函数中，而是：

基于指定位置的fxml标记构建FXMLLoader
从FXMLLoader实例中获取控制器。
调用检索到的控制器上的方法，向控制器提供对域对象的引用。

这篇博客（由另一位作者撰写）提供了一个替代但类似的示例。

在FXMLLoader上设置控制器

CustomerDialogController dialogController = 
    new CustomerDialogController(param1, param2);

FXMLLoader loader = new FXMLLoader(
    getClass().getResource(
        "customerDialog.fxml"
    )
);
loader.setController(dialogController);

Pane mainPane = loader.load();

你可以在代码中构建一个新的控制器，将任何参数从调用者传递到控制器构造函数中。一旦你构建了一个控制器，你可以在调用load()实例方法之前，在FXMLLoader实例上设置它。

在FXML中由于fx:controller定义的限制，我个人更喜欢从FXMLLoader获取控制器而不是将控制器设置到FXMLLoader中。 让控制器从外部静态方法中检索参数 Sergey对Javafx 2.0 How-to Application.getParameters() in a Controller.java file的回答展示了这种方法。 使用依赖注入 FXMLLoader支持依赖注入系统，如Guice、Spring或Java EE CDI，通过允许你在FXMLLoader上设置自定义控制器工厂。这提供了一个回调，你可以使用它来创建具有相关依赖值注入的控制器实例。

以下是关于JavaFX应用程序和控制器依赖注入的示例，使用Spring进行注入。答案提供在以下链接中:

Adding Spring Dependency Injection in JavaFX (JPA Repo, Service)

一个非常好的、干净的依赖注入方法是afterburner.fx框架，它有一个使用该框架的样例air-hacks应用程序。afterburner.fx依靠JEE6 javax.inject执行依赖注入。

使用事件总线

FXML规范的原始创建者和实现者Greg Brown经常建议考虑使用事件总线（例如Guava EventBus）来在FXML实例化的控制器和其他应用程序逻辑之间进行通信。

事件总线是一个简单但功能强大的发布/订阅API，具有注解功能，允许普通Java对象在JVM中相互通信，而无需彼此引用。

跟进问答

对于第一个方法，为什么要返回Stage？该方法也可以是void类型，因为您已经在return stage;之前给出了show()命令。你如何计划通过返回阶段来使用它？

这是将重要参考内容存储在外部类中的函数式解决方案。从showCustomerDialog函数返回一个Stage，以便后续可能需要执行其他操作的外部类（例如基于主窗口中的按钮单击隐藏stage）。另一种面向对象的解决方案可以将该功能和Stage引用封装在CustomerDialog对象中，或者使CustomerDialog扩展Stage。针对自定义对话框的面向对象接口、封装FXML、控制器和模型数据的完整示例超出了本答案的范围，但对于任何想要创建此类示例的人来说，这可能是一篇有价值的博客文章。

由StackOverflow用户@dzim提供的额外信息

Spring Boot依赖注入示例

如何以“Spring Boot方式”进行依赖注入的问题，在附加的永久链接中有关于JavaFX 2的讨论，我在那里回答了这个问题。这种方法在2016年3月已经测试过，并且在Spring Boot v1.3.3.RELEASE上仍然有效： https://dev59.com/XpPfa4cB1Zd3GeqPDnrL#36310391

有时候，您可能希望将结果传回给调用者，这时您可以查看相关问题的答案：

JavaFX FXML从控制器A传递参数到B并返回