Swing-Modernisierung

Von Swing ins Web, Ein Bildschirm nach dem anderen

Ihre Swing-, JavaFX- oder SWT-App läuft ohne Änderungen am Quellcode im Browser. Anschließend erstellen Sie neue Ansichten mit webforJ und ersetzen die alten in Ihrem eigenen Tempo. Ihr Java-Team und der Code bleiben erhalten.

Folge dem Tutorial.Webswing einrichten

Desktop-Toolkits: Swing, JavaFX und SWT: 3
Quellcodeänderungen zur Ausführung im Browser: 0

Kunden

KundenSwing
BestellungenwebforJ
BerichteSwing

Swing-App, gestreamt

Kundentabelle

DateiBearbeitenAnsicht

NameTeamStadt

Hyyan Abo FakherVertriebBerlin

Matthew HawkinsSupportBoston

Eric HandtkeFinanzenHamburg

Ben BrennanVertriebDenver

Garrison OsteenSupportAustin

Lauren AlamoFinanzenPhoenix

Kunden bearbeiten

NameEric HandtkeTeamFinanzenStadtHamburg

AbbrechenSpeichern

webforJ-Dialog

Ein Doppelklick in der Swing-Tabelle öffnet einen webforJ-Dialog statt des alten Swing-Dialogs. Beide laufen im selben Browser-Tab.

Was gleich bleibt

Nur die Bildschirme Ändern

webforJ ist das Full-Stack-Java-Framework für Business-Webanwendungen: Sie entwickeln die gesamte Anwendung – einschließlich aller Ansichten – in Java. Eine Swing-Anwendung zu migrieren bedeutet also, ihre Ansichten zu migrieren, und alles darunter wird übernommen.

Was ändert sich?

Die Ansichten. Sie wechseln sie einzeln und in der für Ihr Unternehmen wichtigen Reihenfolge, während der Rest der Swing-App im selben Browser-Tab weiterläuft.

01
Das Team
Die Entwickler, die heute die Swing-App betreuen, erstellen die Weboberflächen in Java. Es braucht weder ein zweites Team noch eine neue Frontend-Toolchain, die erlernt werden muss.
02
Der Code
Webswing führt die App unverändert aus. Dieselbe Codebasis funktioniert weiterhin als Desktop-App und im Browser – so pflegen Sie eine App statt zwei.
03
Die Logik
Domänenklassen, Services und Validierungsregeln, die nichts mit javax.swing zu tun haben, werden direkt von den neuen Ansichten aufgerufen. Sie werden nicht erst zu Endpunkten.
04
Die Toolchain
Maven, Ihre IDE, Ihr Debugger und Ihre vorhandenen Tests können weiterhin verwendet werden.

Der Umzug in drei Phasen

Den Zug Schritt für Schritt durchgehen Vom Desktop ins Web

Jede Phase bringt etwas hervor, das Nutzer sehen können. Wähle eine Phase, um den Bildschirm und den dazugehörigen Code zu sehen.

Kundentabelle

DateiBearbeitenAnsicht

NameTeamStadt

Hyyan Abo FakherVertriebBerlin

Matthew HawkinsSupportBoston

Eric HandtkeFinanzenHamburg

Ben BrennanVertriebDenver

Garrison OsteenSupportAustin

Lauren AlamoFinanzenPhoenix

Desktop-App im Browser ausführen

Webswing führt Ihre Swing-, JavaFX- oder SWT-App auf dem Server aus und überträgt ihre Benutzeroberfläche als HTML5-Canvas in den Browser. Maus- und Tastatureingaben werden an die echte App weitergeleitet. Der Quellcode bleibt unverändert.

Binden Sie es mit WebswingConnector in eine webforJ-Ansicht ein. Der Connector verbindet sich mit dem Webswing-Server, sobald er zur Seite hinzugefügt wird.

SwingAppView.java

@Route
public class SwingAppView extends Composite<Div> {
  private final Div self = getBoundComponent();
  private WebswingConnector connector;

  public SwingAppView() {
    // Initialize the connector with your Webswing application URL
    connector = new WebswingConnector("http://localhost:8080/myapp/");

    // Set the display dimensions
    connector.setSize("100%", "600px");

    // Add to the view container
    self.add(connector);
  }
}

Kunden

KundenSwing
BestellungenwebforJ
BerichteSwing

WebswingConnector

Kundentabelle

DateiBearbeitenAnsicht

NameTeamStadt

Hyyan Abo FakherVertriebBerlin

Matthew HawkinsSupportBoston

Eric HandtkeFinanzenHamburg

Ben BrennanVertriebDenver

Garrison OsteenSupportAustin

Lauren AlamoFinanzenPhoenix

Kunden bearbeiten

NameEric HandtkeTeamFinanzenStadtHamburg

AbbrechenSpeichern

webforJ

Erstelle darauf aufbauend neue Bildschirme.

Neue Ansichten werden in webforJ erstellt und ergänzen die eingebettete Anwendung. Beide Seiten tauschen Aktionen aus: Ein Klick in Swing kann ein Webformular öffnen, und ein Speichern im Web kann die Swing-Tabelle aktualisieren. Nutzer arbeiten im selben Browser-Tab mit alten und neuen Ansichten.

Swing meldet einen Doppelklick als select-customer. webforJ öffnet sein eigenes Formular und sendet beim Speichern update-customer zurück.

CustomerTableView.java

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

Kunden

KundenwebforJ
BestellungenwebforJ
BerichtewebforJ

NameTeamStadt

Hyyan Abo FakherVertriebBerlin

Matthew HawkinsSupportBoston

Eric HandtkeFinanzenHamburg

Ben BrennanVertriebDenver

Garrison OsteenSupportAustin

Lauren AlamoFinanzenPhoenix

Kunden bearbeiten

NameEric HandtkeTeamFinanzenStadtHamburg

AbbrechenSpeichern

Desktop-Client einstellen

Ersetzen Sie die Swing-Bildschirme einzeln, in der für Ihr Unternehmen wichtigsten Reihenfolge. Gibt es für einen Bildschirm ein webforJ-Äquivalent, entfernen Sie dessen Aktionen. Nach dem letzten Bildschirm entfallen die Webswing-Ebene und der Desktop-Client.

Du kannst nach jeder Phase aufhören und hast trotzdem etwas erreicht. Phase 2 kann so lange laufen, wie es das Budget zulässt.

Was läuft?: Eine Java-App im Browser – jeder Bildschirm in webforJ geschrieben.
Was passt: Der Webswing-Server, die gestreamte Desktop-Oberfläche und der installierte Client.
Was bleibt: Ihre Domänenklassen, Services und Validierungsregeln, die von den neuen Ansichten als Java-Methoden aufgerufen werden.

Phase 1 von 3

Bidirektionale Kommunikation

Alte und neue Bildschirme Miteinander sprechen

Eine Nachricht ist eine Aktion: ein Name, eine optionale Zeichenfolgen-Nutzlast und eine optionale binäre Nutzlast. Den Namen können Sie frei wählen. Beide Seiten bestehen aus einfachem Java, daher muss niemand für den Austausch Browserskripte schreiben.

Swing kündigt an

Ein Doppelklick sendet select-customer mit der Zeile als JSON. Auf dem Desktop öffnet derselbe Klick weiterhin den Swing-Dialog.

Application.java (Swing)

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

CustomerBridgeView.java (webforJ)

connector.onAction(e -> {
  switch (e.getActionName()) {
    case "select-customer" -> e.getActionData().ifPresent(this::openEditor);
    case "export-ready" -> e.getActionBinaryData()
        .ifPresent(d -> status.setText("Got " + d.length() + " characters"));
    default -> { }
  }
});

webforJ-Antworten

Beim Speichern sendet das Webformular update-customer zurück, und die Swing-App aktualisiert ihre Tabelle. Keine Seite greift auf die internen Komponenten der anderen zu.

Application.java (Swing)

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

CustomerTableView.java (webforJ)

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

Befehle an Swing senden

performAction() sendet entweder nur einen Namen oder einen Namen mit Daten. Die Swing-Anwendung entscheidet, was die einzelnen Namen bedeuten.

Aktionen senden

// Trigger a refresh in the Swing application from webforJ
connector.performAction("refresh");

// Send a command with data from webforJ
connector.performAction("selectRecord", "12345");

Wissen, wann Swing bereit ist

onInitialize wird ausgelöst, sobald die Verbindung bereit ist. onStart wird ausgelöst, sobald die Swing-App vollständig geladen ist. Senden Sie Ihre erste Aktion in onStart.

Lebenszyklusereignisse

connector.onInitialize(e -> status.setText("Connected"));
connector.onStart(e -> status.setText("Swing app running"));

Mit einem KI-Assistenten portieren

Lass es von einem Assistenten portieren. Bildschirm für Bildschirm

Das Durcharbeiten von Bildschirm zu Bildschirm ist repetitive Arbeit – genau das Richtige für einen KI-Coding-Assistenten. Das webforJ AI-Plugin verbindet ihn mit dem webforJ MCP-Server und Agent Skills: strukturierten Workflows, die festlegen, wann und in welcher Reihenfolge er diese Tools nutzt und wie er das Ergebnis überprüft.

KI-Plugin installieren Mehr über Agent Skills erfahren

1
Gib ihm einen Swing-Bildschirm.
Fragen Sie nach dem webforJ-Äquivalent, das Ihre bestehenden Dienste aufruft.
2
Es prüft die echte API.
Der MCP-Server ruft bei Bedarf die webforJ-Dokumentation und API-Details ab, statt zu raten.
3
Sie überprüfen und testen.
Verhalten mit dem Swing-Original vergleichen und anschließend zum nächsten Bildschirm wechseln.

So starten Sie

Aus einer JAR-Datei zu einer Seite im Browser

Sie benötigen eine Swing-, JavaFX- oder SWT-Anwendung im JAR-Format, den Webswing-Server und webforJ 25.10 oder höher.

1
Webswing herunterladen und starten
Laden Sie Webswing herunter, entpacken Sie das Archiv und starten Sie den Server anschließend mit dem Skript für Ihre Plattform. Der Server ist unter http://localhost:8080 erreichbar.
```
webswing.sh
```
2
App registrieren
Legen Sie in der Administrationskonsole unter http://localhost:8080/admin den Anwendungsnamen, die Hauptklasse, den Klassenpfad, die JVM-Argumente und das Home-Verzeichnis fest. Die Anwendung wird anschließend unter http://localhost:8080/[app-name]/ bereitgestellt.
CORS
Fügen Sie den Ursprung Ihrer webforJ-App zu den zulässigen Ursprüngen hinzu, z. B. http://localhost:8090.
Ports
Beide verwenden normalerweise 8080. Ändern Sie einen davon, um Konflikte zu vermeiden.

Abhängigkeit hinzufügen

Das Modul webforj-webswing stellt WebswingConnector und die zugehörigen Klassen bereit.

<dependency>
  <groupId>com.webforj</groupId>
  <artifactId>webforj-webswing</artifactId>
  <version>${webforj.version}</version>
</dependency>

4
Einbetten und konfigurieren
Fügen Sie einer Ansicht wie in Phase 1 einen WebswingConnector hinzu. WebswingOptions ändert sein Verhalten, z. B. indem die Abmeldeschaltfläche ausgeblendet wird, wenn Ihre webforJ-App die Anmeldung übernimmt.
```
WebswingConnector connector = new WebswingConnector("http://localhost:8080/myapp/");

WebswingOptions options = new WebswingOptions()
  .setDisableLogout(true);  // Hide the logout button

connector.setOptions(options);
```

Wähle dein Erster Bildschirm

Beginnen Sie mit einer einfachen Liste und einem Bearbeitungsformular. Betten Sie die App ein, übertragen Sie diesen einen Bildschirm zu webforJ und sehen Sie, wie er neben dem Rest läuft.

Nur die Bildschirme Ändern

Das Team

Der Code

Die Logik

Die Toolchain

Den Zug Schritt für Schritt durchgehen Vom Desktop ins Web

Desktop-App im Browser ausführen

Alte und neue Bildschirme Miteinander sprechen

Swing kündigt an

webforJ-Antworten

Befehle an Swing senden

Wissen, wann Swing bereit ist

Lass es von einem Assistenten portieren. Bildschirm für Bildschirm

Aus einer JAR-Datei zu einer Seite im Browser

Webswing herunterladen und starten

App registrieren

Abhängigkeit hinzufügen

Einbetten und konfigurieren

Wähle dein Erster Bildschirm