Saltar al contenido principal

Tutorial de modernización

Abrir en ChatGPT

Este tutorial explica cómo modernizar una aplicación Java Swing existente integrándola con webforJ mediante WebswingConnector. Aprenderás a hacer que una aplicación de escritorio tradicional sea accesible desde la web y a añadir gradualmente funciones web modernas, como cuadros de diálogo web y formularios interactivos que utilizan componentes de webforJ.

Requisitos previos

Antes de empezar este tutorial, completa los pasos de Configuración para configurar el servidor Webswing y los ajustes de CORS.

Código fuente

El código fuente completo de este tutorial está disponible en GitHub: webforj/webforj-webswing-integration-tutorial

El escenario​

Imagina que tienes una aplicación de gestión de clientes creada con Swing que lleva años en producción. Funciona bien, pero ahora los usuarios esperan poder acceder a ella desde la web y contar con una interfaz moderna. En lugar de reescribirla desde cero, usarás Webswing para hacerla accesible desde la web de inmediato y, luego, añadirás gradualmente funciones web modernas, como cuadros de diálogo y formularios web que utilizan componentes de webforJ.

Punto de partida: la aplicación Swing​

La aplicación Swing de ejemplo es una tabla de clientes con las operaciones CRUD habituales. Como muchas aplicaciones Swing empresariales, sigue patrones estándar:

public class Application {
private List<Customer> customers;
private DefaultTableModel model;
private JTable table;

private void createTable() {
String[] columnNames = { "Name", "Company", "Email" };
model = new DefaultTableModel(columnNames, 0) {
@Override
public boolean isCellEditable(int row, int column) {
return false;
}
};

table = new JTable(model);
table.setRowHeight(30);
table.setRowSelectionAllowed(true);

table.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() == 2) {
// Handle double-click to edit
}
}
});
}

private void showEditDialog(Customer customer) {
JTextField nameField = new JTextField(customer.getName());
JTextField companyField = new JTextField(customer.getCompany());
JTextField emailField = new JTextField(customer.getEmail());

Object[] fields = {
"Name:", nameField,
"Company:", companyField,
"Email:", emailField
};

int result = JOptionPane.showConfirmDialog(null, fields, "Edit Customer",
JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);
}
}

Esta aplicación funciona perfectamente como aplicación de escritorio, pero no es accesible desde la web. Los usuarios deben instalar Java y ejecutar el archivo JAR localmente.

Paso 1: hacer que sea compatible con Webswing​

El primer paso es hacer que la aplicación Swing detecte si se está ejecutando en Webswing. Esto le permite adaptar su comportamiento sin perder la compatibilidad con el escritorio.

Detectar el entorno de Webswing​

Añade la dependencia de la API de Webswing a tu proyecto Swing:

<dependency>
<groupId>org.webswing</groupId>
<artifactId>webswing-api</artifactId>
<version>25.1</version>
</dependency>

Luego, modifica la aplicación para detectar el entorno de ejecución de Webswing:

private void initWebswing() {
api = WebswingUtil.getWebswingApi();
isWebswing = api != null;

if (isWebswing) {
setupWebswingListeners();
}
}

La clave es que WebswingUtil.getWebswingApi() devuelve null cuando la aplicación se ejecuta como una aplicación de escritorio normal, lo que permite mantener la compatibilidad con ambos modos.

Adaptar el comportamiento para la implementación web​

Con la detección lista, ya puedes adaptar el comportamiento de la aplicación. El cambio más importante afecta a cómo se gestionan las interacciones del usuario:

private void handleDoubleClick(MouseEvent e) {
int row = table.rowAtPoint(e.getPoint());
if (row >= 0 && row < customers.size()) {
Customer customer = customers.get(row);

if (isWebswing) {
api.sendActionEvent("select-customer", gson.toJson(customer), null);
} else {
showEditDialog(customer);
}
}
}

Al ramificar el comportamiento según el valor de isWebswing, la base de código puede funcionar en ambos entornos.

Paso 2: crear el contenedor de webforJ​

Ahora que la aplicación Swing puede comunicarse mediante eventos, crea una aplicación webforJ que incorpore la aplicación Swing y añada funciones web modernas, como cuadros de diálogo y formularios web.

Configurar el conector​

El componente WebswingConnector incorpora la aplicación alojada en Webswing en una vista de webforJ:

@Route("/")
public class CustomerTableView extends Composite<FlexLayout> {
private final FlexLayout self = getBoundComponent();

public CustomerTableView(@Value("${webswing.connector.url}") String webswingUrl) {
WebswingConnector connector = new WebswingConnector(webswingUrl);
connector.setSize("100vw", "100vh");

self.add(connector);
}
}

El conector se conecta al servidor Webswing y establece un canal de comunicación bidireccional.

Gestionar eventos de Swing​

Cuando la aplicación Swing envía eventos, por ejemplo, cuando un usuario hace doble clic en una fila, el conector los recibe:

connector.onAction(event -> {
switch (event.getActionName()) {
case "select-customer":
event.getActionData().ifPresent(data -> {
JsonObject customer = JsonParser.parseString(data).getAsJsonObject();
CustomerForm dialog = new CustomerForm(customer);
self.add(dialog);
dialog.onSave(() -> {
Gson gson = new Gson();
connector.performAction("update-customer", gson.toJson(customer));
});
});
break;
}
});

Ahora, en lugar del cuadro de diálogo de Swing, los usuarios verán un formulario web moderno creado con componentes de webforJ.

Paso 3: comunicación bidireccional​

La integración cobra todo su potencial cuando la comunicación fluye en ambas direcciones. La aplicación webforJ puede enviar actualizaciones a la aplicación Swing para mantener sincronizadas ambas interfaces.

Enviar actualizaciones a Swing​

Después de que el usuario edite un cliente en el cuadro de diálogo de webforJ:

dialog.onSave(() -> {
// Send updated customer back to Swing
connector.performAction("update-customer", gson.toJson(customer));
});

Procesar actualizaciones en Swing​

La aplicación Swing escucha estas actualizaciones y refresca su vista:

private void setupWebswingListeners() {
api.addBrowserActionListener(event -> {
if ("update-customer".equals(event.getActionName())) {
Customer updated = gson.fromJson(event.getData(), Customer.class);
updateCustomer(updated);
}
});
}

Ventajas de la arquitectura​

Este enfoque ofrece varias ventajas frente a una reescritura completa:

Implementación web inmediata​

Tu aplicación Swing estará disponible en la web de inmediato, sin cambios en el código. Los usuarios podrán acceder a ella desde un navegador mientras trabajas en las mejoras.

Mejora progresiva​

Empieza por reemplazar solo el cuadro de diálogo de edición y, luego, sustituye gradualmente más componentes:

  1. Fase 1: incorpora toda la aplicación Swing y reemplaza solo el cuadro de diálogo de edición
  2. Fase 2: añade navegación y menús de webforJ alrededor de la aplicación incorporada
  3. Fase 3: reemplaza la tabla con una tabla de webforJ y conserva Swing para las funciones irremplazables
  4. Fase 4: reemplaza finalmente todos los componentes de Swing

Mitigación de riesgos​

Como la aplicación Swing original sigue funcionando, puedes:

  • Volver a la implementación de escritorio si es necesario
  • Probar las nuevas funciones junto con las existentes
  • Migrar a los usuarios gradualmente
  • Mantener la misma lógica de negocio

Sigue aprendiendo