Zu den Neuerungen in Java 5 gehören Annotations. Der JSR 175 beschreibt Annotations als "Metadata Facility for the Java Programming Language".

Annotationen beinhalten Metadaten, also Daten über andere Daten. Zu vielen Java-Programmelementen können Annotationen hinzugefügt werden, die während des Build-Vorgangs oder auch zur Laufzeit ausgewertet werden können.

Inhalt

1. Annotationen vor Java 5 und ab Java 5
   
2. Annotation-Kategorien
   
3. Meta-Annotationen, Sichtbarkeit, annotierbare Programmelemente
   
4. Annotation selbst deklarieren, anwenden und zur Laufzeit auslesen
   
5. Erläuterungen zu einigen ausgewählten Java-SE- und Java-EE-Annotationen
   
6. Listen der Annotationen in Java SE und Java EE
   

Annotationen vor Java 5 und ab Java 5

Auch vor Java 5 gab es bereits Annotationen-ähnliche Metadaten:

   /**
    * @deprecated
    * @see #meineNeueMethode
    */
   void meineVeralteteMethode()
   {
      ...
   }

Vor Java 5 mussten Annotationen-ähnliche Metadaten zum Beispiel in JavaDoc-Kommentaren untergebracht werden. Einige wurden vom Compiler ausgewertet (z.B. @deprecated). Andere wurden durch Zusatztools ausgewertet (z.B. mit XDoclet).

Das gleiche Beispiel sieht mit der neuen Java-5-@Deprecated-Annotation folgendermaßen aus:

   /**
    * @see #meineNeueMethode
    */
   @Deprecated
   void meineVeralteteMethode()
   {
      ...
   }

Java-5-Annotationen beginnen mit dem '@'-Zeichen und werden vor dem Programmelement, auf das sie sich beziehen, plaziert, üblicherweise vor den anderen Modifizierern (public, static, final, abstract, void, ...).

Annotation-Kategorien

Es gibt drei Annotation-Kategorien:

Meta-Annotationen, Sichtbarkeit, annotierbare Programmelemente

Meta-Annotationen sind Annotationen, die auf Annotationen angewendet werden können. Einige Meta-Annotationen können sowohl auf Annotationen als auch auf andere Programmelemente angewendet werden, andere nur ausschließlich auf Annotationen.

Ein Softwareentwickler, der normalerweise nur bestehende Annotationen anwendet, wird nicht direkt Meta-Annotationen verwenden. Trotzdem muss er sie kennen, um die Deklaration der Java-Annotationen, die er anwenden will, zu verstehen.

Die beiden folgenden besonders wichtigen Meta-Annotationen können nur ausschließlich auf Annotationen angewendet werden:

Annotation selbst deklarieren, anwenden und zur Laufzeit auslesen

Normalerweise werden vorhandene Annotationen auf den eigenen Code angewendet. Vorher müssen die Annotationen deklariert worden sein und nachher müssen sie ausgewertet werden. Obwohl die beiden letzteren Tätigkeiten seltener (oder nie) explizit vom Entwickler programmiert werden, werden im Folgenden alle drei Schritte kurz beschrieben, weil so am leichtesten die Funktion verstanden werden kann.

Für die Deklaration einer Annotation wird das Schlüsselwort "@interface" verwendet und die Parameter werden als parameterlose Methoden deklariert.

Das Beispiel deklariert eine "Normal Annotation", also einer Annotation mit mehreren Parametern.

Damit die Annotation nicht nur zur Build-Zeit, sondern auch später zur Laufzeit zur Verfügung steht, wird eine Meta-Annotation auf die neue Annotation angewendet, nämlich "@Retention(RetentionPolicy.RUNTIME)":

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention( RetentionPolicy.RUNTIME )
public @interface MeineNeueAnnotation
{
   int      meinIntParameter();
   String   meinStringParameter();
   String   meinDefaultParameter() default "xyz";
   String[] meinArrayParameter();
}

In der folgenden Minibeispielklasse wird die Annotation angewendet. Der Defaultparameter braucht nicht gesetzt zu werden, aber das Fehlen eines anderen Parameters würde zu einem Compilerfehler führen. Bitte beachten Sie die Syntax mit geschweiften Klammern für den Array-Parameter ("meinArrayParameter = { ..., ... }").

public class AnwendungMitAnnotation
{
   @MeineNeueAnnotation( meinIntParameter=42,
                         meinStringParameter="Blubb",
                         meinArrayParameter={"a","b","c"} )
   public void meineMethodeMitAnnotation()
   {
      //...
   }
}

Folgende Anwendung liest die übergebenen Parameter der Annotation zur Laufzeit aus (inklusive des Defaultparameters):

import java.lang.reflect.Method;

public class AnnotationZurLaufzeitVerwenden
{
   public static void main( String[] args ) throws Exception
   {
      Method[] methods = AnwendungMitAnnotation.class.getMethods();
      for( Method m : methods ) {
         if( m.isAnnotationPresent( MeineNeueAnnotation.class ) ) {
            MeineNeueAnnotation a = m.getAnnotation( MeineNeueAnnotation.class );
            System.out.println( "Methode:                 " + m.getName() );
            System.out.println( "meinIntParameter():      " + a.meinIntParameter() );
            System.out.println( "meinStringParameter():   " + a.meinStringParameter() );
            System.out.println( "meinDefaultParameter():  " + a.meinDefaultParameter() );
            System.out.println( "meinArrayParameter()[0]: " + a.meinArrayParameter()[0] );
            System.out.println( "meinArrayParameter()[1]: " + a.meinArrayParameter()[1] );
            System.out.println( "meinArrayParameter()[2]: " + a.meinArrayParameter()[2] );
         }
      }
   }
}

Im Beispiel wird Reflection verwendet. Eine Alternative wäre AOP (Aspect oriented Programming).

Speichern Sie die drei .java-Dateien und führen Sie folgende Kommandozeilenbefehle aus:

javac *.java

java AnnotationZurLaufzeitVerwenden

Das Ergebnis sieht so aus:

Methode:                 meineMethodeMitAnnotation
meinIntParameter():      42
meinStringParameter():   Blubb
meinDefaultParameter():  xyz
meinArrayParameter()[0]: a
meinArrayParameter()[1]: b
meinArrayParameter()[2]: c

Erläuterungen zu einigen ausgewählten Java-SE- und Java-EE-Annotationen

Listen der Annotationen in Java SE und Java EE

Java SE 7

Unter den folgenden Links finden Sie zu den Java-SE-Packages jeweils unter der Überschrift "Annotation Types Summary" Annotation-Listen:

java.lang.annotation, java.lang, java.beans, javax.annotation, javax.annotation.processing, javax.jws, javax.jws.soap, javax.management, javax.xml.bind.annotation.adapters, javax.xml.bind.annotation, javax.xml.ws.

Java EE 7

Unter den folgenden Links finden Sie zu den Java-EE-Packages jeweils unter der Überschrift "Annotation Types Summary" Annotation-Listen (einige Annotationen sind sowohl in Java SE als auch in Java EE enthalten):

javax.annotation, javax.annotation.security, javax.ejb, javax.interceptor, javax.jws, javax.jws.soap, javax.persistence, javax.xml.bind.annotation.adapters, javax.xml.bind.annotation, javax.xml.ws.