Klassenlader (Class Loader) und Klassenpfad

Ein Klassenlader ist dafür verantwortlich, eine Klasse zu laden. Aus der Datenquelle (im Allgemeinen einer Datei) liefert der Klassenlader ein Byte-Array mit den Informationen, die im zweiten Schritt dazu verwendet werden, die Klasse ins Laufzeitsystem einzubringen; das ist Linking. Es gibt vordefinierte Klassenlader und die Möglichkeit, eigene Klassenlader zu schreiben, um etwa verschlüsselte und komprimierte .class-Dateien aus Datenbanken zu laden.

Klassenladen auf Abruf

Nehmen wir zu Beginn ein einfaches Programm mit zwei Klassen:

class Person {
   static String NOW = java.time.LocalDateTime.now().toString();
   public static void main( String[] args ) {
     Dog wuffi = new Dog();
   }
 }
 
 class Dog {
   Person master;
 }

Wenn die Laufzeitumgebung das Programm Person startet, muss sie eine Reihe von Klassen laden. Das tut sie dynamisch zur Laufzeit. Sofort wird klar, dass es zumindest Person sein muss. Wenn aber die statische main(String[])-Methode aufgerufen wird, muss auch Dog geladen sein. Und da beim Laden einer Klasse auch die statischen Variablen initialisiert werden, wird auch die Klasse LocalDateTime geladen.

Zwei weitere Dinge werden nach einiger Überlegung deutlich:

  • Wenn Dog geladen wird, bezieht es sich auf Person. Da Person aber schon geladen ist, muss es nicht noch einmal geladen werden.
  • Unsichtbar stecken noch andere referenzierte Klassen dahinter, die nicht direkt sichtbar sind. So wird zum Beispiel Object geladen, da implizit in der Klassendeklaration von Person steht: class Person extends Object. Auch String muss geladen werden, weil String einmal in der Signatur von main(String[]) vorkommt und es der Typ von now Intern ziehen die Typen viele weitere Typen nach sich. String implementiert Serializable, CharSequence und Comparable, also müssen diese drei Schnittstellen auch geladen werden. Und so geht das weiter, je nach dem, welche Programmpfade abgelaufen werden. Wichtig ist aber zu verstehen, dass diese Klassendateien so spät wie möglich geladen werden.

Im Beispiel mit den Klassen Person und Dog lädt die Laufzeitumgebung selbstständig die Klassen (implizites Klassenladen). Klassen lassen sich auch mit Class.forName(String) über ihren Namen laden (explizites Klassenladen).

Hinweis. Um zu sehen, welche Klassen überhaupt geladen werden, lässt sich der virtuellen Maschine beim Start der Laufzeitumgebung ein Schalter mitgeben -verbose:class. Dann gibt die Maschine beim Lauf alle Klassen aus, die sie lädt.

JAR-Dateien

Große Sammlungen von Java-Klassendatein und Ressourcen werden in sogenannten Java-Archiven, kurz JAR-Dateien, zusammengefasst. Diese Dateien sind im Grunde ganz normale ZIP-Archive mit einem besonderen Verzeichnis META-INF für Meta-Dateien. Das JDK bringt im bin-Verzeichnis das Werkzeug jar zum Aufbau und Extrahieren von JAR-Dateien mit.

JAR-Dateien behandelt die Laufzeitumgebung wie Verzeichnisse von Klassendateien und Ressourcen. Wenn Java-Software ausgeliefert wird, dann bieten sich JAR-Dateien an, denn es ist einfacher, nur ein komprimiertes Archiv weiterzugehen als einen großen Dateibaum. Zudem haben Java-Archive den Vorteil, dass sie signiert werden können und illegale Änderungen auffallen.

Woher die kleinen Klassen kommen: Die Suchorte und spezielle Klassenlader

Die Laufzeitumgebung nutzt zum Laden nicht nur einen Klassenlader, sondern mehrere. Die Java-Laufzeitumgebung nutzt diese verschiedenen Klassenlader um unterschiedliche Orte festzulegen. Ein festes Schema bestimmt die Suche nach den Klassen:

  1. Klassen Typen wie String, Object oder Point stehen in einem ganz speziellen Archiv. Wenn ein eigenes Java-Programm gestartet wird, so sucht die virtuelle Maschine die angeforderten Klassen zuerst in diesem Archiv. Da es elementare Klassen sind, die zum Hochfahren eines Systems gehören, werden sie Bootstrap-Klassen Das Archiv mit diesen Klassen heißt oft rt.jar (für Runtime). Andere Archive können hinzukommen – wie i18n.jar, das Internationalisierungsdaten beinhaltet. Die Implementierung dieses Bootstrap-Klassenlader ist nicht öffentlich und wird von System zu System unterschiedlich sein. Ab Java 9 wird sich das grundlegend ändern.
  2. Ist eine Klasse keine Bootstrap-Klasse, beginnt der System-Klassenlader Applikations-Klassenlader die Suche im Klassenpfad (Classpath). Diese Pfadangabe besteht aus einer Aufzählung einzelner Klassendateien, Verzeichnisse, Klassen oder JAR-Archive, in denen die Laufzeitumgebung nach den Klassendateien sucht. Standardmäßig ist dieser Klassenpfad auf das aktuelle Verzeichnis gesetzt („.“), er lässt sich aber beliebig setzen.

Kompakte Strings nun in Java 9 (JEP 254)

Wenn ein String nur aus Latin-1 Buchstaben besteht, dann kann die Zeichenfolge aus einem byte- statt einem char-Feld bestehen. Diese Änderung wurde in Java 9 nun umgesetzt: http://hg.openjdk.java.net/jdk9/jdk9/jdk/rev/4f6e52f9dc79. Gerade bei IDs lässt sich so 1/2 vom Speicher sparen. Und da Strings immutable sind, muss man nicht konvertieren.

Teurer wird es beim „Mischen“ wie:

String /*intern char[]*/ s  =  "λφα";
String /*intern char[]*/ t  =  " " /*intern byte[]*/
                                +
                                s  /*intern char[]*/;

Intern wird hier eine inflate()-Methoden aufgerufen:

If the coder is "isLatin1", this inflates the internal 8-bit storage to 16-bit <hi=0, low> pair storage.

Inselraus: Swings JLayeredPane

Die JLayeredPane nimmt JComponent-Objekte auf und stellt sie in einer geschichteten Reihenfolge (auch Z-Order genannt) dar. Die Layered Pane besteht selbst wieder aus zwei Objekten, einer Menüzeile und der Inhaltsfläche Content-Pane. Container vom Typ JLayeredPane platzieren ihre Kinder in Ebenen (engl. layers). Jedem Kind wird eine Ebene zugewiesen, und beim Zeichnen werden die Kinder von unten nach oben gezeichnet. Damit werden die Komponenten, die unter anderen Komponenten liegen, unter Umständen verdeckt. Standardmäßig hat die JLayeredPane keinen zugewiesenen Layoutmanager, und Objekte müssen mit setBounds(…) positioniert werden.

Wird ein JLayeredPane-Container verwendet, ist die add(…)-Methode so implementiert, dass sie die Komponenten auf einer Standardebene (JLayeredPane.DEFAULT_LAYER) platziert. Um Komponenten auf eine eigene Ebene zu setzen, sodass sie vor oder hinter anderen Komponenten liegen, wird ihnen eine eigene Ebene zugewiesen, und zwar mit einem Wert relativ zu DEFAULT_LAYER. Kleinere Werte bedeuten, dass die Komponenten unten liegen, und hohe bedeuten, dass sie oben liegen. Ein Beispiel:

layeredPane.add( component, new Integer(5000) );

Für einige Ebenen sind Werte als Konstanten deklariert. Dazu zählen zum Beispiel JLayered-Pane.DEFAULT_LAYER (0), PALETTE_LAYER (100), MODAL_LAYER (200), POPUP_LAYER (300) und DRAG_LAYER (400).

Neben der Möglichkeit, die Ebenen festzulegen, lässt sich die Reihenfolge innerhalb der Ebene später durch die Methode moveToFront() oder moveToBack() verändern.

Inselraus: Swings JRootPane und JDesktopPane

Unter den JComponent-Objekten gibt es einige ausgezeichnete, die als Container für andere Kinder fungieren.

Wurzelkomponente der Top-Level-Komponenten (JRootPane)

Die Komponenten JFrame, JDialog, JWindow, JApplet und JInternalFrame enthalten als einziges Kind den leichtgewichtigen Container JRootPane. Die Methode getRootPane() liefert dieses JRootPane-Objekt. Die JRootPane verwaltet eine Layered Pane, die wiederum Content-Pane und Menü aufnimmt, und eine Glass-Pane, die wie eine Glasscheibe über allen anderen Komponenten liegt. Sie kann Ereignisse abfangen oder in einer paint(…)-Methode etwas über alle Komponenten zeichnen.

Beispiel: Weise der Glass-Pane einen wartenden Cursor zu:

Component c = getRootPane().getGlassPane();
 if( c != null )
   c.setCursor( Cursor.getPredefinedCursor( Cursor.WAIT_CURSOR ) );

 JDesktopPane und die Kinder von JInternalFrame

Die JDesktopPane ist eine Unterklasse von JLayeredPane und als Container für interne Fenster – also Objekte vom Typ JInternalFrame – gedacht. Mit internen Fenstern (engl. internal frames) lassen sich MDI-Applikationen implementieren, also GUI-Anwendungen, bei denen nicht das grafische Betriebssystem die Fenster verwaltet, sondern die eigene Anwendung.

Bevor ein JInternalFrame sichtbar wird, muss der Container erzeugt und sichtbar gemacht werden:

JDesktopPane desktop = new JDesktopPane();
 container.add( desktop );

Jetzt können beliebig viele JInternalFrame-Objekte erzeugt und auf der JDesktopPane platziert werden. Der einfachste Konstruktor ist der Standard-Konstruktor, der einen nicht vergrößerbaren, nicht schließbaren, nicht maximierbaren und nicht zum Icon verkleinerbaren JInternal-Frame ohne Titel erzeugt. Der ausführlichste Konstruktor erlaubt eine genaue Parametrisierung:

JInternalFrame iframe = new JInternalFrame( title, resizable, closeable,
   maximizable, iconifiable );

Zwar gibt es nun ein Exemplar, doch wäre es nach dem Aufsetzen auf den Container noch nicht sichtbar:

iframe.setVisible( true );

Bis zur Vollständigkeit fehlen aber noch die Maße:

iframe.setSize( /* width = */ 200, /* height = */ 100 );

Nun kann der iframe dem Container hinzugefügt werden:

desktop.add( iframe );

In einem kompletten Programm kann das so aussehen:

package com.tutego.insel.ui.swing;
 
 import javax.swing.*;
 import static java.lang.Math.random;
 
 public class JInternalFrameDemo {
 
   static void addInternalToDesktop( JDesktopPane desktop )
   {
     JInternalFrame iframe;
     iframe = new JInternalFrame( "Ein internes Fenster",  // title
                                  true,                    // resizable
                                  true,                    // closeable
                                  true,                    // maximizable
                                  true );                  // iconifiable
 
     iframe.setBounds( (int)(random() * 100), (int)(random() * 100),
                       100 + (int)(random() * 400), 100 + (int)(random() * 300) );
     iframe.add( new JScrollPane(new JTextArea()) );
     iframe.setVisible( true );
 
     desktop.add( iframe );
   }
 
   public static void main( String[] args ) {
     JFrame f = new JFrame();
     f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
     JDesktopPane desktop = new JDesktopPane();
     f.add( desktop );
     f.setSize( 500, 400 );
     addInternalToDesktop( desktop );
     addInternalToDesktop( desktop );
     addInternalToDesktop( desktop );
     f.setVisible( true );
   }
 }

Hinweis: Die Schnittstelle von JInternalFrame erinnert an JFrame, doch ist die Ereignisbehandlung anders. So besitzt JInternalFrame eine Methode addInternalFrameListener(…) an Stelle von addWindowListener(…). Ein JInternalFrame empfängt keine WindowEvents, daher darf es addWindowListener(…) – wie es JFrame von java.awt.Window erbt – auch nicht besitzen.

Inselraus: Die Windows-Optik von Swing mit JGoodies Looks verbessern

Zwar bemüht sich das JDK bestmöglich das Windows-Look-and-Feel zu emulieren, doch das gelingt nicht an allen Stellen. Selbst bei dem aktuellen JDK ist das noch nicht perfekt, wobei die Implementierung unter Windows auf den nativen Windows-Renderer zurückgreift. Und kleine Verbesserungen lassen sich auch nicht so einfach publizieren, da die Release-Zyklen vom JDK lang sind. In diesem Fall hilft JGoodies Looks (http://www.jgoodies.com/freeware/libraries/looks/), ein freies Look-and-Feel unter der BSD-Lizenz. Das Ziel von Looks ist die perfekte Nachbildung des Aussehens für alle Windows-Versionen. Gegenüber dem Windows-Look-and-Feel vom JDK korrigiert es viele Feinheiten, wie passende Insets bei Eingabefeldern, Icons, Farben, Rahmen, den richtigen Font, Menüeigenschaften, Auflösungen von 96 und 120 dpi und vieles mehr. Gesetzt wird Looks wie jedes andere LAF:

try {
   String laf = Options.getSystemLookAndFeelClassName();
   UIManager.setLookAndFeel( laf );
 } catch ( Exception e ) {
   System.err.println( "L&F lässt sich nicht initialisieren: " + e );
 }

Inselraus: Die Zusatzkomponentenbibliothek SwingX

Für ernsthafte grafische Oberflächen mit Swing sind die Standardkomponenten der Java SE etwas mau. Wichtige Komponenten wie ein Datumsauswahldialog fehlen, zum Teil sind die angebotenen Komponenten nicht leistungsfähig genug. So kann beispielsweise die Swing-Textkomponente zwar einfaches HTML darstellen, scheitert aber an komplexeren Dokumenten mit CSS. Da die Java Foundation Classes in den letzten Jahren sehr stabil geblieben sind – es gab keine großen Änderungen oder nennenswerte neue Komponenten –, bleibt Entwicklern nichts anderes übrig, als entweder

  • die benötigten Swing-Komponenten selbst zu entwickeln oder
  • sich im Open-Source-Umfeld umzuschauen bzw.
  • eine kommerzielle Swing-Komponentenbibliothek einzukaufen.

Wie üblich ist die Eigenentwicklung immer nur die letzte Option. Im Laufe der letzten Jahre haben sich einige sehr gute quelloffene Swing-Zusätze etabliert. Hervorzuheben ist SwingX, ein Projekt, von dem lange Zeit gedacht wurde, dass die Komponenten in das javax.swing-Paket aufgenommen würden. Das ist aber bisher nicht passiert, nur eine Komponente hat es – wen auch abgewandelt – in die Standardbibliothek geschafft.

Hinweis: Aktiv wird SwingX nicht mehr weiterentwickelt.

Im Angebot: Erweiterte und neue Swing-Komponenten

Die SwingX-Bibliothek erweitert Swing auf zwei Arten:

  • Einige SwingX-Komponenten erweitern die Standard-Swing-Komponenten und fügen Funktionalität hinzu. So ist JXFrame eine Unterklasse von JFrame und kann zum Beispiel eine Statuszeile haben. Oder JXTable ist eine Unterklasse von JTable mit zusätzlicher Suchfunktionalität und dem Vorteil, dass sich Spalten automatisch ein-/ausblenden lassen.
  • SwingX definiert ganz neue Swing-Komponenten, etwa eine Mischung aus Tabelle und Baum (JXTreeTable), ausfaltbare Container oder einen Login-Dialog.

Um einen ersten Überblick über SwingX zu bekommen, lohnt es sich, einen Blick auf das SwingX-Demo zu werfen. Auf der SwingX-Homepage http://swingx.java.net/ wird auf die Web-Startapplikation verlinkt (http://swinglabs-demos.java.net/demos/swingxset6/swingxset.jnlp).

Überblick über erweiterte Standard-Swing-Klassen

SwingX nimmt einige Klassen als Basisklassen und fügt Funktionalität hinzu. Die Standardkomponenten lassen sich problemlos gegen die neuen Klassen austauschen.

SwingX-Klasse Swing-Basisklasse Aufgabe
JXButton JButton Schaltfläche mit Unterstützung für Painter
JXLabel JLabel Beschriftung mit Unterstützung für Painter
JXTable JTable stark erweiterte Tabelle mit Suche, Sortierung, Filterung, …
JXList JList stark erweiterte Liste mit Suche, Sortierung, Filterung, …
JXTree JTree stark erweiterter Baum mit Suche, Filterung, …
JXFrame JFrame Fenster mit optionaler Statuszeile, Warte-zustand, …
JXDialog JDialog Vereinfacht den Aufbau von Dialogen.
JXPanel JPanel Panel mit Transparenz und Painter
JXEditorPane JEditorPane verbesserte Editor-Funktionalität, Undo/Redo und Suche
JXComboBox JComboBox Verbessert den Edit-Modus beim Einsatz in einer Tabelle.
JXFormattedTextField JFormattedTextField Unterstützt Prompts und Buddies in formatierten Textzeilen.
JXTextArea JTextArea Unterstützt Prompts und Buddies in Text-bereichen.
JXTextField JTextField Unterstützt Prompts und Buddies in Text-zeilen.
JXRootPanel JRootPanel Wurzelkomponente mit Symbolleiste und Statuszeile

Erweiterte Standard-Swing-Klassen

Die Klassen JXTable, JXList, JXTreeTable sind sehr leistungsfähig und daher mit einem kleinen Satz kaum zu beschreiben. Die API-Dokumentation gibt mehr Informationen. Wichtig sind dabei Klassen aus dem Paket org.jdesktop.swingx.decorator, die für JXTable, JXTreeTable, JXTree und JXList Sortierung, Filterung und Hervorhebung unterstützen.

In den Zellen tauchen zudem die Begriffe Painter, Prompt und Buddy auf:

  • Ein Painter ist ein Objekt, das an die SwingX-Komponente gesetzt wird. Zum Zeichnen greift die SwingX-Klasse auf das externe Zeichenobjekt zurück. Der Vorteil ist, dass so keine Unterklassen nötig sind, etwa von JButton oder JLabel, nur wenn in den Zeichenprozess eingegriffen werden soll.
  • Prompts und Buddies zeigen bei JXTextField, JXFormattedTextField und JXTextArea Eingabehinweise oder Fehler.

Neue Swing-Klassen

Zusätzlich zu den Erweiterungen der Standard-Swing-Komponenten bietet SwingX weitere Komponenten. Manche sind dringend nötig, etwa zur Auswahl eines Datums, einige sind sehr speziell, etwa zum Zeichnen eines 2D-Graphen.

SwingX-Klasse Swing-Basisklasse Aufgabe
JXDatePicker JComponent Datumseingabe im Textfeld mit Popup-Menü
JXHyperlink JButton Hyperlink
JXBusyLabel JLabel Animation für Ladeprozesse
JXTreeTable JXTable Verschmilzt Tabelle und Baum.
JXStatusBar JComponent Statuszeile, in der Regel unten am Fenster
JXErrorPane JComponent Darstellung von Fehlermeldungen
JXMultiThumbSlider JComponent Slider mit zwei Knöpfen
JXMonthView JComponent Zeigt Monatskalender und erlaubt Monats-auswahl.
JXSearchField JXTextField Textfeld mit kleinem Such-Icon
JXRadioGroup JPanel Vereinfacht die ButtonGroup.
JXMultiSplitPane JPanel geschachtelte Split-Panels
JXCollapsiblePane JXPanel animierte ausfaltbare Panels
JXTaskPane JXPanel Titel mit Icon zum Ausfalten der Container-elemente
JXTaskPaneContainer JXPanel Container für mehrere JXTaskPanes
JXTipOfTheDay JXPanel Gibt den „Tipp des Tages“ aus.
JXTitledPanel JXPanel Panel mit Überschrift
JXTitledSeparator JXPanel Trennlinie mit Text
JXImageView JXPanel Zeigt ein Bild, ein neues kommt mit Drag & Drop.
JXColorSelectionButton JButton Zeigt bei Aktivierung einen Farbauswahldialog.
JXGradientChooser JXPanel Panel zum Aufbau eines Farbverlaufs (-Gradient)
JXGraph JXPanel Zeichnet 2D-Graphen.

Neue Klassen, die SwingX bietet

Zur Suche gehören noch ein paar andere Komponenten, die nicht aufgeführt sind. Für die JXTable gibt es weiterhin JXTableHeader, was eine Spezialisierung von JTableHeader ist.

Weitere SwingX-Klassen

Des Weiteren gibt es ein paar neue Layoutmanager, etwa HorizontalLayout, VerticalLayout oder StackLayout (setzt alle Komponenten aufeinander). SwingX unterstützt ebenfalls die Tastaturvervollständigung bei Textfeldern und der Combo-Box. Beispiele finden sich im Paket org.jdesktop.swingx.autocomplete.

SwingX-Installation

Wer SwingX einsetzen möchte, der lädt von http://java.net/downloads/swingx/releases/ das Java-Archiv swingx-all-1.6.4.jar (etwa 1,4 MiB) herunter und bindet es in den Klassenpfad ein. Auf den Seiten sind auch die Quellen und die Java-API-Dokumentation verlinkt. Nach dem Einbinden stehen die neuen Klassen unter dem Paket org.jdesktop.swingx zur Verfügung.

Zusätzliche statische Initialisier im enum

Es sind Blöcke der Art static { … } im Rumpf eines Aufzählungstyps erlaubt. Lädt die Laufzeitumgebung einer Klasse, initialisiert sie der Reihe nach alle statischen Variablen bzw. führt die static-Blöcke aus. Die Aufzählungen sind statische Variablen und werden beim Laden initialisiert. Steht der statische Initialisierer hinter den Konstanten, so wird auch er später aufgerufen als die Konstuktoren, die vielleicht auf statische Variablen zurückgreifen wollen, die der static-Block initialisiert. Ein Beispiel:

public enum Country {
  GERMANY, UK, CHINA;
  {
    System.out.println( "Objektinitialisierer" );
  }
  static {
    System.out.println( "Klasseninitialisier" );
  }

  private Country() {
    System.out.println( "Konstruktor" );
  }

  public static void main( String[] args ) {
    System.out.println( GERMANY );
  }
}

Die Ausgabe ist:

Objektinitialisierer

Konstruktor

Objektinitialisierer

Konstruktor

Objektinitialisierer

Konstruktor

Klasseninitialisier

GERMANY

Die Ausführung und Ausgabe hängt von der Reihenfolge der Deklaration ab und jede Umsortierung führt zu einer Verhaltensänderung. Jetzt könnten Programmierer auf die Idee kommen, mögliche static-Blöcke an den Anfang zu setzen, vor die Konstanten. Meine Leser sollten das Ergebnis testen …

Thema der Woche: Properties und Bean-Bindings

  1. Lies https://docs.oracle.com/javase/8/javafx/properties-binding-tutorial/binding.htm.
  2. Simuliere in einem Beispiel den Unterschied zwischen einem Change- und Invalid-Event.
  3. Was ist ein Java SE Profil und gehört die Property-API immer zu jedem Profil?
  4. Verschaffe Überblick über https://docs.oracle.com/javase/8/javafx/api/javafx/beans/binding/Bindings.html.
  5. Baue ein Bindung für ein double mit folgender Logik: ist das double echt kleiner als 0, ist das Ergebnis -1, wenn es größer/gleich 0 ist, ist das Ergebnis +1.
  6. Schreibe einige neues Bindings:
  • von double -> boolean, wenn double == 0 ist,
  • von Point -> double für den Abstand zum Nullpunkt
  • von String -> Point, wobei der String „1,23“ dann zum new Point(1,23) wird
  • verknüpfe die drei letzten Properties, dass ein String mit einem Punkt auf boolean abgebildet wird

Neues ReactJS Nachrichtenportal

http://reactjs.de/ ist eine neue Webseite, die sich mit der JS-Bibliothek ReactJS beschäftigt und Nachrichten kanalisiert.

http://reactjs.de/posts/react-tutorial charakterisiert es so:

React ist eine JavaScript-Bibliothek zum Erstellen von Benutzeroberflächen. Es wurde 2013 von Facebook unter BSD-Lizenzveröffentlicht und schlägt seitdem immer größere Wellen und beeinflusst nachhaltig die gesamte JavaScript-Frontendlandschaft. Es wird verwendet von Facebook, Instagram, Whatsapp, Yahoo, AirBnB, dem Atom-Editor undvielen anderen mehr.

WildFly 10 Beta herausgegeben

Detail unter http://wildfly.org/news/2015/08/09/WildFly10-Beta1-Released/ und https://developer.jboss.org/wiki/WildFly1000Beta1ReleaseNotes, kurz zusammengefasst:

  • Continued Java EE7 Support

  • Java 8+ Required

  • ActiveMQ Artemis

  • JavaScript Support with Hot Reloading

  • Offline CLI Support For Domain Mode

  • HA Singleton Deployments

  • Migration Operations for Legacy Subsystems

  • Capabilities and Requirements

  • Hibernate 5

  • Infinispan 8

Guava 19.0-rc1 herausgekommen

Die Änderungen führt https://github.com/google/guava/wiki/Release19 auf.

Von meiner Seite bin ich nicht mehr so scharf auf Guava, ich komme mittlerweile seit Java 8 ganz gut ohne aus. Klar, könnte ich mehr Guava nutzen, doch ich kann auch ohne, auch wenn ich einmal eine Argument mehr an eine Methode setze.

Heiß her geht auch die Diskussion auf einen Java 8-Umstieg (https://groups.google.com/forum/#!topic/guava-discuss/fEdrMyNa8tA). Die Google Entwickler wissen nicht so recht, was der beste Weg ist, da man bemüht ist, mit einer neuen Java 8-Version keinen alten Code zu brechen.