Tutorial zur Modernisierung
Dieses Tutorial zeigt Schritt für Schritt, wie Sie eine bestehende Java-Swing-App modernisieren, indem Sie sie mit webforJ und dem WebswingConnector integrieren. Sie erfahren, wie Sie eine herkömmliche Desktop-App über das Web zugänglich machen und schrittweise moderne Webfunktionen wie webbasierte Dialoge und interaktive Formulare mit webforJ-Komponenten hinzufügen.
Bevor Sie mit diesem Tutorial beginnen, führen Sie die Schritte unter Einrichtung und Konfiguration aus, um Ihren Webswing-Server und die CORS-Einstellungen zu konfigurieren.
Der vollständige Quellcode für dieses Tutorial ist auf GitHub verfügbar: webforj/webforj-webswing-integration-tutorial
Das Szenario
Stellen Sie sich vor, Sie haben eine mit Swing entwickelte Kundenverwaltungs-App, die seit Jahren produktiv eingesetzt wird. Sie funktioniert gut, aber die Nutzer erwarten inzwischen Zugriff über das Web und eine moderne Benutzeroberfläche. Statt die App von Grund auf neu zu schreiben, verwenden Sie Webswing, um sie sofort über das Web zugänglich zu machen. Anschließend fügen Sie schrittweise moderne Webfunktionen wie webbasierte Dialoge und Formulare mit webforJ-Komponenten hinzu.
Ausgangspunkt: die Swing-App
Die beispielhafte Swing-App zeigt eine Kundentabelle mit typischen CRUD-Operationen. Wie viele Swing-Apps in Unternehmen folgt sie gängigen Mustern:
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);
}
}
Diese App funktioniert als Desktop-App einwandfrei, ist aber nicht über das Web zugänglich. Nutzer müssen Java installieren und die JAR-Datei lokal ausführen.
Schritt 1: Unterstützung für Webswing hinzufügen
Im ersten Schritt soll die Swing-App erkennen, ob sie unter Webswing ausgeführt wird. So kann sie ihr Verhalten entsprechend anpassen, ohne die Kompatibilität mit der Desktop-Version zu beeinträchtigen.
Webswing-Umgebung erkennen
Fügen Sie Ihrem Swing-Projekt die Webswing-API-Abhängigkeit hinzu:
<dependency>
<groupId>org.webswing</groupId>
<artifactId>webswing-api</artifactId>
<version>25.1</version>
</dependency>
Ändern Sie anschließend Ihre App so, dass sie die Webswing-Laufzeitumgebung erkennt:
private void initWebswing() {
api = WebswingUtil.getWebswingApi();
isWebswing = api != null;
if (isWebswing) {
setupWebswingListeners();
}
}
Entscheidend ist, dass WebswingUtil.getWebswingApi() bei einer gewöhnlichen Desktop-App null zurückgibt. So bleibt die Kompatibilität mit beiden Betriebsarten erhalten.
Verhalten für die Webbereitstellung anpassen
Nach der Erkennung können Sie nun das Verhalten der App anpassen. Die wichtigste Änderung betrifft die Verarbeitung von Nutzerinteraktionen:
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);
}
}
}
Indem das Verhalten anhand des Werts von isWebswing verzweigt wird, kann die Codebasis beide Umgebungen unterstützen.
Schritt 2: Den webforJ-Wrapper erstellen
Nachdem die Swing-App Ereignisse senden kann, erstellen Sie eine webforJ-App, die die Swing-App einbettet und moderne Webfunktionen wie webbasierte Dialoge und Formulare ergänzt.
Den Connector einrichten
Die Komponente WebswingConnector bettet Ihre auf Webswing gehostete App in eine webforJ-Ansicht ein:
@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);
}
}
Der Connector stellt eine Verbindung zu Ihrem Webswing-Server her und richtet einen bidirektionalen Kommunikationskanal ein.
Ereignisse aus Swing verarbeiten
Wenn die Swing-App Ereignisse sendet, etwa wenn ein Nutzer auf eine Zeile doppelklickt, empfängt der Connector sie:
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;
}
});
Anstelle des Swing-Dialogs sehen Nutzer nun ein modernes Webformular, das mit webforJ-Komponenten erstellt wurde.
Schritt 3: Bidirektionale Kommunikation
Die Integration entfaltet ihr volles Potenzial, wenn die Kommunikation in beide Richtungen funktioniert. Die webforJ-App kann Aktualisierungen an die Swing-App zurücksenden, sodass beide Benutzeroberflächen synchron bleiben.
Aktualisierungen an Swing senden
Nachdem der Nutzer einen Kunden im webforJ-Dialog bearbeitet hat:
dialog.onSave(() -> {
// Send updated customer back to Swing
connector.performAction("update-customer", gson.toJson(customer));
});
Aktualisierungen in Swing verarbeiten
Die Swing-App lauscht auf diese Aktualisierungen und aktualisiert ihre Anzeige:
private void setupWebswingListeners() {
api.addBrowserActionListener(event -> {
if ("update-customer".equals(event.getActionName())) {
Customer updated = gson.fromJson(event.getData(), Customer.class);
updateCustomer(updated);
}
});
}
Vorteile der Architektur
Dieser Ansatz bietet mehrere Vorteile gegenüber einer vollständigen Neuentwicklung:
Sofortige Webbereitstellung
Ihre Swing-App wird ohne Codeänderungen sofort über das Web zugänglich. Nutzer können über einen Browser darauf zugreifen, während Sie an Erweiterungen arbeiten.
Schrittweise Erweiterung
Beginnen Sie damit, nur den Bearbeitungsdialog zu ersetzen, und tauschen Sie dann nach und nach weitere Komponenten aus:
- Phase 1: Die gesamte Swing-App einbetten und nur den Bearbeitungsdialog ersetzen
- Phase 2: webforJ-Navigation und -Menüs um die eingebettete App ergänzen
- Phase 3: Die Tabelle durch eine webforJ-Tabelle ersetzen und Swing für unverzichtbare Funktionen beibehalten
- Phase 4: Schließlich alle Swing-Komponenten ersetzen
Risikominimierung
Da die ursprüngliche Swing-App weiterhin funktioniert, können Sie:
- bei Bedarf auf die Desktopbereitstellung zurückgreifen
- neue Funktionen parallel zu bestehenden Funktionen testen
- Nutzer schrittweise migrieren
- dieselbe Geschäftslogik beibehalten
Moving a desktop Java app to the web?
Send us a screenshot of one screen and we'll reply with how it moves to webforJ.
Weiterlernen
ArtikelBig bang migration vs phased: how to cut over a Java app
ArtikelModernize a Java Swing app without JavaScript: JavaOne 2026
ArtikelStrangler Fig Pattern for a Java Swing App, Step by Step
ArtikelConvert Swing to web: a Swing to webforJ mapping guide
ArtikelSwing to JavaScript communication with webforJ and Webswing
ArtikelWebswing and webforJ: a modernization roadmap