Sei kein Held, sei eine Null! Über 10x Developer und andere Herausforderungen.

Im November 2018 habe ich bei den XP-Days in Hamburg meine erste (und bisher einzige) "eXtreme Presentation" (manchmal auch Pecha Kucha genannt) gehalten. Dabei werden in 6'40" genau 20 Folien jeweils genau 20 Sekunden lang gezeigt und dann automatisch weitergeschaltet. Beim Aufräumen meiner Festplatte habe ich meinen Text zu den Folien wiedergefunden. Und da es meines Wissens weder Fotos noch einen Video-Mitschnitt von der Präsentation gibt, halte ich die Kurzgeschichte einfach hier für die "Ewigkeit" fest :-)

[Update 04.03.2021] Bei der OOP 2021 durfte ich diesen Pecha Kucha noch einmal halten. Den Video-Mitschnitt davon gibt es hier.

[0:00, "Kleine Helden"]
Moin zusammen!
Wollen wir nicht alle kleine oder große Helden sein? Zumindest ein klein bisschen?
Die meisten von uns wollten als Kind vermutlich Superkräfte haben. Besser sein als die anderen. Herausstechen. Bewundert werden.
Aber es ist doch viel schöner, einen Freund zu haben, der auch Superkräfte hat. Dann bin ich nicht so allein.

[0:20, "Berggipfel"]
Später im Leben nehmen wir uns dann richtig große Ziele vor. Wir suchen Herausforderungen.
Wir wollen hoch hinaus, vielleicht ganz nach oben.
Und das ist auch gut so. Denn ohne das Streben nach Besserem hören wir irgendwann auf, gut zu sein.
Aber: Wir merken schnell, dass wir es nach oben nicht alleine schaffen.

[0:40, "Seilschaft"]
Es mag Einzelne geben, die riskieren alles und gewinnen alles alleine. Der Großteil der Einzelnen schafft das nicht. Die gehen unter. Die stürzen ab.
Zusammen sichern wir uns – Profis und Neulinge – nicht nur dort, wo es steil ist, sondern auch schon vorher, weil wir die unsicheren Stellen nicht sofort als solche erkennen.
Und dann gelangen wir zusammen nach oben. Und stehen über der Welt.

[1:00, "ISS"]
Am höchsten hinaus geht’s zum ultimativen Abenteuer unserer Zeit. In den Weltraum, zur ISS – hier noch mit Space Shuttle aus der Zeit des Aufbaus.
Wer mich kennt, weiß, dass Weltraumfahrt mein Hobby ist.
Ich bin leider kein Astronaut geworden, begeistere mich aber trotzdem auf viele Arten dafür...

[1:20, "LEGO-Apollo"]
Hier seht Ihr beispielsweise mein Weihnachtsgeschenk vom letzten Jahr.
Mein Sohn hat natürlich angeboten, mitzuhelfen. Ich durfte dann geduldig beobachten und bei den schwierigen Stellen ab und zu auch mitmachen.
Wenn wir nicht gerade LEGO bauen, lese ich gerne Bücher über die Raumfahrt. Auf ein Buch wurde ich im vergangenen Jahr durch einen Vortrag von Jens Schauder aufmerksam.

[1:40, "Chris Hadfield"]
Es geht um das Buch "An Astronaut’s Guide to Life on Earth" von Chris Hadfield, einem Kanadier.
Er flog mir dem Space Shuttle zur Mir, zur ISS, und war später 6 Monate auf der ISS.
Bekannt wurde er den meisten wohl durch seine Cover-Songs aus dem All, hier z.B. „Space Oddity“ von David Bowie.
(Zu finden auf YouTube; und ja, er hat auch diverse populärwissenschaftliche Berichte aus dem All gesendet ;-)

[2:00, "Aim to be a Zero"]
In dem Buch prägte er den Satz „Aim to be a Zero“.
Er teilt Astronauten in drei Kategorien ein:
Die "+1" sind ein echter Gewinn fürs Projekt und fürs Team. Das Problem dabei: Wer es darauf anlegt, eine +1 zu sein, steuert geradewegs auf eine -1 zu. Weil er als Angeber rüberkommt. Oder weil er seine Aufgabe grandios verbockt.

[2:20, "Space Shuttle Cockpit"]
Nun sind Astronauten alle Überflieger, die Besten der Besten, die wollen alle eine +1 sein. Trotzdem müssen gerade sie sich bemühen, einfach nur ihre Arbeit gut und unaufgeregt zu machen. Einfach eine gute Null zu sein.
Denn der Versuch, alles über-perfekt zu machen, führt in diesem Umfeld schnell in die Katastrophe...

[2:40, "John Glenn"]
Astronauten müssen lernen, sich zurückzunehmen, obwohl sie natürlich ALLES können.
Das ist schwierig und war auch nicht immer so. Die ersten Raumkapseln wurden alleine geflogen, erst danach tauchten Teams in den Raumschiffen auf.
Die Astronauten der ersten Generation waren Cowboys, Draufgänger.
Einzelkämpfer mit ausgeprägtem Ego.

[3:00, "10x Developer"]
Das kennen wir auch in der Softwareentwicklung.
Wir kennen alle einen Kollegen, der unglaublich schnell abliefert. Der alle schwierigen Aufgaben bekommt oder sich nimmt. Der Liebling des Chefs.
Er wirkt immer beschäftigt und ist gefühlt 10x schneller als der Rest.
Deshalb nennen wir ihn „10x Developer“. Es gibt dabei aber ein Problem.

[3:20, "gut gemeint"]
Wenn ich glaube, der Einzige zu sein, der solche Probleme lösen kann, dann werde ich das auch irgendwann sein. Dann werde ich zum Flaschenhals meines Teams und meiner Firma.
Und nach dem Abliefern der schnellen Lösung muss das Team 10x so lange aufräumen, bis die Lösung stabil betrieben und weiterentwickelt werden kann...

[3:40, "ISS-Schlaf"]
Außerdem entsteht durch solche 10x Developer eine Heldenkultur, in der Feuerwehreinsätze belohnt und nachhaltige Lösungen vermieden werden. Das führt irgendwann dazu, dass sich ein Teil der Kollegen in Bürokratie und Prozess versteckt, während der andere Teil sich selbst ausbeutet und dabei ausbrennt. Schlafmangel ist nur ein Symptom davon.
Astronauten bekommen übrigens genug Schlaf, darauf achtet die Bodenkontrolle.

[4:00, "10x besser"]
10x Developer kann man auch anders definieren, wie Kate Heddleston das in ihrem Blog tut:
Mach die Menschen um dich herum 10x besser!
Du bist nicht gut, wenn Du besser bist als die anderen, sondern wenn Du den anderen hilfst, genauso gut wie Du zu werden.
Das nützt dem Team, dem Projekt, der Firma langfristig.

[4:20, "Außenbordeinsatz"]
Wie passt das zu den Astronauten? Immerhin sehen wir immer solche heldenhaften Fotos...
Was man hier aber nicht sieht: Da draußen ist noch mindestens ein zweiter Astronaut, damit sie sich gegenseitig helfen können. Und drinnen noch ein Dritter als Unterstützung.
Die Astronauten MÜSSEN bei solchen Aufgaben eine unaufgeregte, gute Null sein.

[4:40, "Alexander Gerst (Buch)"]
Und das mit der Null ist keine Privatmeinung von Chris Hadfield. Alexander Gerst erwähnt das ebenfalls als mittlerweile normale Erwartungshaltung. Es geht dabei nicht um Mittelmäßigkeit, sondern um „gut genug“. Denn perfekt wird es sowieso nie. Und bei komplexen Aufgaben können Aktionismus und Heldentum katastrophale Folgen haben.
Warum ist das für uns in der Softwareentwicklung relevant? Viele unserer Probleme sind unglaublich komplex.

[5:00, "Cynefin"]
Das Cynefin-Framework (Kai-ne-vin) teilt unsere Probleme in vier Kategorien ein. In der einfachen oder offensichtlichen Kategorie und vielleicht auch noch in der komplizierten Kategorie können wir Probleme vielleicht noch als Einzelkämpfer lösen.
Die Probleme der komplexen Kategorie aber können wir erst im Nachhinein richtig verstehen. Das ist in den meisten Fällen viel zu komplex für einen Kopf allein. Diese Probleme sollten wir mit dem ganzen Team lösen.

[5:20, "Star Shape"]
Dafür müssen wir uns als Entwickler anders aufstellen. Vielleicht habt Ihr vom T-Shape gehört: Zusätzlich zu meinem technischen Spezialwissen schaue ich über den technischen Tellerrand. Aber auch das reicht nicht aus. Ich muss das Problem auch fachlich verstehen. Und ich muss soziales Können haben, um mich mit anderen auszutauschen.
Das nennen wir Star-Shape. Star-shaped developers, star-shaped testers, star-shaped product owners...

[5:40, "Mob Programming"]
Und vielleicht benötigen wir dafür auch andere Formen der Zusammenarbeit.
Aufgaben einzeln lösen und das Ergebnis reviewen, wird den immer komplexeren Problemen nicht mehr gerechnet. Vielleicht ist selbst Pair Programming nicht genug, wenn nämlich das gesamte Team den Lösungs-Prozess verstehen muss.
Mob Programming, bei dem das gesamte Team zusammen eine Aufgabe löst, hat sich hier als unglaublich hilfreich erwiesen.

[6:00, "Sharing Culture"]
Das alles wird letztlich auch die Kultur unserer Zusammenarbeit und die Kultur unseres Unternehmens verändern.
Wir brauchen keine geteilten Dokumente. Sondern geteiltes Verstehen durch gemeinsam Machen.
Weg von einer Kultur des Versteckens, Abkapselns – hin zu einer Kultur des Nehmens und Gebens von Wissen und Können.

[6:20, "Danke"]
Sei kein Held. Leg es nicht darauf an, hervorzustechen.
Versuch lieber, eine gute Null zu sein. Mit all Deinem Können. Hilf dem Team. Lass Dir helfen.
Werdet zusammen besser.
Dann löst Ihr gemeinsam und heldenhaft die immer komplexeren Probleme unserer Zeit.
Sei kein Held, sei eine Null. Aim to be a Zero.
Vielen Dank!

[6:40, Ende]


Von Benjamin Felis gibt es übrigens ein ganz tolles Graphic Recording aller vier Kurzpräsentationen.

Unendliche Streams in Java 8 und 9

[This text is available in English on DZone.]

Mit Lambdas und Streams können wir seit Java 8 endlich etwas funktionaler programmieren. Ein wichtiges Konzept in funktionalen Sprachen sind unendliche Streams, die durch geeignete Bedingungen passend "abgebrochen" werden (die Streams sind natürlich nicht wirklich unendlich, sondern sie werden "lazy" - also erst bei Bedarf - ausgewertet). So etwas gibt es auch in Java, und das möchte ich mit dem folgenden Beispiel zeigen.

Es geht um den Luhn-Algorithmus zur einfachen Berechnung einer Prüfsumme. Inspiriert dazu wurde ich durch den JVM Functional Language Battle von Falk Sippach. Zu sehen gab es in dem Vortrag verschiedene Implementierungen, von klassischem, imperativem Java bis hin zu Scala, Frege und Java mit Vavr (vormals Javaslang).

Eine kurze Zusammenfassung vom Luhn-Algorithmus:

• Gegeben sei eine nicht negative, ganze Zahl beliebiger Länge.
• Von rechts nach links wird jede 2. Ziffer der Zahl verdoppelt. Entsteht dabei eine zweistellige Zahl, wird die Quersumme gebildet.
• Alle so entstandenen Ziffern (einfach und verdoppelt) werden aufsummiert.
• Die Prüfsumme ist gültig, wenn die Gesamtsumme ohne Rest durch 10 teilbar ist.

Wie kann man das mit Java-8-Streams implementieren? Dazu noch ohne Variablen, Zustandsänderungen und Fallunterscheidung? Beispielsweise so:

import java.util.PrimitiveIterator;
import java.util.stream.IntStream;

public class Luhn {

  public static boolean isValid(String number) {

    PrimitiveIterator.OfInt faktor =
      IntStream.iterate(1, i -> 3 - i).iterator();

    int summe = new StringBuilder(number).reverse()
      .toString().chars()
      .map(c -> c - '0')
      .map(i -> i * faktor.nextInt())
      .reduce(0, (a, b) -> a + b / 10 + b % 10);

    return (summe % 10) == 0;
  }
}

Als Beispiel durchlaufen wir isValid() mit dem String "8763".

Mit IntStream.iterate() erzeugen wir uns einen endlosen (aber lazy berechneten) Stream der Zahlen 1,2,1,2,1,2, ... – das ist der Faktor, mit dem jede Ziffer multipliziert wird.

Dann packen wir den Zahlen-String in einen StringBuilder, weil der eine reverse()-Methode bietet. Damit können wir die einzelnen Ziffern als chars()-Stream vorwärts durchlaufen (und müssen nicht von hinten zählen):

'3', '6', '7', '8'

Jedes Ziffern-char wir nun mit dem ersten map() auf den Ziffern-Wert 0..9 abgebildet und mit dem zweiten map() mit dem nächsten Faktor aus dem endlosen IntStream multipliziert:

3, 12, 7, 16

Mit reduce() berechnen wir nun die Quersumme aller dieser Zahlen, wobei wir für jede Zahl die Zehnerstelle (div 10) und die Einerstelle (mod 10) addieren, also

(0 + 3) + (1 + 2) + (0 + 7) + (1 + 6)

Ergibt 20, und das ist ohne Rest durch 10 teilbar. Somit ist die Prüfsumme gültig.


Mit Java 9 können wir uns das Umwandeln in einen String (und das Umkehren der Zeichenfolge) sparen, indem wir aus der zu prüfenden Zahl einen weiteren unendlichen Stream machen, den wir mit takeWhile() und einem geeigneten Lambda-Prädikat kappen:

import java.util.PrimitiveIterator;
import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class Luhn9 {

  public static boolean isValid(long number) {

    PrimitiveIterator.OfInt faktor =
      IntStream.iterate(1, i -> 3 - i).iterator();

    long summe = LongStream.iterate(number, n -> n / 10)
      .takeWhile(n -> n > 0)
      .map(n -> n % 10)
      .map(i -> i * faktor.nextInt())
      .reduce(0, (a, b) -> a + b / 10 + b % 10);

    return (summe % 10) == 0;
  }
} 

Der chars()-Stream in der Java-8-Lösung war nach der Verarbeitung aller Zeichen zu Ende. LongStream.iterate() in dieser Java-9-Variante teilt die zu prüfende Zahl dagegen endlos immer weiter durch 10, also z.B.

8763, 876, 87, 8, 0, 0, 0, ...

Wir müssen den Stream also nur verarbeiten, solange die Zahl größer Null ist. takeWhile() macht genau das und liefert folgenden endlichen Stream:

8763, 876, 87, 8

Das erste map() liefert einen Stream der letzten Ziffern (mod 10):

3, 6, 7, 8

Der Rest (Multiplizieren mit dem Faktor und Quersummen-Addition) ist dann wieder wie bei der Java-8-Lösung.

Das ist vielleicht noch nicht perfekt funktional, weil wir keine Funktionskomposition beliebiger passender Funktionen durchführen können, sondern auf die vorhandene Stream-API angewiesen sind. Aber für Java-Bordmittel ist das doch gar nicht so schlecht.


Und wer noch nicht genug davon hat: Ein anderes schönes Beispiel für unendliche Java-Streams ist die Berechnung von Kaprekar-Zahlen, was kürzlich als Challenge auf dev.to lief. Neben takeWhile() kommt bei der Java-Lösung noch limit() zum Einsatz, um einen unendlichen Stream nicht mit einer Bedingung, sondern mit einer festen Anzahl zu begrenzen.

JSF-FacesContext in Unit-Tests mocken

Beim Schreiben von Unit-Tests für JSF-Beans kommt es leider ab und zu vor, dass der zu testende Code eine Fremdbibliothek verwendet, in der statisch auf

FacesContext.getCurrentInstance()

zugegriffen wird. Beim Ausführen des Tests kann dann eine NullPointerException im Code der Fremdbibliothek auftreten, die man nicht ohne Weiteres weg bekommt, denn der FacesContext hat zwar einen Getter, aber keinen Setter für das aktuelle Kontext-Objekt.

Hier kommt OmniFaces zu Hilfe – eine nützliche Hilfsbibliothek für JSF, die man vielleicht sowieso schon ins Projekt eingebunden hat. OmniFaces bietet die Methode Faces.setContext() an, mit der man den aktuellen JSF-Kontext setzen kann. Normalerweise benötigt man diese Methode nicht, aber in JSF-Unit-Tests kann sie Gold wert sein. Übergibt man z.B. ein Mockito-Mock-Objekt, ist man die NullPointerException schnell und einfach los:

import org.mockito.Mock;
import org.omnifaces.util.Faces;

public class FrontendBeanTest {

    @Mock
    private FacesContext facesContextMock;

    @Test
    public testFuerJsfBean {

        // Given
        Faces.setContext( facesContextMock );

        // When
        ...

        // Then
        ...
    }
}

Firefox 52 und Java-Applets

Mit Version 52.0 hat Firefox die Unterstützung für Plugins eingestellt, die auf die Uralte NPAPI setzen – das betrifft auch das Java-Plugin und somit Java-Applets.

Das war schon länger angekündigt und ist absolut nachvollziehbar, denn die NPAPI hat diverse Sicherheitsprobleme. Zudem sind Java-Applets eine sterbende Technologie, und mit Java 9 wird das Applet-Browser-Plugin auf den Status deprecated gesetzt werden.

Manchmal ist man aber doch noch darauf angewiesen, dass man ein Applet im Browser aufrufen kann. Und das geht auch mit Firefox 52 noch:

• Zum Einen kann man Firefox 52 ESR (Extended Support Release) verwenden. Darin wird der Plugin-Support bis Mai 2018 aktiviert bleiben.
• Zum Anderen – und das ist vermutlich die schnellere Lösung – kann man die Firefox-Konfiguration anpassen. Dazu ruft man in der Adresszeile about:config auf, macht einen Rechtsklick in die Liste der Optionen und wählt im erscheinenden Popup Neu/Boolean auf. Als Namen gibt man plugin.load_flash_only an, als Wert false. Nach einem Browser-Neustart können Java-Applets dann wieder genutzt werden.

Und immer dran denken: Die Nutzung sowohl dieser Informationen als auch von Plugins wie Flash und Java-Applets geschieht vollkommen auf eigene Gefahr.

Pair Programming & das Gehirn

Mitte Mai haben Stephan Kraus und ich auf der SEACON einen Vortrag über Pair-Programming-Coaching im Großprojekt gehalten. Wir haben dabei von unseren Erfahrungen mit der Neu- und Weiterentwicklung einer großen E-Commerce-Plattform berichtet.

Das Coaching bieten wir dort als Angebot an die zahlreichen Teams an, um Pair Programming einfach mal ein paar Wochen während der ganz normalen Arbeit kennenzulernen (bzw. zu intensivieren), um die Vorzüge von kontinuierlichem Wissenstransfer und gegenseitiger Qualitätsverbesserung zu erleben. Immer im Wissen, dass man auch bei schon bei ziemlich guter Qualität immer noch besser werden kann – weil wir als Menschen Fehler machen (aus denen wir als Team viel lernen können) und weil auch Technik nicht perfekt ist.

Spannend war, dass bei der Konferenz direkt nach uns der Vortrag von Julia Dellnitz und Jan Gentsch über Brain Patterns in der Softwareentwicklung stattfand – wo ganz nebenbei ;-) erklärt wurde, warum man mit Pair Programming die typischen Gehirn-Fallen, in die man sonst leicht bei der Kopfarbeit hineintappt, elegant austrickst:

• Unser Gehirn interpretiert unklare Dinge so, wie sie uns gerade passen. Natürliche Sprache (zwischen Fachbereich und Entwickler, aber auch zwischen den Entwicklern selbst!) ist oft nicht eindeutig... Pair Programming hilft hier, indem das, was man meint, zügig als Programmcode hingeschrieben und dann vom Pair verbessert bzw. vervollständigt wird. Programmierer können erfahrungsgemäß über und mit Code viel klarer diskutieren.
• Wir können alleine nicht gleichzeitig über das "Was" und das "Wie" nachdenken. Die zwei Rollen beim Pair Programming decken aber beides ab: Der Driver an der Tastatur kümmert sich um die Implementierung (das "Wie"), der Navigator als strategischer Denker ist für das "Was" zuständig. Und weil die Rollen in Mikroiterationen ständig wechseln, kann dann jeder doch beides zur Lösung beitragen.

Die Patterns erklären außerdem, warum es wichtig ist, Pair Programming als sehr intensive Form der Zusammenarbeit zu üben:

• Sozialer Schmerz durch offenes, ehrliches Feedback wird im Gehirn wie physischer Schmerz empfunden. Das Geben und Annehmen von konstruktivem Feedback muss daher Schritt für Schritt gelernt und verbessert werden, damit es von den Team-Mitgliedern nicht als persönlicher Angriff empfunden wird.
• Ich als der beste Programmierer der Welt muss lernen, dass ich vielleicht doch mal einen Fehler mache... und dass meine Kollegen manchmal auch echt gute Ideen haben.

Der Vortrag war eine schöne Bestätigung, dass wir mit der Förderung von Pair Programming als wichtiger XP-Praktik auf dem richtigen Weg sind. Die kurze, schriftliche Zusammenfassung inkl. Brain-O-Mat sollte jeder Kopfarbeiter mal gelesen haben!

Closures in Clojure

Eine Sprache, die nach Closures benannt ist (und genauso ausgesprochen wird), sollte ziemlich gut mit Closures umgehen können :-). Das Zähler-Beispiel für Java, Groovy, Scala etc. sieht in Clojure wie folgt aus:

; closures.clj

(defn zaehlerMitStartwert [startwert]
  (let [zaehler (atom startwert)]
    (fn [] (swap! zaehler inc))))

(def next1 (zaehlerMitStartwert 10))
(def next2 (zaehlerMitStartwert 20))

(println (next1))  ;; 11
(println (next2))  ;; 21
(println (next2))  ;; 22
(println (next1))  ;; 12

In der Funktion zaehlerMitStartwert wird im let-Block ein lokales Binding für zaehler angelegt. Der Wert von zaehler ist ein Atom mit dem übergebenen startwert. Ein Atom speichert in Clojure einen Zustand, der threadsicher ausgetauscht werden kann. Rückgabe von zaehlerMitStartwert ist eine Funktion ohne Parameter: (fn [] ...) - dies ist die Closure, die die freie Variable zaehler außerhalb der Closure-Funktion bindet (umschließt). Die Closure-Funktion verändert (swap!t) den zaehler-Wert mithilfe der inc-Funktion und gibt den neuen (reingeswap!ten) Wert zurück.

Dann definieren wir zwei globale Variablen next1 und next2, die mit je einer Closure-Instanz initialisiert werden. Diese Funktionen werden mit der Clojure- bzw. Lisp-typischen Syntax (next1) aufgerufen (statt next1() o.ä.).

Closures in Groovy

Beim JavaLand 2016 vor einer Woche hat Dierk König einen schönen Einstieg in die elegante und kompakte Ausdrucksweise von Groovy gegeben. Dabei hat er als Closure-Beispiel einen Zähler verwendet, den ich hier – weil er so gut zu meinen bisherigen Closure-Beispielen (u.a. für Java, JavaScript und Scala) passt – zeigen möchte (Fehler im Code gehen selbstverständlich auf mein Konto ;-):

// closures.groovy

Closure zaehlerMitStartwert(startwert) {
  return {
    startwert++
  }
}

def next1 = zaehlerMitStartwert(10)
def next2 = zaehlerMitStartwert(20)

println next1()  // 10
println next2()  // 20
println next2()  // 21
println next1()  // 11

Das return in der Funktion zaehlerMitStartwert gibt die Closure – den darauffolgenden Block mit geschweiften Klammern und der Zähl-Anweisung – zurück. Im Block selbst ist kein return notwendig, weil hier für den Compiler klar ist, dass die letzte (und hier einzige) Anweisung im Block das Ergebnis der Block-Funktion ist. Man sieht sehr schön, dass Groovy-Closures problemlos freie Variablen außerhalb des Closure-Blocks binden - so, wie das auch bei Scala der Fall ist (aber anders als bei Java, wo normalerweise nur final-Werte und nur mit Tricks Variablen gebunden werden können).

Wer das Groovy-Skript ausprobieren möchte, kann es einfach in die Groovy-Web-Console kopieren und dort ausführen.

Closures in Java

Java 8 ist nun bald zwei Jahre alt – eine gute Gelegenheit, meine kleine Closures-Reihe weiterzuführen. Nach Scala, JavaFX und JavaScript sind heute also Closures in Java an der Reihe. Das Zähler-Beispiel sieht mit den Lambda-Ausdrücken aus Java 8 so aus:

import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.IntSupplier;

public class ClosuresJava8 {

  static IntSupplier zaehlerMitStartwert(int startwert) {

    AtomicInteger n = new AtomicInteger(startwert);

    IntSupplier s = () -> {
      return n.incrementAndGet();
    };

    return s;
  }

  public static void main(String[] args) {

    IntSupplier next1 = zaehlerMitStartwert(10);
    IntSupplier next2 = zaehlerMitStartwert(20);

    System.out.println( next1.getAsInt() ); // 11
    System.out.println( next2.getAsInt() ); // 21
    System.out.println( next2.getAsInt() ); // 22
    System.out.println( next1.getAsInt() ); // 12
  }
}

Die Methode zaehlerMitStartwert() gibt eine IntSupplier-Lambda-Funktion zurück. IntSupplier ist ein sogenanntes "funktionales Interface", d.h. ein Interface mit genau einer Methode (in diesem Fall getAsInt()). Ein "Supplier" bezeichnet dabei eine Methode ohne Parameter, die einen Rückgabewert liefert.

Der Lambda-Ausdruck ist dabei so etwas wie eine Kurzschreibweise für ein anonymes Objekt des IntSupplier-Interfaces, wobei das new, der Interface-Name und der Methodenname weggelassen werden. Die Anweisung im Lambda-Ausdruck ("return n.incrementAndGet();") wird dabei zum Rumpf der unsichtbaren getAsInt()-Methode.

Im Lambda-Ausdruck wird der übergebene Startwert erhöht und zurückgegeben. Allerdings müssen die gebundenen Variablen außerhalb des Lambda-Ausdrucks in Java final oder "effectively final" sein (d.h. sie dürfen nicht verändert werden, damit der Compiler final annehmen kann). Deshalb lassen wir den Lambda-Ausdruck ein AtomicInteger-Objekt binden – der Inhalt des AtomicInteger-Objektes ist veränderbar, die Referenz darauf ist aber wie gewünscht final.

Im obigen Beispiel wird die Lambda-Funktion nur zum einfacheren Verständnis in der lokalen Variablen s zwischengespeichert. Man kann den Lambda-Ausdruck auch direkt als Methodenergebnis zurückgeben:

  static IntSupplier zaehlerMitStartwert(int startwert) {

    AtomicInteger n = new AtomicInteger(startwert);

    return () -> {
      return n.incrementAndGet();
    };
  }

Und da unser Lambda-Ausdruck nur aus einer einzigen Anweisung besteht, deren Ergebnis als Funktionsergebnis zurückgegeben wird, kann man das noch weiter kürzen und die geschweiften Klammern und das return im Lambda-Rumpf weglassen:

  static IntSupplier zaehlerMitStartwert(int startwert) {

    AtomicInteger n = new AtomicInteger(startwert);

    return () -> n.incrementAndGet();
  }

Das sieht doch schon fast richtig funktional aus :-)

Bean-Mapping mit MapStruct

Am vergangenen Wochenende habe ich auf dem MATHEMA Campus einen Vortrag über MapStruct gehalten. MapStruct ist ein Annotations-basierter Code-Generator für Mappings zwischen beliebigen Java-Beans und kann damit hervorragend zum Umkopieren der Daten zwischen den diversen Domänen-Modellen einer Anwendung (JPA, JAXB, REST, sonstige DTOs/POJOs ... ) genutzt werden.

Der generierte Mapping-Code nutzt keine Reflection, sondern Getter- und Setter-Aufrufe – und erreicht damit die Geschwindigkeit von handgeschriebenem Mapping-Code. Ganz nebenbei ist der generierte Code lesbar und verständlich. Das ist wichtig, falls der Projektverantwortliche Angst hat, ein weiteres Werkzeug ins Projekt einzubinden – zur Not stellt man den generierten Code unter Versionskontrolle und pflegt ihn später von Hand weiter (wer einmal MapStruct verwendet hat, wird das aber nicht wollen ;-).

MapStruct wird als Annotations-Prozessor eingebunden, d.h. der Mapping-Code wird beim Aufruf von javac (bzw. bei jedem Speichern z.B. in Eclipse) generiert. Das Prozessor-JAR wird dabei nur zur Compile-Zeit benötigt. Zur Laufzeit ist bei einem Komponentenmodell wie CDI gar kein JAR als Abhängigkeit nötig, ohne Komponentenmodell nur ein winziges JAR < 20 K.

Folgender Code reicht, um den Mapping-Code zwischen einer Kunde-Entity und einem Kunde-DTO generieren zu lassen:

@Mapper(componentModel = "cdi")
public interface KundeMapper {

  @Mapping(target = "geburtsdatum", format = "dd.MM.yyyy")
  KundeDTO jpaEntity2RestDto(Kunde kunde);
}

MapStruct erzeugt daraus in etwa folgenden Code:

@Generated("org.mapstruct.ap.MappingProcessor")
@ApplicationScoped
public class KundeMapperImpl implements KundeMapper {

  public KundeDTO jpaEntity2RestDto(Kunde kunde) {
    // null-Checks
    // Ziel-Objekt-Erzeugung
    // Getter-/Setter-Aufrufe
    // ...
  }
}

Der standardmäßig generierte Code ist oft schon genau das, was man benötigt. Ansonsten ist so ziemlich alles konfigurierbar: Unterschiedliche Property-Namen in Quell- und Ziel-Bean, unterschiedliche Typen, die Objekt-Fabriken zur Ziel-Objekt-Erzeugung... Zudem können vorhandene, handgeschriebene Mapper eingebunden werden. Und Objekt-Graphen werden selbstverständlich genauso gemappt wie Collections, Maps, Arrays... Für JAXB, Joda-Time und Java 8 Date&Time stehen automatische Mappings zur Verfügung.

Man merkt, dass dieser Mapper mit vielen Praxis-Problemen im Hinterkopf entwickelt wurde. Und man fragt sich relativ schnell, warum man nur so lange das Bean-Mapping von Hand oder mit Reflection-Bibliotheken durchgeführt hat ;-)

Mindestvoraussetzung für MapStruct ist Java 6 – aber da heute der letzte Tag der kostenfreien Java-7-Updates (und ab morgen nur noch Java 8 "aktuell") ist, sollte das kein Problem darstellen.

Die Folien zu meinem Vortrag finden sich hier.

Scope-Events in CDI 1.1

Wer in einer Java-Webanwendung mitbekommen möchte, wann die Anwendung fertig bereitgestellt ist (z.B. um den Deployment-Timestamp zu ermitteln und anzuzeigen), hat dazu diverse Möglichkeiten. Eine lang verfügbare Lösung ist ein ServletContextListener, seit Java EE 6 kann man auch eine @Singleton-@Startup-EJB verwenden. Mit CDI 1.1 in Java EE 7 haben wir nun eine weitere Variante, ein @Initialized-Event für den Application-Scope (d.h. für den ServletContext):

import javax.inject.Named;
import javax.enterprise.event.Observes;
import javax.enterprise.context.*;

@Named
@ApplicationScoped
public class DeploymentInfoBean {

  private Date deploymentTimestamp;

  public Date getDeploymentTimestamp() {
    return deploymentTimestamp;
  }

  void deploymentFinished(
    @Observes
    @Initialized(ApplicationScoped.class)
    ServletContext context) {

    deploymentTimestamp = new Date();
  }
}

Wer nur am Zeitpunkt interessiert ist und keine Werte aus dem ServletContext benötigt, kann sich als Parameter auch einfach ein Object übergeben lassen und beseitigt damit die Abhängigkeit zu javax.servlet.

Man kann sich nicht nur über die fertige Initialisierung eines Scopes informieren lassen, sondern auch über die Beendigung eines Scopes – und so beispielsweise Anfang und Ende von HTTP-Sessions überwachen:

public class SessionWatcher {

  void sessionCreated(
    @Observes
    @Initialized(SessionScoped.class)
    HttpSession session) {
      ...
  }

  void sessionDestroyed(
    @Observes
    @Destroyed(SessionScoped.class)
    HttpSession session) {
      ...
  }
}

Java in OS X 10.10 "Yosemite"

Wie auch schon die Vorgängerversion wird OS X 10.10 ohne vorinstalliertes Java 6 ausgeliefert. Bei einem Update wird eine vorhandene Java-6-Installation aus /System/Library/Java/JavaVirtualMachines gelöscht. Das alles ist eigentlich kein Problem, denn Java 6 ist eh veraltet, seit Oracle vor zwei Jahren den kostenlosen Support für Version 6 eingestellt hat – und in /Library/Java/JavaVirtualMachines installierte Versionen von Java 7 und Java 8 bleiben bei einem Update auf OS X 10.10 erhalten.

Manche Programme benötigen aber noch Java 6 zum Starten. Yosemite weist mit einem Dialog darauf hin:

Mit der Schaltfläche "Weitere Infos" gelangt man zur Download-Seite von Java für OS X 2014-001, mit dem in Mac OS X 10.7 bis OS X 10.10 Java 1.6.0_65 installiert werden kann. Dies ist dieselbe Java-Version, die Apple auch schon mit "Java für OS X 2013-005" ausgeliefert hat – nur ein geringfügig aktuellerer Build.

NoSQL mit JPA und Hibernate OGM

Nach einer längeren Beta-Phase wurde heute die erste finale Version von Hibernate OGM veröffentlicht! Im Gegensatz zu Hibernate ORM, mit dem Entity-Modelle auf relationale Datenbanken abgebildet werden, kümmert sich Hibernate OGM um das Mapping von JPA-Entities auf NoSQL-Datenbanken.

Hibernate OGM erhebt dabei gar nicht erst den Anspruch, zu jedem Anwendungsfall von NoSQL-Datenbanken zu passen. Dazu gibt es zu viele unterschiedliche Ideen und Konzepte, wie nicht-relationale Daten gespeichert werden können (unstrukturiert, als Graph, als Dokument etc.). In der Praxis wird in den schemafreien NoSQL-Datenbanken aber dennoch oft mit strukturierten Daten gearbeitet, die häufig von Hand auf ein Objektmodell abgebildet werden. Der wichtige Unterschied zu den relationalen SQL-Datenbanken besteht in den flexiblen, nicht starren Schemata, d.h. Schema-Evolution (Migration) ist im laufenden Betrieb möglich und üblich.

Und genau hier glänzt Hibernate OGM: Liegt der Anwendungsfall vor, ein flexibles Entity-Modell in einer NoSQL-Datenbank zu persistieren, kann man mit den bekannten JPA-Annotationen und -Konzepten programmieren. Der Einstieg ist also denkbar einfach, wobei bei Bedarf auch produktspezifische Optimierungen möglich sind, z.B. mit nativen Abfragen (JavaScript-Abfrage-Dokumente für MongoDB, Cypher-Abfragen für Neo4j etc.).

OGM versucht, für jedes NoSQL-Produkt ein möglichst "natürliches" Mapping zu nutzen, u.a. damit andere Clients eine für das jeweilige Produkt gewohnte Datenbankstruktur vorfinden. Weil aber die API immer dieselbe ist (JPA), muss man sich nicht am Anfang auf ein NoSQL-Produkt festlegen, sondern kann das Mapping – und die Performance! – in diversen NoSQL-Stores ausprobieren und vergleichen.

In diesem Jahr habe ich Hibernate OGM auf einigen Konferenzen vorgestellt – die Folien der Vorträge kann man hier anschauen bzw. runterladen. Die Folien behandeln zwar noch die Beta-Versionen, gelten aber weitestgehend auch für die erste finale Version (die übrigens nicht die Nummer 1.0, sondern 4.1 trägt).

Ansonsten: Einfach mal ausprobieren! Wer grundlegende JPA-Kenntnisse hat, wird sich schnell mit MongoDB, Neo4J & Co. zurecht finden :-)

Schema-Export mit JPA 2.1

Eine der Neuerungen in Java Persistence 2.1 ist die standardisierte Möglichkeit, aus den Mapping-Informationen des Datenmodells das Datenbank-Schema generieren zu können. Seit gestern Abend steht mit Hibernate 4.3 eine weitere Implementierung des aktuellen JPA-Standards zur Verfügung, mit der folgender Code zur Schema-Generierung ausgeführt werden kann:

import javax.persistence.Persistence;

...

try (FileWriter out
      = new FileWriter("schema-komplett.sql")) {

   Map<String, Object> props = new HashMap<>();

   props.put(
      "javax.persistence.schema-generation.scripts.action",
      "create");

   props.put(
      "javax.persistence.schema-generation.scripts.create-target",
      out);

   Persistence.generateSchema(
      "name-der-persistence-unit", props);
}

Leider scheint im Standard keine Möglichkeit vorgesehen zu sein, eine Differenz zum aktuell in der Datenbank vorhandenen Schema zu ermitteln.

JPA-Schema-Export mit Hibernate

Die Hibernate-Tools bieten mit den Klassen SchemaExport und SchemaUpdate die Möglichkeit, das Datenbank-Schema (Tabellen, Indizes, Fremdschlüssel-Constraints etc.) aus den Mapping-Informationen des Datenmodells zu generieren. Da es sich um Hibernate-spezifische API handelt, wird von den Klassen eine Hibernate-Configuration erwartet. Mit Hilfe der kleinen, von Hibernate nicht offiziell unterstützten (und mittlerweile auf "deprecated" gesetzten) Klasse Ejb3Configuration kann aber auch eine Java-Persistence-Konfigurationsdatei persistence.xml eingelesen werden:

import org.hibernate.cfg.Configuration;
import org.hibernate.ejb.Ejb3Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.hibernate.tool.hbm2ddl.SchemaUpdate;

...

Configuration cfg =
   new Ejb3Configuration()
        .configure("name-der-persistence-unit", null)
        .getHibernateConfiguration();

Mit der ermittelten Configuration kann nun das komplette Schema ...

SchemaExport schemaExport = new SchemaExport(cfg);

schemaExport.setOutputFile("schema-komplett.sql");

schemaExport.create(true, false);

... oder aber nur die Differenz zum aktuell in der Datenbank vorhandenen Schema ermittelt werden:

SchemaUpdate schemaUpdate = new SchemaUpdate(cfg);

schemaUpdate.setOutputFile("schema-diff.sql");

schemaUpdate.execute(true, false);

Das true beim jeweils letzten Aufruf sorgt dafür, dass das SQL-Skript in die angegebene Datei geschrieben wird. Das false verhindert, dass die SQL-Anweisungen in der Datenbank ausgeführt werden.

Im kommenden Hibernate 4.3, das die JPA-2.1-Spezifikation implementiert, wird Ejb3Configuration nicht mehr enthalten sein. Dann muss bzw. kann endlich die mit JPA 2.1 standardisierte Schema-Generierung verwendet werden.

Java in OS X 10.9 "Mavericks"

Das Upgrade von OS X 10.8 nach 10.9 lief komplett problemlos, so soll es sein. Allerdings war anschließend Java 6 (Apples Implementation) nicht mehr vorhanden – wer diese Version benötigt, muss Java for OS X 2013-005 manuell herunterladen und installieren. Man hat dann Java 1.6.0_65 auf der Platte (im Gegensatz zu Oracle veröffentlicht Apple noch kostenfreie Updates für Java SE 6).

Ein bereits installiertes JDK 7 von Oracle bleibt normalerweise erhalten. Wer zu den Nutzern gehört, bei denen auch diese Java-Installation nach dem Upgrade nicht mehr aktiv ist, installiert einfach das aktuelle JDK 7u45. Java-7-Versionen bis einschließlich 7u25 wurden/werden von Apple aus Sicherheitsgründen deaktiviert.

Java-Batch-Anwendungen

Mal ein bisschen Werbung in eigener Sache. Im Frühjahr wurde der neue Standard "Batch Applications for the Java Platform" (JSR-352) – oder kurz "Java Batch" – in der Version 1.0 freigegeben. Der Standard bietet einen Rahmen, um Massendaten transaktional, blockweise und im Fehlerfall mit Wiederaufsetzpunkten zu verarbeiten. Und das unabhängig davon, ob die Batch-Verarbeitung in Java SE oder in Java EE stattfinden soll.

Dieser Bereich der Datenverarbeitung war lange Zeit ganz klar vom Großrechner (Host) dominiert, aber im Rahmen der allgemeinen Migrationsbestrebungen weg von COBOL (ja, das ist immer noch ein wichtiges Thema) entstehen Batch-Anwendungen mehr und mehr im Java-Umfeld.

Nachdem ich bereits auf dem Herbstcampus in Nürnberg zu diesem Thema gesprochen habe, halte ich nun einen weiteren Vortrag im Rahmen der Reihe "GFU Semicolon" in Köln. Nach einem Überblick über die Batch-Architektur schauen wir uns die Grundlagen der Batch-Programmierung in Java SE mit der Referenzimplementation JBatch an. Die Integration in Java EE 7 zeige ich am Beispiel von GlassFish 4.

Der Vortrag findet statt am Dienstag, 22.10.2013, von 18:00 bis 19:00 Uhr. Im Anschluss gibt es bei einem kleinen Imbiss Gelegenheit zur Diskussion. Die Teilnahme ist kostenlos, eine Anmeldung ist aber erforderlich.

[Update 24.10.]
Die Folien sind nun verfügbar – und ein Foto vom Vortrag:

REST-Web-Services mit JAX-RS portabel aktivieren

... und dennoch implementationsspezifisch konfigurieren? Eins nach dem anderen. Seit Java EE 6 kann man JAX-RS in einem Application-Server portabel dadurch aktivieren, dass man eine Klasse von javax.ws.rs.core.Application ableitet und mit @ApplicationPath annotiert:

package com.muchsoft.rest;

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;

@ApplicationPath("/rest")
public class ApplicationWithRESTWebServices
                          extends Application {
}

D.h. dass man nun REST-Web-Services anbieten kann, ohne sich um die konkrete Implementierung – beispielsweise Jersey als Referenz-Implementation – kümmern zu müssen. Gut.

Was aber, wenn man doch gewisse produktspezifische Features nutzen möchte, wie beispielsweise ausführliches Trace-Logging bei Jersey? Dann greift man auf den Deployment-Deskriptor web.xml zurück und mappt dort ein Servlet mit den entsprechenden Init-Parametern. Allerdings muss das nicht eine Jersey-Klasse (mit entsprechendem servlet-mapping) sein, sondern es reicht, die eigene Application-Unterklasse als Servlet einzutragen (ohne servlet-mapping-Element):

<servlet>
  <servlet-name>
    com.muchsoft.rest.ApplicationWithRESTWebServices
  </servlet-name>
  <init-param>
    <param-name>
      com.sun.jersey.api.json.POJOMappingFeature
    </param-name>
    <param-value>true</param-value>
  </init-param>
  <init-param>
    <param-name>
      com.sun.jersey.config.feature.Trace
    </param-name>
    <param-value>true</param-value>
  </init-param>
</servlet>

REST-Web-Services mit BASIC-Auth und HTTPS in GlassFish

Nehmen wir mal einen einfachen REST-Web-Service wie den folgenden, der alle Bestellungen des Benutzers liefern soll:

@Path("/bestellungen")
public class BestellungWebService {

  @Context
  private SecurityContext securityContext;

  @Produces({ MediaType.APPLICATION_JSON,
              MediaType.APPLICATION_XML })
  @GET
  public Response getAlleBestellungen() {

    final String username =
      securityContext.getUserPrincipal().getName();

    try {
      List<Bestellung> bestellungen = ...;

      return Response.ok( bestellungen ).build();
    }
    catch (Exception e) {
      return Response.serverError()
                     .entity( e.getMessage() ).build();
    }
  }
}

Mit beispielsweise Wget könnte dieser Service dann wie folgt aufgerufen werden, wenn der Applikationspfad auf "rest" gemappt ist:

wget http://localhost:8080/meinewebapp/rest/bestellungen

Fast immer muss ein solcher Service abgesichert werden, damit nur bestimmte Anwender Zugriff darauf haben. Man könnte natürlich den UserPrincipal programmatisch auswerten, aber sofern die berechtigten Benutzer im Application-Server als User eingetragen sind, ist eine deklarative Absicherung einfacher - und erfordert keine Änderungen am Quelltext.

Am Beispiel von GlassFish 3.1.2 schauen wir uns das an. Wir erlauben dem GlassFish-Admin-User, den Web-Service aufzurufen. Dazu sichern wir am Ende des Deployment-Deskriptors web.xml alle Ressourcen unterhalb /rest so ab, dass nur die "admin"-Rolle darauf zugreifen darf. Mit CONFIDENTIAL erzwingen wir zudem, dass die Übertragung der Daten per https (SSL bzw. TLS) stattfindet:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">

  ...

  <security-constraint>
    <web-resource-collection>
      <url-pattern>/rest/*</url-pattern>
    </web-resource-collection>
    <auth-constraint>
      <role-name>admin</role-name>
    </auth-constraint>
    <user-data-constraint>
      <transport-guarantee>CONFIDENTIAL</transport-guarantee>
    </user-data-constraint>
  </security-constraint>

  <login-config>
    <auth-method>BASIC</auth-method>
    <realm-name>admin-realm</realm-name>
  </login-config>

  <security-role>
    <role-name>admin</role-name>
  </security-role>

</web-app>

Die BASIC-Authentication, bei der Benutzername und Passwort im Klartext (!) übertragen werden, ist hier dennoch in Ordnung, weil wir gleichzeitig mit https die verschlüsselte Datenübertragung aktivieren.

Die berechtigten Anwender müssen im "admin-realm" eingetragen sein, das ist der Realm mit allen GlassFish-Admins (der in der Standardinstallation den User "admin" enthält). Als Beispiel für einen Security-Realm ist das hier ausreichend; in der Praxis wird man aus Sicherheitsgründen eher einen separaten Realm im GlassFish konfigurieren und in web.xml referenzieren.

Nun müssen wir dem Application-Server noch – produktspezifisch – mitteilen, welche Benutzernamen aus dem Realm auf welche Rollen gemappt werden. Dies erfolgt in der Datei glassfish-web.xml (früher sun-web.xml):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE glassfish-web-app PUBLIC
  "-//GlassFish.org//DTD GlassFish Application Server 3.1 Servlet 3.0//EN"
  "http://glassfish.org/dtds/glassfish-web-app_3_0-1.dtd">
<glassfish-web-app>

  <context-root>meinewebapp</context-root>
     
  <security-role-mapping>
    <role-name>admin</role-name>
    <principal-name>admin</principal-name>
  </security-role-mapping>

</glassfish-web-app>

Fertig. Der Aufruf des Web-Services erfolgt über Wget nun mit

wget https://localhost:8081/meinewebapp/rest/bestellungen
       --user ... --password ... --no-check-certificate

Ein Aufruf über unverschlüsseltes http ist nicht mehr möglich. Während wir hier der Einfachheit halber auf die Prüfung des https-Zertifikats verzichten, sollte man in der Praxis besser ein geeignetes eigenes Zertifikat im Server installieren und auf Client-Seite verwenden.

JAXB und HashMaps, Teil 2

In Teil 1 zu JAXB und HashMaps ging es vor einiger Zeit darum, mit möglichst wenig Aufwand im Java-Code eine XML-Struktur zu verarbeiten, deren Element-Namen teilweise fest vorgegeben waren. Teil 2 zeigt nun, wie man eine XML-Struktur mit beliebigen Element-Namen aus einer (Hash)Map innerhalb einer JAXB-Entität ausgibt (bzw. dorthin einliest). Konkret soll folgendes XML-Dokument erzeugt werden:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<meineEntitaet>
  <paarliste>
    <paar>
      <schluessel>Antwort</schluessel>
      <wert>42</wert>
    </paar>
  </paarliste>
</meineEntitaet>

Dazu benötigen wir als Erstes für einen einzelnen Eintrag der Map (also für jedes Schlüssel-Wert-Paar) folgende Klasse:

import javax.xml.bind.annotation.XmlElement;

class MapElement {

  @XmlElement(name = "schluessel")
  String key;

  @XmlElement(name = "wert")
  Integer value;

  MapElement() {
  }

  MapElement(String key, Integer value) {
    this.key = key;
    this.value = value;
  }
}

Die Liste der Map-Einträge wird in einer eigenen Klasse verpackt, damit wir den Namen des XML-Elements festlegen können, das die einzelnen Schlüssel-Wert-Paare umschließt:

class MapElements {

  @XmlElement(name = "paar")
  List<MapElement> mapElements;

  MapElements() {
  }

  MapElements(List<MapElement> mapElements) {
    this.mapElements = mapElements;
  }
}

In der JAXB-Entität taucht nun aber nicht diese MapElements-Klasse auf, sondern die ursprünglich gewünschte (Hash)Map:

import java.util.*;
import javax.xml.bind.annotation.*;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class MeineEntitaet {

  @XmlElement(name = "paarliste")
  @XmlJavaTypeAdapter(MapAdapter.class)
  private Map<String, Integer> map = new HashMap<>();
  public Map<String, Integer> getMap() {
    return map;
  }

  public void setMap(Map<String, Integer> map) {
    this.map = map;
  }
}

Für die Umwandlung zwischen der MapElements-Klasse und der HashMap benötigen wir einen XmlAdapter:

import java.util.*;
import javax.xml.bind.annotation.adapters.XmlAdapter;

public class MapAdapter extends XmlAdapter<MapElements, Map<String, Integer>> {

  @Override
  public MapElements marshal(Map<String, Integer> map) {
    List<MapElement> list = new ArrayList<>();
    for (Map.Entry<String, Integer> entry : map.entrySet()) {
      list.add(new MapElement(entry.getKey(), entry.getValue()));
    }
    return new MapElements(list);
  }

  @Override
  public Map<String, Integer> unmarshal(MapElements elements) {
    Map<String, Integer> map = new HashMap<>();
    for (MapElement mapElement : elements.mapElements) {
      map.put(mapElement.key, mapElement.value);
    }
    return map;
  }
}

Damit können wir schließlich das XML-Dokument erzeugen:

MeineEntitaet huelle = new MeineEntitaet();
huelle.getMap().put("Antwort", 42);
JAXB.marshal(huelle, System.out);

Warum ist StandardCharsets final?

In vielen Anwendungen und Bibliotheken findet man eine Klasse, die Konstanten für häufig benutzte Zeichensätze enthält:

import java.nio.charset.Charset;

public class ApplicationCharsets {

  public static final Charset UTF_8

    = Charset.forName( "UTF-8" );

  public static final Charset ISO_8859_1

    = Charset.forName( "ISO-8859-1" );

  public static final Charset WINDOWS_1252

    = Charset.forName( "WINDOWS-1252" );

} 

Seit Java 7 gibt es die Klasse java.nio.charset.StandardCharsets, die Konstanten für die Zeichensätze enthält, die garantiert in jeder Java-Implementierung zur Verfügung stehen – US-ASCII, ISO-8859-1 (ISO Latin 1) sowie diverse Unicode-Kodierungen.

Damit man im Anwendungs-Code nicht verschiedene Klassen für die Standard- und die Anwendungs-Zeichensatzkodierungen referenzieren muss, könnte man die Anwendungs-Konstanten wie folgt formulieren ...

import java.nio.charset.*;

public class ApplicationCharsets

    extends StandardCharsets /* geht nicht :-( */ {

  public static final Charset WINDOWS_1252

    = Charset.forName( "WINDOWS-1252" );

} 

... wenn die Klasse StandardCharsets nicht final wäre. So bleibt derzeit leider nur folgender Ausweg:

public class ApplicationCharsets {

  public static final Charset UTF_8

    = StandardCharsets.UTF_8;

  public static final Charset ISO_8859_1

    = StandardCharsets.ISO_8859_1;

  public static final Charset WINDOWS_1252

    = Charset.forName( "WINDOWS-1252" );

} 

Warum also darf von StandardCharsets keine Unterklasse abgeleitet werden? Einfach nur aus historischen Gründen, weil ähnliche Klassen bisher auch final waren? Kann man das in Java 8 ändern?