El diseño de un sistema modular de manejo de eventos es esencial para crear aplicaciones JavaFX sostenibles y escalables. El patrón Mediator ofrece una manera eficaz de descodificar componentes y simplificar la comunicación entre ellos. Este artículo explora cómo implementar un sistema modular de manejo de eventos utilizando el patrón Mediator en JavaFX.

Comprender el patrón de mediador

El patrón de Mediator es un patrón de diseño conductual que promueve el acoplamiento suelto asegurando que los componentes se comuniquen a través de un mediador central en lugar de directamente entre sí. En JavaFX, este patrón ayuda a gestionar interacciones complejas entre los componentes de la interfaz de usuario, facilitando el mantenimiento y la extensión del código.

Diseño de la interfaz de mediador

Comience por definir una interfaz de mediador que declare métodos para registrar componentes y manejar eventos. Esta interfaz actúa como un contrato para el comportamiento del mediador.

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

Implementación del Mediador

El mediador de hormigón gestiona componentes registrados y coordina el manejo de eventos. Mantiene un mapa de componentes y define cómo responder a diversos eventos.

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

Creación de componentes de la interfaz de usuario

Los componentes de la interfaz de usuario, como botones o deslizadores, deben comunicarse con el mediador en lugar de directamente entre sí. Cada componente notifica al mediador cuando se produce un evento.

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

Integrando componentes y mediador en JavaFX

En su aplicación JavaFX, instantáneamente el mediador y los componentes, registre componentes con el mediador y establezca controladores de eventos para activar notificaciones de mediador.

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

Al seguir este enfoque, usted crea un sistema modular de manipulación de eventos escalable que simplifica las interacciones de componentes en aplicaciones JavaFX utilizando el patrón Mediator.