Solución:
Enfoque recomendado
Esta respuesta enumera diferentes mecanismos para pasar parámetros a los controladores FXML.
Para aplicaciones pequeñas, recomiendo encarecidamente pasar parámetros directamente del llamador al controlador: es simple, directo y no requiere marcos adicionales.
Para aplicaciones más grandes y complicadas, valdría la pena investigar si desea utilizar mecanismos de inyección de dependencia o bus de eventos dentro de su aplicación.
Pasar parámetros directamente de la persona que llama al controlador
Pase datos personalizados a un controlador FXML recuperando el controlador de la instancia del cargador FXML y llamando a un método en el controlador para inicializarlo con los valores de datos requeridos.
Algo parecido al siguiente código:
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());
}
}
Se construye un nuevo FXMLLoader como se muestra en el código de muestra, es decir new FXMLLoader(location). La ubicación es una URL y puede generar dicha URL a partir de un recurso FXML mediante:
new FXMLLoader(getClass().getResource("sample.fxml"));
Tenga cuidado de NO usar una función de carga estática en FXMLLoader, o no podrá obtener su controlador de su instancia de cargador.
Las propias instancias de FXMLLoader nunca saben nada sobre los objetos de dominio. No pasa directamente objetos de dominio específicos de la aplicación al constructor FXMLLoader, sino que:
- Construya un FXMLLoader basado en el marcado fxml en una ubicación específica
- Obtenga un controlador de la instancia de FXMLLoader.
- Invoque métodos en el controlador recuperado para proporcionar al controlador referencias a los objetos de dominio.
Este blog (de otro escritor) proporciona un ejemplo alternativo, pero similar.
Configuración de un controlador en FXMLLoader
CustomerDialogController dialogController =
new CustomerDialogController(param1, param2);
FXMLLoader loader = new FXMLLoader(
getClass().getResource(
"customerDialog.fxml"
)
);
loader.setController(dialogController);
Pane mainPane = loader.load();
Puede construir un nuevo controlador en código, pasando los parámetros que desee de su llamador al constructor del controlador. Una vez que haya construido un controlador, puede configurarlo en una instancia de FXMLLoader antes de invocas el load() ejemplo método.
Para configurar un controlador en un cargador (en JavaFX 2.x) NO PUEDE también definir un fx:controller atributo en su archivo fxml.
Debido a la limitación del fx:controller definición en FXML, personalmente prefiero obtener el controlador de FXMLLoader en lugar de configurar el controlador en FXMLLoader.
Hacer que el controlador recupere parámetros de un método estático externo
Este método está ejemplificado por la respuesta de Sergey a Javafx 2.0 How-to Application.getParameters () en un archivo Controller.java.
Usar inyección de dependencia
FXMLLoader admite sistemas de inyección de dependencia como Guice, Spring o Java EE CDI al permitirle configurar una fábrica de controladores personalizados en FXMLLoader. Esto proporciona una devolución de llamada que puede usar para crear la instancia del controlador con valores dependientes inyectados por el sistema de inyección de dependencia respectivo.
Un ejemplo de la aplicación JavaFX y la inyección de dependencia del controlador con Spring se proporciona en la respuesta a:
- Adición de la inyección de dependencia de Spring en JavaFX (JPA Repo, Service)
Un enfoque de inyección de dependencia realmente agradable y limpio está ejemplificado por el marco afterburner.fx con una aplicación de muestra de air-hacks que lo usa. afterburner.fx se basa en JEE6 javax.inject para realizar la inyección de dependencia.
Usar un bus de eventos
Greg Brown, el creador e implementador de la especificación FXML original, a menudo sugiere considerar el uso de un bus de eventos, como el Guava EventBus, para la comunicación entre controladores instanciados FXML y otra lógica de aplicación.
EventBus es una API de publicación / suscripción simple pero poderosa con anotaciones que permite a los POJO comunicarse entre sí en cualquier lugar de una JVM sin tener que referirse entre sí.
Preguntas y respuestas de seguimiento
en el primer método, ¿por qué regresa Stage? El método también puede ser nulo porque ya está dando el comando show (); justo antes de la etapa de regreso ;. ¿Cómo planifica el uso devolviendo el escenario?
Es una solución funcional a un problema. Se devuelve una etapa del showCustomerDialog función de modo que una referencia a ella pueda ser almacenada por una clase externa que puede desear hacer algo, como ocultar el escenario basándose en un clic de botón en la ventana principal, en un momento posterior. Una solución alternativa orientada a objetos podría encapsular la funcionalidad y la referencia de etapa dentro de un objeto CustomerDialog o tener una etapa de extensión de CustomerDialog. Un ejemplo completo de una interfaz orientada a objetos para un cuadro de diálogo personalizado que encapsula FXML, el controlador y los datos del modelo está más allá del alcance de esta respuesta, pero puede ser una publicación de blog valiosa para cualquiera que desee crear una.
Información adicional proporcionada por el usuario de StackOverflow llamado @dzim
Ejemplo de inyección de dependencia de Spring Boot
La pregunta de cómo hacerlo “The Spring Boot Way”, hubo una discusión sobre JavaFX 2, que respondí en el enlace permanente adjunto. El enfoque sigue siendo válido y probado en marzo de 2016, en Spring Boot v1.3.3. LIBERAR: https://stackoverflow.com/a/36310391/1281217
A veces, es posible que desee devolver los resultados a la persona que llama, en cuyo caso puede consultar la respuesta a la pregunta relacionada:
- Parámetro JavaFX FXML que pasa del controlador A al B y viceversa
Me doy cuenta de que esta es una publicación muy antigua y ya tiene algunas respuestas excelentes, pero quería hacer un MCVE simple para demostrar uno de esos enfoques y permitir a los nuevos codificadores una forma de ver rápidamente el concepto en acción.
En este ejemplo, usaremos 5 archivos:
- Main.java – Simplemente se usa para iniciar la aplicación y llamar al primer controlador.
- Controller1.java – El controlador para el primer diseño FXML.
- Controller2.java – El controlador para el segundo diseño FXML.
- Layout1.fxml – El diseño FXML para la primera escena.
- Layout2.fxml – El diseño FXML para la segunda escena.
Todos los archivos se enumeran en su totalidad al final de esta publicación.
La meta: Para demostrar valores de paso de Controller1 para Controller2 y viceversa.
El flujo del programa:
- La primera escena contiene un
TextField, aButtony unLabel. Cuando elButtonse hace clic, la segunda ventana se carga y se muestra, incluido el texto introducido en elTextField. - Dentro de la segunda escena, también hay un
TextField, aButtony unLabel. losLabelmostrará el texto ingresado en elTextFielden la primera escena. - Al ingresar texto en la segunda escena
TextFieldy haciendo clic en suButton, la primera escena esLabelse actualiza para mostrar el texto introducido.
Esta es una demostración muy simple y seguramente podría significar alguna mejora, pero debería dejar el concepto muy claro.
El código en sí también se comenta con algunos detalles de lo que está sucediendo y cómo.
EL CÓDIGO
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 text="This is Layout1!"/>
<HBox alignment="CENTER_LEFT" spacing="10.0">
<Label text="Enter Text:"/>
<TextField fx:/>
<Button fx: mnemonicParsing="false" text="Open Layout2"/>
</HBox>
<VBox alignment="CENTER">
<Label text="Text From Controller2:"/>
<Label fx: 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 text="Welcome to Layout 2!"/>
<VBox alignment="CENTER">
<Label text="Text From Controller1:"/>
<Label fx: text="Nothing Yet!"/>
</VBox>
<HBox alignment="CENTER_LEFT" spacing="10.0">
<Label text="Enter Text:"/>
<TextField fx:/>
<Button fx: mnemonicParsing="false" text="Set Text on Layout1"/>
</HBox>
</VBox>
</AnchorPane>
La clase javafx.scene.Node tiene un par de métodos setUserData (Object) y Object getUserData ()
Que podría usar para agregar su información a Node.
Entonces, puede llamar a page.setUserData (info);
Y el controlador puede verificar si la información está configurada. Además, puede utilizar ObjectProperty para la transferencia de datos hacia atrás, si es necesario.
Observe una documentación aquí: http://docs.oracle.com/javafx/2/api/javafx/fxml/doc-files/introduction_to_fxml.html Antes de la frase “En la primera versión, el handleButtonAction () está etiquetado con @FXML para permitir que el marcado definido en el documento del controlador lo invoque. En el segundo ejemplo, el campo del botón está anotado para permitir que el cargador establezca su valor. El método initialize () está anotado de manera similar “.
Por lo tanto, debe asociar un controlador con un nodo y establecer un dato de usuario para el nodo.