Swing (Java)

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Die Widgets von Swing mit dem Ocean Look and Feel (Standard seit Java 1.5)
Klassenhierarchie von AWT und Swing

Bei Swing handelt es sich um eine Programmierschnittstelle (API) und Grafikbibliothek zum Programmieren von grafischen Benutzeroberflächen. Swing wurde von Sun Microsystems für die Programmiersprache Java entwickelt. 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 & 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.

Merkmale[Bearbeiten]

Aufbau[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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

Multithreading[Bearbeiten]

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.

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 dieser Operation im Event Dispatch Thread ausgeführt wird und Swing-Komponenten manipulieren darf. Seit Java 1.6 ist sie als javax.swing.SwingWorker im JRE enthalten.

Geschichte[Bearbeiten]

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[Bearbeiten]

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

import javax.swing.*;
 
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[Bearbeiten]

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.

Swing-Editoren[Bearbeiten]

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
  • Window Builder Pro – Ehemals kommerzielles Eclipse-Plugin für Swing-, SWT- und GWT-GUIs, wird aktuell zu einem Eclipse Projekt überführt.[10]
  • 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 1012 nicht mehr aktiv)

Literatur[Bearbeiten]

  • 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[Bearbeiten]

Einzelnachweise[Bearbeiten]

  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 (Java-API-Dokumentation, online, abgerufen am 18. April 2007).
  5. Križnar Igor: SWT Vs. Swing Performance Comparison (PDF) cosylab.com. 3. März 2006. 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.
  6. Java Desktop
  7. Swing Depot: Component Suites
  8. JGoodies Homepage
  9. Computerwoche: GUI-Builder für Eclipse (Version vom 16. Juli 2012 im Internet Archive).
  10. eclipse.org