Passage de Paramètres JavaFX FXML

Approche Recommandée

Cette réponse énumère les différents mécanismes pour passer des paramètres à FXML contrôleurs.

Pour les petites applications je recommande fortement de passer des paramètres directement à partir de l'appelant à la manette, c'est simple, simple et ne nécessite pas de supplément de cadres.

Pour les plus grands, les demandes plus complexes, il vaudrait la peine d'étudier si vous voulez utiliser L'Injection De Dépendance ou Bus D'Événement mécanismes au sein de votre application.

Passage de Paramètres Directement à Partir de l'Appelant vers le Contrôleur de

Transmettre des données personnalisées à un FXML contrôleur en récupérant le contrôleur du FXML chargeur instance et d'appel d'une méthode sur le contrôleur de l'initialiser avec les valeurs de données.

Quelque chose comme le code suivant:

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

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

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

  stage.show();

  return stage;
}

...

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

Une nouvelle FXMLLoader est construit comme le montre l'exemple de code c'est à dire new FXMLLoader(location). L'emplacement est une URL et vous pouvez générer un tel URL à partir d'un FXML ressource par:

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

Attention à ne PAS utiliser une charge statique de la fonction sur la FXMLLoader, ou vous ne serez pas en mesure d'obtenir votre contrôleur de votre occurrence de loader.

FXMLLoader instances eux-mêmes ne savez rien à propos des objets du domaine. Vous n'avez pas de passer directement de l'application spécifique dans le domaine des objets dans le FXMLLoader constructeur, au lieu de vous:

1. Construire un FXMLLoader basée sur fxml de balisage à un emplacement spécifié
2. Obtenir un contrôleur de la FXMLLoader instance.
3. Appeler des méthodes sur l'extrait de contrôleur de fournir le contrôleur avec des références à des objets du domaine.

Ce blog (par un autre écrivain) fournit une autre, mais semblable, exemple.

Réglage d'un Contrôleur de la FXMLLoader

CustomerDialogController dialogController = 
    new CustomerDialogController(param1, param2);

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

Pane mainPane = (Pane) loader.load();

Vous pouvez construire un nouveau contrôleur dans le code, la réussite de tous les paramètres que vous voulez à partir de votre correspondant dans le contrôleur constructeur. Une fois que vous avez construit un contrôleur, vous pouvez le mettre sur un FXMLLoader instance avant vous appelez la load() instance méthode.

Pour configurer une manette sur un chargeur (en JavaFX 2.x) vous NE pouvez pas définir un fx:controller attribut dans votre fichier fxml.

En raison de la limitation sur la fx:controller définition dans le FXML, personnellement, je préfère faire le contrôleur de l'FXMLLoader plutôt que de fixer le contrôleur dans le FXMLLoader.

Avoir le Contrôleur de Récupérer les Paramètres d'un Externe Méthode Statique

Cette méthode est illustrée par Sergey réponse à Javafx 2.0 Comment-pour l'Application.getParameters() dans un Controller.java fichier.

Utiliser L'Injection De Dépendance

FXMLLoader prend en charge la dépendance des systèmes d'injection comme Guice, de Printemps ou Java EE CDI en vous permettant de personnaliser le contrôleur de l'usine sur le FXMLLoader. Cela fournit un rappel que vous pouvez utiliser pour créer l'instance du contrôleur avec les valeurs dépendantes de l'injectés par l'injection de dépendance du système. Il est un exemple de l'intégration de FXML par le Printemps de l'injection de dépendance du système (malheureusement le lien est mort et que le contenu est allé, si quelqu'un sait d'un exemple similaire, merci d'éditer cette question de la référence), mais c'est un peu moins agiles que pour l'usage de la nouvelle coutume de contrôleur de l'usine de fonctionnalités disponibles dans JavaFX 2.2.

Un vraiment agréable, propre de l'injection de dépendances approche est illustrée par la la post-combustion.fx cadre auprès d'un échantillon air-hacks application qui l'utilise. la post-combustion.fx s'appuie sur JEE6 javax.injecter pour effectuer l'injection de dépendance.

Utiliser un Événement de Bus

Greg Brown, l'original, le FXML spécification créateur et réalisateur, souvent suggère d'envisager l'utilisation d'un bus d'événement, comme la Goyave EventBus, pour la communication entre les FXML instancié contrôleurs et d'autres de l'application de la logique.

L'EventBus est un simple mais puissant publier/souscrire API avec des annotations qui permet Pojo de communiquer les uns avec les autres dans une JVM sans avoir à se référer les uns aux autres.

De suivi Q&Un

sur la première méthode, pourquoi pensez-vous du retour de la Scène? La méthode peut être vide aussi bien parce que vous avez déjà en train de la commande show(); juste avant le retour de scène;. Comment envisagez-vous l'utilisation par le retour de la Scène

C'est une fonctionnelle de la solution à un problème. Une étape est retourné à partir de la showCustomerDialog fonction de telle sorte qu'une référence à elle peut être stockée par une classe externe qui souhaitent faire quelque chose, comme cacher la scène basée sur un bouton, cliquez sur dans la fenêtre principale, à une date ultérieure. Un autre orienté objet, la solution pourrait résumer la fonctionnalité et de la scène de référence à l'intérieur d'un CustomerDialog objet ou d'avoir un CustomerDialog étendre la Scène. Un exemple complet pour une interface orientée objet pour un dialogue personnalisé de l'encapsulation FXML, le contrôleur et le modèle de données est au-delà de la portée de cette réponse, mais peut faire un bon blog pour tout le monde enclin à en créer un.

---

Informations complémentaires fournies par StackOverflow utilisateur nommé @dzim

Exemple pour le Printemps de Démarrage de l'Injection de Dépendances

La question de comment le faire "Le Printemps de Démarrage Chemin", il y avait une discussion à propos de JavaFX 2, qui je anserwered dans le permalien.
L'approche est toujours valide et testé en Mars 2016, au Printemps de Démarrage v1.3.3.LIBÉRATION:
https://stackoverflow.com/a/36310391/1281217

---

Parfois, vous pouvez transmettre les résultats à l'appelant, dans ce cas, vous pouvez consulter la réponse à la question connexe:

• JavaFX FXML passage de paramètres du Contrôleur de A à B et vice-versa

OriginalL'auteur jewelsea

Je réalise que c'est un très vieux post et a quelques grandes réponses déjà,
mais je voulais faire un simple MCVE pour démontrer une telle approche et de permettre aux programmeurs un moyen de voir rapidement le concept en action.

Dans cet exemple, nous allons utiliser 5 fichiers:

1. Main.java - Simplement utilisé pour démarrer l'application et appelez le premier contrôleur.
2. Controller1.java - Le contrôleur pour la première FXML mise en page.
3. Controller2.java - Le contrôleur pour la deuxième FXML mise en page.
4. Layout1.fxml - Le FXML mise en page de la première scène.
5. Layout2.fxml - Le FXML mise en page de la deuxième scène.

Tous les fichiers sont répertoriés dans leur intégralité en bas de ce post.

L'Objectif: Pour démontrer la transmission de valeurs de Controller1 à Controller2 et vice versa.

Le Déroulement Du Programme:

• La première scène contient un TextField, un Button, et un Label. Lorsque le Button est cliqué, la deuxième fenêtre est chargé et affiché, y compris le texte entré dans la TextField.
• Dans la deuxième scène, il y a aussi un TextField, un Button, et un Label. Le Label va afficher le texte saisi dans la TextField sur la première scène.
• Lors de la saisie de texte dans la deuxième scène du TextField et en cliquant sur son Button, la première scène du Label est mis à jour pour afficher le texte saisi.

C'est une démonstration très simple et pourrait sûrement se tenir à une certaine amélioration, mais devrait rendre le concept très clair.

Le code lui-même est également fait remarquer avec quelques détails de ce qui se passe et comment.

LE CODE

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());
}
}

Layout1.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>

OriginalL'auteur Zephyr

Cela FONCTIONNE ..

Rappelez-vous la première fois que vous imprimez le passage de la valeur, vous obtiendrez null,
Vous pouvez l'utiliser après votre windows chargé , de même pour tout ce que vous voulez de code pour n'importe quel autre composant.

Premier Contrôleur

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);
}

Un Autre Contrôleur

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

OriginalL'auteur diego matos - keke

Voici un exemple d'utilisation d'un contrôleur injecté par 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;
}

Ici est une mise en œuvre concrète du chargeur:

public class ConcreteViewLoader extends GuiceFxmlLoader {
@Inject
public ConcreteViewLoader(Stage stage, Provider<MyController> provider) {
super(stage, provider);
}
@Override
public String getFileName() {
return "my_view.fxml";
}
}

Remarque cet exemple charge l'affichage dans le centre d'un BoarderPane qui est la racine de la Scène dans la Scène. Ce n'est pas pertinent pour l'exemple (détail de l'implémentation de mon cas d'utilisation spécifiques), mais a décidé de le laisser comme certains peuvent le trouver utile.

OriginalL'auteur jenglert

J'ai une méthode beaucoup plus simple de créer une instance de la classe à l'aide de la méthode initialize. J'ai cherché sur Internet plusieurs jours en attendant de trouver ce vraiment simple méthode.

Déclarer une instance de votre classe:

//définition de la variable utilisée pour l'instance de la classe principale

private static FXMLController instance;

Déclarer votre classe comme suit:

public class FXMLController implements Initializable {

Définir une méthode dans votre classe comme suit:

public void mainController() {
instance = this;
}

Puis appeler la méthode dans la méthode initialize:

@Override //this method is ran when first showing the main window
public void initialize(URL location, ResourceBundle resources) {
//initialize the instance of this class so it can be shared across controllers
mainController();
}

OriginalL'auteur Jeremy