Kapitel 21 Reflection und Annotationen

Aber für was ist das gut?
– Advanced Computing Systems Division von IBM, 1968, zum Microchip

Das Reflection-Modell erlaubt es uns, Klassen und Objekte, die zur Laufzeit von der JVM im Speicher gehalten werden, zu untersuchen und in begrenztem Umfang zu modifizieren. Das Konzept der Reflection (oder auch Introspektion) wird dann besonders interessant, wenn wir uns näher mit Java-Beans beschäftigen oder wir Hilfsprogramme zum Debuggen oder GUI-Builder schreiben. Diese Programme nennen sich auch Meta-Programme, da sie auf den Klassen und Objekten anderer Programme operieren. Reflection fällt daher auch in die Schlagwortkategorie Meta-Programming.

21.1 MetaData 

Eine Metadata ist eine Information über eine Information. In Java beschreibt ein Class-Objekt, was konkrete Exemplare der Klassen – die Objekte – können, also für Methoden haben und für Attribute besitzen. Dazu gibt es schon lange die JavaDoc-Tags, die ebenfalls Metadaten sind. So ist in folgendem Beispiel die Methode veraltet, da das Tag @deprecated gesetzt ist.

/**
 * Sets the day of the month of this <tt>Date</tt> object to the specified 
value. ....
 *
 * @param   date   the day of the month value between 1–31.
 * @deprecated As of JDK version 1.1, replaced by ....
 */
public void setDate(int date) {
  setField(Calendar.DATE, date);
}

In diesem Fall gilt das JavaDoc-Tag für genau eine Methode. Diese Methode gilt damit als annotiert. Die Beschreibungen können aber noch weiter gehen und müssen nicht nur auf Methodenebene bleiben. So annotiert das Tag @author den Autor und damit gleich eine ganze Klasse oder Schnittstelle.

21.1.1 XDoclet 

Für die über das JavaDoc eingebrachten Tags muss sich der Java-Compiler nicht kümmern. Es ist Aufgabe des externen Programms JavaDoc, aus diesem Kommentaren etwas zu machen, etwa eine HTML-Dokumentation. Doch die Tags haben sich in den letzten Jahren als sehr flexibel herausgestellt, da es zwar für bestimmte Tags Bedeutungen gibt (@see, @autor, …) aber im Prinzip diese frei gewählt werden können. Zu Nutze macht sich das etwa das Programm XDoclet (http://xdoclet.sourceforge.net/). Es generiert aus Tags Schnittstellen, Hilfsklassen, Deskriptoren und mehr. Eine Enterprise Java Bean ist so in wenigen Zeilen definiert:

import javax.ejb.SessionBean;
/**
 * @ejb.bean name = "Hallo"
 *           type = "Stateless"
 *  
 **/
public abstract class HalloBean implements SessionBean
{
  /**
   * @ejb.interface-method
   */
  public String hallo( String name ) {
    return "Hallo " + name;
  }
}

Ein Ant-Tag nimmt denn so annotierten Quellcode und generiert alle für die Enterprise Java Beans nötigen Dateien.

21.1.2 Annotationen 

In Java 5.0 gibt es eine in die Programmiersprache eingebaute Fähigkeit für Metadaten: Annotationen. Auch sie beginnen mit einem @-Zeichen. Neben eingebauten Annotationen lassen sich neue Annotationen definieren. Jeder dieser Annotationen sind Exemplare von Annotations-Typen, die über externe Programme oder über Reflection erfragt werden können. In Java 5.0 sind sechs Annotationen vordefiniert:

@Deprecated. Wie auch das bekannte JavaDoc Tag.

@Overrides. Definiert eine Methode als überschriebene Methode, also als Methode, die eine andere Methode in der Oberklasse überschreibt. Ist diese Annotation an einer Methode festgemacht, die keine Methode der Oberklasse überschreibt, gibt es einen Compilerfehler. Nützlich ist dies für überschriebene Methode der Adpater-Klassen; eine falsche Signatur fällt leicht nicht auf.

@Documented. Der Wunsch wird angezeigt, die Annotation in der Dokumentation zu erwähnen.

@Inherited. Annotationen werden auf die Unterklassen weitergegeben.

@Retention. Die Annotation verlangt einen Parameter, der bestimmt, wann die Annotation verfügbar ist: Auch zur Laufzeit? Zur Compilezeit?

@Target. Bestimmt das Programmelement, für das die Annotation gilt.

Eigene Annotationen werden ähnliche wie Schnittstellen definiert.

public @interface MeineAnnotation
{
   // …
}