La conception d'un système modulaire de gestion des événements est essentielle pour créer des applications JavaFX évoluables et durables. Le modèle Mediator offre un moyen efficace de découpler les composants et de rationaliser la communication entre eux. Cet article explore comment mettre en œuvre un système modulaire de gestion des événements en utilisant le modèle Mediator dans JavaFX.

Comprendre le modèle du médiateur

Le modèle Mediator est un modèle de conception comportementale qui favorise le couplage lâche en assurant que les composants communiquent par l'intermédiaire d'un médiateur central plutôt que directement entre eux. En JavaFX, ce modèle aide à gérer les interactions complexes entre les composants d'interface utilisateur, ce qui facilite la maintenance et l'extension du code.

Conception de l'interface médiateur

Commencez par définir une interface médiateur qui déclare les méthodes d'enregistrement des composants et de gestion des événements. Cette interface agit comme un contrat pour le comportement du médiateur.

public interface EventMediator {
 void registerComponent(String name, UIComponent component);
 void handleEvent(String eventType, String sourceComponent);
}

Mise en œuvre du médiateur

Le médiateur en béton gère les composants enregistrés et coordonne la gestion des événements. Il tient une carte des composants et définit la façon de réagir à divers événements.

public class ConcreteEventMediator implements EventMediator {
 private Map<String, UIComponent> components = new HashMap<>();

 @Override
 public void registerComponent(String name, UIComponent component) {
 components.put(name, component);
 }

 @Override
 public void handleEvent(String eventType, String sourceComponent) {
 // Example: handle button click
 if ("buttonClick".equals(eventType)) {
 UIComponent component = components.get(sourceComponent);
 // Perform actions based on the source component
 System.out.println(sourceComponent + " triggered a " + eventType);
 }
 }
}

Création des composants d'interface utilisateur

Les composantes de l'assurance-chômage, comme les boutons ou les curseurs, doivent communiquer avec le médiateur plutôt qu'avec l'autre.

public interface UIComponent {
 void setMediator(EventMediator mediator);
 void triggerEvent(String eventType);
}

public class ButtonComponent implements UIComponent {
 private EventMediator mediator;
 private String name;

 public ButtonComponent(String name) {
 this.name = name;
 }

 @Override
 public void setMediator(EventMediator mediator) {
 this.mediator = mediator;
 }

 @Override
 public void triggerEvent(String eventType) {
 mediator.handleEvent(eventType, name);
 }
}

Intégration des composants et médiateurs dans JavaFX

Dans votre application JavaFX, mettez en place le médiateur et les composants, enregistrez les composants avec le médiateur et configurez les gestionnaires d'événements pour déclencher les notifications de médiateur.

public class MainApp extends Application {
 @Override
 public void start(Stage primaryStage) {
 ConcreteEventMediator mediator = new ConcreteEventMediator();

 ButtonComponent button1 = new ButtonComponent("Button1");
 ButtonComponent button2 = new ButtonComponent("Button2");

 button1.setMediator(mediator);
 button2.setMediator(mediator);

 mediator.registerComponent("Button1", button1);
 mediator.registerComponent("Button2", button2);

 Button javafxButton1 = new Button("Button 1");
 javafxButton1.setOnAction(e -> button1.triggerEvent("buttonClick"));

 Button javafxButton2 = new Button("Button 2");
 javafxButton2.setOnAction(e -> button2.triggerEvent("buttonClick"));

 VBox vbox = new VBox(10, javafxButton1, javafxButton2);
 Scene scene = new Scene(vbox, 300, 200);
 primaryStage.setScene(scene);
 primaryStage.setTitle("Mediator Pattern in JavaFX");
 primaryStage.show();
 }

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

En suivant cette approche, vous créez un système modulaire de gestion d'événements évolutive qui simplifie les interactions des composants dans les applications JavaFX en utilisant le modèle Mediator.