Swing (Java)

Die Widgets von Swing mit dem Ocean Look and Feel (Standard seit Java 1.5)

Klassenhierarchie von AWT und Swing

Swing ist ein GUI-Toolkit für die Programmiersprache Java von Sun Microsystems. Seit Java-Version 1.2 (1998) ist es Bestandteil der Java-Runtime. Swing gehört zu den Java Foundation Classes (JFC), die eine Sammlung von Bibliotheken zur Programmierung von grafischen Benutzerschnittstellen bereitstellen. Zu diesen Bibliotheken gehören Java 2D, die Java Accessibility API (JAAPI), das Drag-and-Drop-API und das Abstract Window Toolkit (AWT). Swing baut auf dem älteren AWT auf und ist mit den anderen APIs verwoben.

Hauptkonkurrent von Swing ist das für Eclipse entwickelte SWT. Der designierte Nachfolger von Swing ist das Framework JavaFX, das seit März 2014 im Lieferumfang des Oracle JDK enthalten ist, das aber bisher nicht durch den Java Community Process als offizieller Java-Standard spezifiziert wurde.

Merkmale

Aufbau

Swing ist modular und objektorientiert aufgebaut, so dass es sich gerade für die Entwicklung komplexer Anwendungen gut eignet. Durch die Plattformunabhängigkeit entfällt ebenfalls viel Entwicklungs- und Testarbeit.

Pluggable Look-and-Feel

Das Erscheinungsbild (Look, siehe Skin) und das Verhalten (Feel) von Swing-Komponenten kann mittels sogenannter Look-and-Feels angepasst werden. Auf allen Plattformen stehen sowohl das Motif-Look-and-Feel als auch das Metal-Look-and-Feel (ab Java 5 das Ocean-Look-and-Feel) zur Verfügung, auf Linux Gtk, Mac und Windows zusätzlich ein dem systemüblichen angepasstes eigenes Look and Feel. Es existieren eine Reihe unabhängig entwickelter Erscheinungsbilder, wovon die meisten auf Metal basieren. Seit Java 1.5 ist das Synth-Look-and-Feel hinzugekommen, dessen aus Bildern zusammengesetztes Erscheinungsbild in einer XML-Datei beschrieben wird, sodass kein Java-Code geschrieben werden muss. Mit Java 1.6, Update 10 wurde das vollständig vektorbasierte Nimbus-Look-and-Feel eingeführt.^[1]

Leichtgewichtige Komponenten

Swing-Komponenten werden direkt von Java gerendert und sind nicht von nativen Betriebssystemkomponenten abhängig. Dadurch funktionieren alle Swing-Komponenten auf allen Plattformen gleich, unabhängig davon, ob die entsprechende Plattform eine Komponente zur Verfügung stellt oder nicht. Der Nachteil ist, dass eine Swing-Anwendung nicht wie eine für das Betriebssystem entwickelte Anwendung aussieht. Das kann aber durch eine Auswahl an entsprechenden Pluggable Look-and-Feels kompensiert werden. Diese Eigenschaft wird mit dem englischen Wort Lightweight UI beschrieben (lightweight = all-Java language).

Vergleich

Im Vergleich zu AWT hat man mit Swing folgende zusätzliche Komponenten, die zur Oberflächenerzeugung genutzt werden können:

• Keyboard Accelerators, also Tastenkombinationen zur Steuerung von Komponenten
• Drag and Drop
• Setzen des Look and Feel
• Tooltips
• automatisches Double Buffering
• neue Layout-Manager/Panels
• Anwendungen mit Multiple Document Interface
• zusätzliche Komponenten, um Tabellen und Baumstrukturen darzustellen

Multithreading

Swing ist nicht thread-sicher, es kann also zu unerwarteten Wechselwirkungen zwischen verschiedenen Threads kommen, wenn nicht sorgfältig programmiert wird.^[2] Stattdessen sind die Swing-Komponenten so implementiert, dass ihre Methoden stets in einem sogenannten Event Dispatch Thread des AWT ausgeführt werden müssen, der die gesamte Ereignisverarbeitung grafisch-interaktiver Java-Anwendungen durchführt.^[3] Um dies zu vereinfachen, stellt die Hilfsklasse SwingUtilities zwei Methoden bereit, die aus anderen Threads heraus aufgerufen werden können und ein ausführbares Objekt vom Typ Runnable als Parameter nehmen.^[4]

• invokeLater reiht das ausführbare Objekt in die Ereigniswarteschlange von AWT ein und kehrt noch vor dessen Ausführung in den aufrufenden Code zurück. Der aufrufende Thread wird also nicht blockiert.
• invokeAndWait reiht das ausführbare Objekt in die Ereigniswarteschlange von AWT ein und wartet, bis es abgearbeitet wurde. Der aufrufende Thread wird also blockiert.

Verstöße gegen diese Konventionen werden dem Programmierer nicht gemeldet, so dass damit verbundene Schwierigkeiten lange unentdeckt bleiben bzw. gar nicht behoben werden. UI-Frameworks wie SWT oder auch .NET WinForms handhaben dies anders und quittieren fehlerhafte Aufrufe sofort.

Außerhalb des JRE stellte Sun eine SwingWorker genannte Basisklasse zur Verfügung, die zwei zu überladende Methoden anbietet: Eine, die in einem eigenen Thread aufgerufen wird und eine längerdauernde Operation ausführen kann und eine weitere, die nach dem Ende dieser Operation im Event Dispatch Thread ausgeführt wird und Swing-Komponenten manipulieren darf. Des Weiteren existiert ein Mechanismus, der es erlaubt, Zwischenschritte (z. B. in einer Fortschritts-Anzeige) zu visualisieren. Seit Java 1.6 ist sie als javax.swing.SwingWorker im JRE enthalten.

Geschichte

Swing wurde erstmals mit dem JDK 1.1.5 Ende 1997 als externe Bibliothek ausgeliefert und ist seit JDK 1.2 („Java 2“) Ende 1998 fester Bestandteil der Java-Laufzeitumgebung. Swing hatte sehr bald den Ruf, eine schlechte Performance aufzuweisen und für „ernsthafte“ Anwendungen ungeeignet zu sein. Der Standard-Stil (Look&Feel) von Swing-Fenstern fand ebenfalls nicht besonders viele Freunde.

Sun legte daraufhin großes Augenmerk auf die Verbesserung des Aussehens der mitgelieferten Look and Feels, sowie der Performance von Swing. Mittlerweile hat sich die Performance durch verbesserte Hardwareunterstützung der Beschleunigungsfunktionen von Grafikkarten, sowie über Performance-Verbesserungen in den Klassenbibliotheken selbst und bei der Java Runtime deutlich verbessert. Spätestens seit Java Version 1.4 2002 weist Swing keine merkbaren Performanceunterschiede zu nativen GUIs auf. Auch Performancevergleiche zwischen Swing und SWT zeigen keine Performanceunterschiede auf.^[5]

Beispiel

Als Beispiel für eine Swing-Anwendung wird hier das Hallo-Welt-Programm angegeben:

import javax.swing.*;

public class HelloWorldSwing {
    public static void main(String[] args) {
        // Verpacke den auszuführenden Quellcode in ein eigenes Runnable-Objekt, 
        // um diesen nachher im Event Dispatching Thread ausführen zu können
        Runnable guiCreator = new Runnable() {
            public void run() {
                // Erstellt das Swing-Fenster
                JFrame fenster = new JFrame("Hallo Welt mit Swing");
                // Swing anweisen, das Programm zu beenden, wenn das Fenster geschlossen wird
                fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                // Fügt den "Hallo Welt"-Text hinzu
                JLabel label = new JLabel("Hallo Welt");
                fenster.add(label);

                // Zeigt das Fenster an
                fenster.setSize(300, 200);
                fenster.setVisible(true);
            }
        };

        // Führe den obigen Quellcode im Event-Dispatch-Thread aus
        SwingUtilities.invokeLater(guiCreator);
    }
}

Teile dieses Quellcodes werden von unterschiedlichen Threads ausgeführt. Der Thread, der die Methode main ausführt, ist für gewöhnlich nicht der Event-Dispatch-Thread (EDT). Swingkomponenten sollten jedoch generell nur vom EDT erzeugt und verändert werden (falls in der Dokumentation nicht ausdrücklich anderes steht). Daher wird der Quellcode für die GUI in ein eigenes Runnable-Objekt verpackt. Der Thread, der die Methode main ausführt, erzeugt also nur das Runnable-Objekt und weist Swing an, diesen Quellcode später im EDT auszuführen.

Erweiterungen

Swing lässt sich an verschiedenen Stellen mittels des in Swing eingebauten Plug-In-Konzeptes erweitern. Typische Erweiterungen betreffen Look&Feels, Layoutmanager und weitere Komponenten.

Das SUN-Open-Source-Projekt SwingLabs bietet eine Reihe von Erweiterungen für Swing und dient als Testumgebung für zukünftige Erweiterungen von Swing. Unter anderem wurden in SwingLabs die in Java 6 eingeführten Klassen GroupLayout, SystemTray und Desktop gehostet. Weitere Erweiterungen werden von der java.net Java Desktop Community^[6] im Java Desktop Swing Depot gesammelt.^[7] JGoodies von Karsten Lentzsch bietet ebenso eine Reihe an Swing-Erweiterungen, wie beispielsweise das FormLayout.^[8]

Das Projekt Spring Richclient bietet eine Integration von Swing in das Spring Framework. Es wird allerdings seit Mitte 2009 nicht mehr weiterentwickelt.

Editoren

Es gibt eine Reihe meist kostenpflichtiger WYSIWYG GUI Design Tools für Swing. Die folgenden sind die bekanntesten:^[9]

• JFormDesigner – Kommerzieller Editor, sowohl eigenständig als auch als Eclipse-, IntelliJ-IDEA- und JBuilder-Plugin
• Jigloo – Kommerzielles Eclipse-Plugin für Swing- und SWT-GUIs, kostenlos für nicht kommerzielle Zwecke
• Eclipse WindowBuilder – offizielles Eclipse-Plugin für Swing-, SWT-, AWT- und GWT-Oberflächen
• Matisse4MyEclipse – Portierung von Matisse, dem GUI-Builder der NetBeans IDE, für Eclipse und Swing, läuft nur unter MyEclipse
• Visual Editor – Open-Source-Eclipse-Plugin für Swing- und SWT-GUIs (zugehöriges Entwicklungsprojekt ist seit April 2012 nicht mehr aktiv)

Literatur

• Deutschsprachige Bücher:
  • David Geary: Graphic Java 2.0 Band II. Die JFC beherrschen (Swing). 3. Auflage. Markt+Technik, 15. November 1999, ISBN 3-8272-9590-4 (Übersetzung des englischen Originals)
  • David Geary: Graphic Java 2.0. Die JFC beherrschen (AWT). 3. Auflage. Markt+Technik, 15. Juli 1999, ISBN 3-8272-9585-8 (Übersetzung des englischen Originals)
  • Paul Fischer: Grafik-Programmierung mit Java-Swing. Addison-Wesley, 15. September 2001, ISBN 3-8273-1910-2
• Englischsprachige Bücher:
  • Marc Loy, Robert Eckstein, Dave Wood: Java Swing. 2. Auflage. O’Reilly, November 2002, ISBN 0-596-00408-7
  • Kathy Walrath, Mary Campione, Alison Huml: The JFC Swing Tutorial. 2. Auflage. Addison-Wesley Professional, Februar 2004, ISBN 0-201-91467-0 (Referenz)
  • Kim Topley: Core Swing Advanced Programming. Prentice Hall, 2000, ISBN 0-13-083292-8
  • Kim Topley: Core, Java Foundation Classes. Prentice Hall, 1998, ISBN 0-13-080301-4
  • David M. Geary: Mastering the JFC – Volume II Swing. 3. Auflage. Prentice Hall PTR, 1998, ISBN 0-13-079667-0 (Referenz)
  • David M. Geary: Mastering the JFC – Volume I AWT. 3. Auflage. Prentice Hall PTR, 1999, ISBN 0-13-079666-2 (Referenz)

Weblinks

• „The Swing Tutorial“ bei Oracle
• Christian Ullenboom: Java ist auch eine Insel. Einführung in grafische Oberflächen. ISBN 978-3-8362-7737-2

Einzelnachweise

1. Swing Enhancements in the Java Standard Edition 6.0 und SE 6 Update 10 Release Notes bei Oracle
2. Christian Ullenboom: Swing ist nicht Thread-sicher. (online [abgerufen am 9. März 2008]). 
3. AWT Threading Issues. (online [abgerufen am 18. April 2007]). 
4. SwingUtilities (Java Platform SE 6). 2006 (online [abgerufen am 18. April 2007] Java-API-Dokumentation). 
5. Križnar Igor: SWT Vs. Swing Performance Comparison. (PDF) cosylab.com, 3. März 2006, archiviert vom Original am 4. Juli 2008; abgerufen am 16. September 2009: „Initial expectation before performing this benchmark was to find SWT outperform Swing. This expectation stemmed from greater responsiveness of SWT-based Java applications (e.g., Eclipse IDE) compared to Swing-based applications. However, this expectation could not be quantitatively confirmed.“  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/cosylib.cosylab.com 
6. Java Desktop (Memento des Originals vom 29. Juli 2005 im Internet Archive)  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/community.java.net
7. Swing Depot: Component Suites (Memento des Originals vom 9. Juni 2009 im Internet Archive)  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/www.javadesktop.org
8. JGoodies Homepage
9. Bernhard Steppan: Graphical User Interface: GUI-Builder für Eclipse im Vergleich. In: Computerwoche. 11. November 2004, abgerufen am 7. Dezember 2023.