4  Java

Die Java Platform, Standard Edition 6 API Specification listet über 3700 Klassen auf, und im Internet finden sich unzählige qualitativ hochwertige Programme und Bibliotheken, die nicht nur in Java geschrieben, sondern auch unter freien Lizenzen verfügbar sind. In den meisten Fällen erlauben die Lizenzen auch eine kommerzielle Verwendung. Dieses reichliche Angebot hat dazu geführt, dass kommerzielle Softwareentwicklung heute oft darin besteht, die passenden Bibliotheken zu finden, zu konfigurieren und sie dann mit dem noch fehlenden eigenen Code zusammenzufügen. Clojure integriert sich so nahtlos in die Java-Landschaft, dass die Verwendung beider Sprachen in einem Programm in fast allen Fällen möglich ist, was ein großer Vorteil ist. Manch neue Sprache scheitert an ihrer zu kleinen Standardbibliothek, aber auch Sprachen mit langer Geschichte, gerade in der Lisp-Familie, haben oft eine zerklüftete Bibliotheken-Landschaft. Für Common Lisp finden sich entgegen der landläufigen Meinung zwar zahlreiche Bibliotheken für diverse Anforderungen, doch ist deren Integration oft unzulänglich, und auch die Qualität der Dokumentation oder die Vollständigkeit der Implementation lassen häufig zu wünschen übrig. Selbst auf der JVM laufende Sprachen, die von ihrer kanonischen Implementation portiert wurden, wie Jython oder JRuby, fügen sich nicht vollkommen nahtlos ein, da sie durch ihre primäre Plattform nicht immer mit Javas Typsystem harmonieren. Harmonie mit der JVMPython beispielsweise verfügt über keinen Typen für einen Character und kennt nur Doubles, die allerdings in Python „float“ heißen. Deutlich schwieriger wird es aber in den Fällen, in denen eine Bibliothek, egal ob Teil des Standards oder extern, weitere Abhängigkeiten hat. Die C-Implementation von Python beispielsweise unterstützt die Entwicklung von Terminal-Interfaces mit der Curses-Bibliothek, Jython hingegen nicht. Nichtsdestotrotz sind diese Sprachen natürlich der JVM sehr nah und integrieren sich recht gut in die Java-Infrastruktur.

Dieses Kapitel beschreibt die Verwandtschaft von Clojure und Java. Dabei richten wir unser Augenmerk nicht ausschließlich auf den üblichen Fall, dass Java-Klassen aus Clojure verwendet werden sollen, was bereits in Abschnitt 2.5 grundlegend beschrieben wurde. Auch die Gegenrichtung, Clojure aus Java zu verwenden, findet Beachtung. Letzteres ist auf zwei Ebenen möglich.

4.1  Java aus Clojure

Java-Klassen und Methoden direkt aus Clojure zu verwenden, gilt in der Clojure-Welt nicht als unfein oder Lösung zweiter Klasse. Es ist vollkommen idiomatischer Code. Tatsächlich rät Rich Hickey sogar von der Entwicklung von Wrapper-Bibliotheken, die lediglich den Zugriff auf bestimmte Klassen vereinfachen sollen, ab. Java bietet bereits in seiner Standard Edition ein so umfangreiches Ensemble von Lösungen, dass ein pragmatischer Ansatz, der versucht, in möglichst kurzer Zeit qualitativ möglichst hochwertige Programme zu schaffen, dieses Angebot nicht ignorieren darf. Einfache Syntax: PunktWenn aber dieser Zugriff als so relevant betrachtet wird, muss er einfach erfolgen können. Das ist in Clojure der Fall: Vereinfacht gesagt ist Clojures Syntax für den Griff in die Java-Welt der Punkt.

4.1.1  Konstruktoren und Methoden

Einer der ersten Schritte ist die Instantiierung von Klassen. dies wurde bereits in der Einleitung in Abschnitt 2.5 verwendet. Die ausführliche Form ist die Verwendung von new:

Eventuelle Argumente an den Konstruktor werden in diesen Aufruf mit eingeschlossen:

Der erste Ausdruck, bei dem der Name der Methode die Position des Funktionsaufrufs einnimmt, entspricht der Syntax eines normalen Clojure-Aufrufs. Diese Variante ist wohl auch die derzeit am häufigsten auftretende, was eine rekursive Suche nach „(\. “ und „(\.[a-zA-Z]“ im Wurzelverzeichnis der Contrib-Bibliothek mit ca. 700:30 andeutet. Für die meisten Java-Programmierer hingegen wird die alternative Reihenfolge vertrauter erscheinen. Das zusätzliche Paar Klammern, das im ersten Ausdruck den Methodennamen und die übergebenen Parameter umfasst, ist optional. Es kann jedoch einerseits die Lesbarkeit verbessern, bietet andererseits aber auch eine Alternative, die bei der Codeerzeugung durch Makros hilfreich sein kann.

Die Berechnung der Fläche eines Kreises mit zufälligem Radius demonstriert die Instantiierung eines Objekts der Klasse Random, einen Methodenaufruf auf diesem Objekt und die Verwendung des statischen Felds PI aus dem Math-Paket.

Hier kann der Aufruf von nextFloat nicht innerhalb des Rumpfes von doto erfolgen, da der Rückgabewert von doto das erzeugte Objekt ist. Gewünscht wird in diesem Fall aber die mit dem Zufallszahlengenerator erzeugte Zahl.

Ein weiteres, unvollständiges Beispiel verdeutlicht, was hier ausgedrückt werden soll:

In diesem Beispiel werden zwei Buttons erzeugt, die in einem anderen Codeabschnitt gezeichnet werden können. Dem Status der Drückbarkeit folgend, ist das dahinter liegende System aktuell „an“, kann aber durch Drücken des aktiven Buttons mit der Beschriftung „Aus“ ausgeschaltet werden. Der Button „An“ ist nicht aktiv, und genau diese Eigenschaft wurde durch das doto-Makro direkt im Zusammenhang mit der Instantiierung festgelegt, indem im Body von doto (.setEnabled false) aufgerufen wurde. Das Resultat ist eine deutlich „funktionalere“ Schreibweise eines an sich nicht funktionalen Vorgangs, nämlich der Erzeugung eines Objekts einer bestimmten Klasse und der darauf folgenden Manipulation dieses Objekts.

InMethodenaufrufe auf Methodenrückgabewerten vielen Fällen wird auf dem Rückgabewert einer Methode erneut eine Methode aufgerufen. In Clojure-Code existiert auch für diesen Anwendungsfall eine alternative Ausdrucksform. Als Beispiel verwenden wir hier eine XSL-Transformation, der das folgende, minimale DocBook-Beispiel zugrunde liegt.

Dies wird durch ein ganz simples XSL-Stylesheet konvertiert, das eine Kopie des Originals erzeugt.

Für dieses XSL-Stylesheet wird eine Instanz von Transformer aus einer TransformerFactory erzeugt. Auf dem Transformer erfolgt dann ein Aufruf von der Methode transformer, der das XML-Dokument als Argument übergeben wird. Das Resultat – hier inklusive der Imports und der Contrib-Bibliothek java-utils, aus der as-file importiert wird – ist durch die Schachtelung der vielen Aufrufe nicht für jeden leicht lesbar.

Dot-Dot macht den Ausdruck nicht notwendigerweise kürzer, aber – vor allem durch die Einrückung des Quelltexts – vermutlich für die meisten Anwender besser lesbar.

4.1.2  Weitere Funktionen auf Objektinstanzen

Java kennt das Schlüsselwort instanceOf , mit dem zur Laufzeit überprüft werden kann, ob ein Objekt einer bestimmten Klasse angehört. In Clojure ist dies mit dem Prädikat instance? möglich:

Allerdings scheint sich die Clojure-Gemeinde gegen die Verwendung dieser Funktion entschieden zu haben. Die Verwendung ist letztlich Geschmackssache.

4.1.3  Java-Arrays

In vielen bestehenden Java-Projekten und -Bibliotheken werden Java-Arrays von primitiven Datentypen wie int, long, etc. verwendet. Diese integrieren sich nicht so nahtlos in Clojure wie Javas Objekte. Ihre Verbreitung verlangt auch von Clojure die Behandlung von Java-Arrays.

Die gute Nachricht zuerst: Arrays können als Grundlage für Sequences dienen. Daher ist lesender Zugriff mit den bekannten Funktionen möglich, wie am Ende dieses Abschnitts demonstriert wird. Allerdings sind spezielle Funktionen für das Erzeugen sowie für indexbasierten Zugriff notwendig.

Die Funktion make-array erwartet mindestens den Objekttyp und die Länge des Arrays als Parameter. Die Verwendung der Funktionen alength, aget und aset sollte anhand des obigen Beispiels deutlich werden.

Es ist aus Performancegründen jedoch empfehlenswert, nicht mit den generischen Methoden auf Arrays von primitiven Typen zu operieren, sondern die typspezifischen Methoden wie int-array, byte-array, char-array usw. zum Erzeugen und Setzen von Werten zu verwenden.

Die Funktion iteriert über alle Elemente des Arrays a und bindet bei jedem Durchlauf den aktuellen Index an die Variable idx. Zusätzlich wird die Variable ret an das bisherige Ergebnis gebunden, was beim ersten Element des Arrays mit dem Inhalt von init vorbelegt ist. Mit diesen Variablenbindungen führt areduce dann den Ausdruck expr aus, dessen Rückgabewert im nächsten Schritt in ret zu finden sein wird.

Für die Demonstration dieser Funktion werden zunächst zwei Vars angelegt, die mit Hilfe von int-array an ein Array von ints gebunden werden.

Der nächste Schritt ist Definition und Aufruf der Funktion alle>1?, deren Aufgabe es ist, zu testen, ob alle Elemente eines Arrays größer als 1 sind. In dieser Funktion findet areduce Verwendung.

4.2  Interfaces und abgeleitete Klassen

Clojures Zusammenarbeit mit Java beschränkt sich nicht auf die Verwendung von Javas Klassen in Clojure. Die Integration mit verschiedenen Bibliotheken verlangt das Ableiten von Klassen, das Implementieren von Interfaces, und manchmal beginnt ein Programm sein Leben nicht an der REPL, sondern in einer Main-Funktion von Java, die dafür sorgt, dass benötigte Klassen nachgeladen werden. Auch diese Anforderungen deckt Clojure ab. Clojure-Code kann zu Klassen kompiliert werden, die von anderen abgeleitet sind oder Interfaces implementieren oder auch einfach so, wie sie sind, verwendet werden. Auch ohne kompilierte Klassen können mit Clojure Interfaces implementiert und Klassen abgeleitet werden: mit Hilfe eines Proxy-Objekts.

4.2.1  Proxy

Eine sehr einfache Form der Integration mit fremden Bibliotheken besteht darin, ein Proxy-Objekt mit Hilfe des Makros proxy zu erstellen. Dessen formale Syntax lautet:

4.2.2  Klassen kompilieren

Im Umfeld von Java ist die Klasse die Lingua Franca. Für Clojure ist es unabdingbar, Klassen erzeugen zu können, wenn es sich in diesem Umfeld platzieren möchte. Hinter den Kulissen geschieht das oft für den Clojure-Programmierer unbemerkt. Gleichzeitig ist es aber auch möglich, Klassen gezielt zu erzeugen. Diese können danach sowohl von Clojure- als auch von Java-Programmen verwendet werden. Auf diese Weise lassen sich auch Klassen in Clojure erstellen, die ein Interface implementieren oder von einer anderen – möglicherweise abstrakten – Klasse ableiten.

Grundlagen

Ein erstes einfaches Beispiel zeigt das Vorgehen beim Erzeugen solcher in Clojure geschriebenen Klassen. Zudem behandelt es die bereits in Abschnitt 2.18.1 angesprochene Problematik der unterschiedlichen Auffassung von gültigen Identifiern von Clojure und Java: Der Namensraum enthält in Clojure ein Minuszeichen, das im Java-Umfeld durch einen Unterstrich ersetzt wird.

Zunächst werden zwei Verzeichnisse benötigt:

Davon, dass Clojures Compiler im Hintergrund aktiv war, zeugt das passende Verzeichnis-Listing im classes-Unterordner:

Clojure sowie Java

Wenn Clojure einerseits Klassen aus Java verwenden, andererseits aber auch Klassen für Java erzeugen kann, liegt es nahe, dass sich in Clojure Klassen schreiben lassen, die sowohl aus Clojure- als auch aus Java-Code verwendet werden können.

Beachtenswert ist hier der Rückgabewert. Diese Form der Init-Funktionen verlangt, dass ein Vektor als Resultat geliefert wird. Spezieller RückgabewertDas erste Element dieses Vektors gibt die Argumente an den Konstruktor der abzuleitenden Klasse an. Das zweite Argument liefert die interne Statusvariable. In diesem Falle verwenden wir ein Atom. Das ist hier eigentlich überflüssig, da diese Klasse keine Änderung am Status vorsieht. Diese Form demonstriert jedoch ein übliches Verfahren.

Der Java-Compiler kann diese Datei kompilieren:

Die so erzeugte Klasse wird – wie es von Java-Klassen bekannt ist – von der Kommandozeile aus aufgerufen. In diesem Falle wird „Clojure“ als Argument übergeben, das schlussendlich dem Konstruktor von GenCl übergeben wird und in der Ausgabe nach dem Drücken des Buttons wieder auftaucht.

Wie das Beispiel zeigt, benötigt dieses Programm auch die JAR-Datei von Clojure in seinem Classpath, um zu laufen. Da dieses einfache Programm kein Event an den Close-Button des Fensters gebunden hat, muss es mit „Strg-c“ beendet werden.

Dieses Beispiel hat gezeigt, dass sich in Clojure geschriebene Klassen nicht nur für den Einsatz in Clojure-Programmen eignen, sondern auch für Java-Programme zur Verfügung stehen.

4.3  Beispiel: Plot einer Bifurkation

Die logistische Abbildung ist eine einfache, iterierte Abbildung, die für manche Zahlenwerte zu recht stabilen Zuständen führt, aber bei anderen chaotisches, nicht vorhersagbares Verhalten an den Tag legt. Sie wurde bereits im 19. Jahrhundert aus der Betrachtung der Entwicklung von Populationen entwickelt. An dieser Abbildung lässt sich der Effekt der Bifurkation, also des Aufspaltens in zwei Werte, beobachten.

(4.1)

Gleichung (4.1) zeigt die iterierende Vorschrift. Einführendes Material zu den Hintergründen findet sich in einer Präsentation von Jakob Nawrath von der Uni Freiburg [49] und auf der deutschen Wikipedia [79].

Zu beachten ist hier auch die lokale Definition einer kleinen Hilfsfunktion, die letztlich einen Rechenschritt der Iteration implementiert. Diese Definition liegt in Form einer anonymen Funktion mit Read-Syntax vor, die lokal im let gespeichert wird. Alles andere in dieser Funktion dient zur Koordination der Iteration. Die Iteration ist am Ende, wenn die Anzahl der erfolgten Schritte die Summe aus zu überspringenden und zu erfassenden Schritten übersteigt. Dann wird der Akkumulator als Resultat präsentiert. Davor sind die Fälle zu unterscheiden, ob es sich noch um die Einschwingphase handelt oder um die Aufzeichnungsphase. Im ersten Falle wird der Akkumulator zwischen den Schritten nicht verändert, im zweiten Falle wird der aktuelle Wert dort hineingeschrieben.

Diese Berechnung verteilen wir durch die Verwendung von pmap anstelle von map einfach über die verfügbaren Prozessoren. Das Resultat der Iteration, die 5000 Werte verwirft und danach 100 aufzeichnet, wird noch in die korrekte Form für die zentrale Datenstruktur gebracht und dann mit Hilfe von swap! und into in das Atom geschrieben.

Ein kurzer Ausflug an die REPL zeigt den Algorithmus hierfür.

Aufbauend auf der Lösung für das Auffinden von Minima und Maxima in einem eindimensionalen Datensatz aus Abschnitt 2.17.2 hätte unter Verwendung von juxt eine alternative Implementation gefunden werden können. Das hier gewählte Verfahren demonstriert hingegen, wie komplexere Datenstrukturen als Akkumulator in Rekursionen verwendet werden.

Die vollstände Umrechnung der Ergebnismenge in Pixelkoordinaten berechnet zunächst auf diese Weise die Extremwerte, definiert sich kürzere Namen und skaliert diese Werte dann auf den durch die Abmessungen des Pixelraums gegebenen Bereich.

Diese Methode ist dafür entwickelt, im Callback paintComponent einer JComponent zum Einsatz zu koemmen. Diese Verwendung zeigt die Funktion swing-setup.

Es wird ein JPanel erzeugt, dessen paintComponent-Methode mit Hilfe von proxy implementiert wird. Die Verwendung von doto erlaubt im weiteren Verlauf den Aufruf diverser Methoden direkt bei der Erzeugung des Objekts. In ähnlicher Form wird ein JFrame erzeugt, der das Panel aufnimmt. Kernstück der Darstellung ist ein Timer-Objekt, das dieser Funktion übergeben wird. Wann immer dieser Timer feuert, wird der aktuelle Stand der Berechnung gezeichnet. Das wird durch das Registrieren eines ActionListener mit der Methode addActionListener erreicht. In guter Swing-Manier löst dieses Event lediglich einen Repaint aus, was dazu führt, dass die paintComponent-Methode aufgerufen wird.

Abschließend benötigt dieses Beispiel eine Funktion, die das Ganze koordiniert:

Ein Timer-Objekt, das viermal pro Sekunde feuert, wird erzeugt, und dem Swing-Thread wird der Code für die Oberfläche übergeben. Da diese Funktion sicherlich öfter aufgerufen wird, empfiehlt es sich, die gespeicherten Daten zuvor zu löschen und danach die Berechnung zu starten. Im Ganzen wartet diese Funktion dann fünf Sekunden, bis sie den Timer wieder stoppt, womit die kleine Applikation beendet ist. Abbildung 4.1 zeigt das Resultat des Aufrufs

Abbildung 4.1:

Bifurkationsdiagramm

4.4  Clojure als Skriptsprache

Die Verwendung existierender Java-Bibliotheken ist die vermutlich häufigste Form der Java-Clojure-Interaktion; Clojure liefert jedoch auch Werkzeuge mit, um eine bestehende – in Java geschriebene Anwendung – durch Clojure zu erweitern. Übliche Motivationen für den Einsatz dieser Variante sind in der Regel die höhere Entwicklungsgeschwindigkeit im Vergleich zum Erstellen vergleichbarer Funktionalität in Java selbst oder die Bereitstellung einer Schnittstelle für die dynamische Erweiterung des Java-Programms, eine Lösung, die auch häufig mit Groovy realisiert wird.

Im Folgenden zeigen wir grundlegend die Verwendung von in Clojure definierten Funktionen aus einem Java-Programm.

Mit Hilfe dieser Klasse kann von Java auf in Clojure definierte Funktionen zugegriffen werden. In einer Clojure-Datei test1.clj sei eine einfache Funktion definiert:

Diese Datei muss sich im Classpath befinden, um gefunden zu werden, wobei die Regeln für Namensräume und Dateinamen gelten, die in Abschnitt 2.7.2 beschrieben sind. Die so definierte Funktion kann nun aus Java verwendet werden. Dazu lädt das Java-Programm zunächst mit der statischen Methode load aus RT die Datei, ermittelt dann die passende Var anhand des Funktionsnamens und ruft auf dieser die Methode invoke auf.

Dieses Beispiel zeigt nur die wichtigen Abschnitte des Java-Codes. Die notwendigen Bestandteile eines vollwertigen Programms sind hier nicht abgebildet.

4.5  Clojure ist auch eine Bibliothek

Clojure wird als eine JAR-Datei ausgeliefert. In dieser findet sich eine Vielzahl von Klassen, manche mehr, manche weniger interessant. Vor allem die persistenten Datenstrukturen und die Sequence-Funktionalitäten können auch für eigentlich in Java geschriebene Programme interessant sein. Für diese Programme ist es leicht möglich, die JAR-Datei in ihre Sammlung von Bibliotheken aufzunehmen und die dortigen Klassen zu verwenden. Allerdings verlangen die meisten Klassen eine laufende Runtime von Clojure, die beim Starten einen erheblichen Aufwand bedeutet. Das dürfte für Karl Krukow der Anlass gewesen sein, eine Bibliothek zu entwickeln und zu pflegen, die Clojures Datenstrukturen enthält, aber nicht auf die komplette Runtime angewiesen ist [42].

4.5.1  Sequences

Das erste Beispiel in diesem Abschnitt zeigt die Verwendung der Sequence-Funktionen aus einem Java-Programm.

Die Zeilen 1–7 importieren die notwendigen Pakete aus dem Sprachumfang von Clojure. Die statische innere Klasse XmlFilter, deren Definition ab Zeile 18 erfolgt, enthält relativ viel gleichartige Wiederholungen zur Definition einiger Keywords. Zudem implementiert sie eine Filtermethode auf einer Java Map.

Ab Zeile 68 beginnt mit der Main-Methode der interessantere Teil. Mit der Methode load der Runtime RT wird die Contrib-Bibliothek clojure.contrib.lazy-xml geladen. Auf diese Weise stehen alle in Clojure implementierten Bibliotheken zur Verfügung. Aus diesem Paket extrahiert der Ausdruck in Zeile 74 eine Var – seqVar – die darauf im Java-Programm zur Verfügung steht. In Clojure werden Funktionen wie andere Typen auch durch Vars dargestellt, und die soeben importierte Var verweist auf die Funktion parse-seq. Diese Funktion ruft der Ausdruck ab Zeile 77 mit Hilfe von invoke auf. Dabei dient der RSS-Feed zum Thema Clojure auf Reddit als Quelle. Das Resultat ist eine ISeq. Ab Zeile 82 iteriert das Programm nun unter Verwendung der Interface-Funktionen von Clojure durch die Seq und wendet den XmlFilter auf jedes einzelne Element an.

Dieses Programm demonstriert exemplarisch die Verwendung der Runtime und der Sequences von Clojure. Nebenbei zeigt das Programm aber auch, wie kompakt in Clojure geschriebener Code ist. Dieser einfache XML-Parser benötigt beinahe 100 Zeilen Quelltext.

4.5.2  Persistente Datenstrukturen