Java Annotations

Java 1.5 führte Annotationen ein, und heute werden sie intensiv in Java EE-Frameworks wie Hibernate, Jersey und Spring verwendet. Eine Java-Annotation ist Metadaten über das Programm, die im Programm selbst eingebettet sind. Sie kann durch das Annotation-Parsing-Tool oder den Compiler geparst werden. Wir können auch festlegen, dass die Verfügbarkeit von Annotationen nur zur Kompilierzeit oder bis zur Laufzeit besteht. Vor Java-Annotationen waren Programmmetadaten durch Java-Kommentare oder durch Javadoc verfügbar, aber Annotationen bieten mehr als das. Annotationsmetadaten können auch zur Laufzeit verfügbar sein, und Annotation-Parser können sie nutzen, um den Prozessablauf zu bestimmen. Zum Beispiel fügen wir in einem Jersey-Webservice eine PATH-Annotation mit einem URI-String zu einer Methode hinzu, und zur Laufzeit parst Jersey sie, um die Methode zu bestimmen, die für das gegebene URI-Muster aufgerufen werden soll.

Java Custom Annotation

Das Erstellen einer benutzerdefinierten Annotation ähnelt dem Schreiben eines Interfaces, außer dass das Interface-Schlüsselwort mit einem @-Symbol versehen ist. Wir können Methoden in einer Annotation deklarieren. Lassen Sie uns ein Beispiel für eine benutzerdefinierte Java-Annotation sehen und dann werden wir deren Merkmale und wichtige Punkte besprechen.

package com.journaldev.annotations;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target(ElementType.METHOD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInfo{
	String author() default "Pankaj";
	String date();
	int revision() default 1;
	String comments();
}

Einige wichtige Punkte über Java-Annotationen:

• Annotationsmethoden können keine Parameter haben.
• Die Rückgabetypen von Annotationsmethoden sind auf Primitive, Strings, Enums, Annotationen oder Arrays davon beschränkt.
• Java-Annotationsmethoden können Standardwerte haben.
• Annotationen können Meta-Annotationen angehängt haben. Meta-Annotationen werden verwendet, um Informationen über die Annotation bereitzustellen.

Meta-Annotationen in Java

Es gibt fünf Arten von Meta-Annotationen:

• @Documented – zeigt an, dass Elemente, die diese Annotation verwenden, durch Javadoc und ähnliche Tools dokumentiert werden sollten. Dieser Typ sollte verwendet werden, um die Deklarationen von Typen zu annotieren, deren Annotationen die Nutzung der annotierten Elemente durch ihre Kunden beeinflussen. Wenn eine Typdeklaration mit Documented annotiert ist, werden ihre Annotationen Teil der öffentlichen API der annotierten Elemente.
• @Target – gibt die Arten von Programmelementen an, auf die ein Annotationstyp anwendbar ist. Einige mögliche Werte sind TYPE, METHOD, CONSTRUCTOR, FIELD usw. Wenn die Meta-Annotation Target nicht vorhanden ist, kann die Annotation auf jedes Programmelement angewendet werden.
• @Inherited – zeigt an, dass ein Annotationstyp automatisch vererbt wird. Wenn ein Benutzer den Annotationstyp bei einer Klassendeklaration abfragt und die Klassendeklaration keine Annotation für diesen Typ aufweist, wird automatisch die Superklasse der Klasse nach dem Annotationstyp abgefragt. Dieser Prozess wird wiederholt, bis eine Annotation für diesen Typ gefunden wird, oder die Spitze der Klassenhierarchie (Object) erreicht ist.
• @Retention – gibt an, wie lange Annotationen mit dem annotierten Typ aufbewahrt werden sollen. Es nimmt ein RetentionPolicy-Argument an, dessen mögliche Werte SOURCE, CLASS und RUNTIME sind
• @Repeatable – wird verwendet, um anzugeben, dass der Annotationstyp, dessen Deklaration er annotiert, wiederholbar ist.

Eingebaute Annotationen in Java

Java bietet fünf eingebaute Annotationen.

• @Override – Wenn wir eine Methode der Superklasse überschreiben wollen, sollten wir diese Annotation verwenden, um dem Compiler zu signalisieren, dass wir eine Methode überschreiben. Wenn also die Superklassenmethode entfernt oder geändert wird, zeigt der Compiler eine Fehlermeldung an. Erfahren Sie, warum wir immer die Java-Override-Annotation verwenden sollten, wenn wir eine Methode überschreiben.
• @Deprecated – wenn wir wollen, dass der Compiler weiß, dass eine Methode veraltet ist, sollten wir diese Annotation verwenden. Java empfiehlt, dass wir in Javadoc Informationen darüber bereitstellen sollten, warum diese Methode veraltet ist und welche Alternative verwendet werden sollte.
• @SuppressWarnings – Dient dazu, dem Compiler zu sagen, dass er bestimmte von ihm produzierte Warnungen ignorieren soll, zum Beispiel die Verwendung von Rohdatentypen in Java-Generics. Seine Aufbewahrungspolitik ist SOURCE, und sie wird vom Compiler verworfen.
• @FunctionalInterface – Diese Annotation wurde in Java 8 eingeführt, um anzuzeigen, dass das Interface als funktionales Interface gedacht ist.
• @SafeVarargs – Eine Programmiererbehauptung, dass der Körper der annotierten Methode oder des Konstruktors keine potenziell unsicheren Operationen mit seinem Varargs-Parameter durchführt.

Java Annotations Beispiel

Lassen Sie uns ein Java-Beispiel sehen, das die Verwendung von eingebauten Annotationen in Java sowie die Verwendung einer von uns im obigen Beispiel erstellten benutzerdefinierten Annotation zeigt.

package com.journaldev.annotations;

import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

public class AnnotationExample {

	public static void main(String[] args) {
	}

	@Override
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 1)
	public String toString() {
		return "Overriden toString method";
	}

	@Deprecated
	@MethodInfo(comments = "deprecated method", date = "Nov 17 2012")
	public static void oldMethod() {
		System.out.println("old method, don't use it.");
	}

	@SuppressWarnings({ "unchecked", "deprecation" })
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 10)
	public static void genericsTest() throws FileNotFoundException {
		List l = new ArrayList();
		l.add("abc");
		oldMethod();
	}

}

Java Annotations Parsing

Wir werden Reflection verwenden, um Java-Annotationen aus einer Klasse zu parsen. Bitte beachten Sie, dass die Aufbewahrungspolitik der Annotation RUNTIME sein sollte, sonst sind ihre Informationen zur Laufzeit nicht verfügbar und wir können keine Daten daraus abrufen.

package com.journaldev.annotations;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class AnnotationParsing {

	public static void main(String[] args) {
		try {
			for (Method method : AnnotationParsing.class.getClassLoader()
					.loadClass(("com.journaldev.annotations.AnnotationExample")).getMethods()) {
				// checks if MethodInfo annotation is present for the method
				if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
					try {
						// iterates all the annotations available in the method
						for (Annotation anno : method.getDeclaredAnnotations()) {
							System.out.println("Annotation in Method '" + method + "' : " + anno);
						}
						MethodInfo methodAnno = method.getAnnotation(MethodInfo.class);
						if (methodAnno.revision() == 1) {
							System.out.println("Method with revision no 1 = " + method);
						}

					} catch (Throwable ex) {
						ex.printStackTrace();
					}
				}
			}
		} catch (SecurityException | ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

}

Output des obigen Programms ist:

Annotation in Method 'public java.lang.String com.journaldev.annotations.AnnotationExample.toString()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=Main method, date=Nov 17 2012)
Method with revision no 1 = public java.lang.String com.journaldev.annotations.AnnotationExample.toString()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @java.lang.Deprecated()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=deprecated method, date=Nov 17 2012)
Method with revision no 1 = public static void com.journaldev.annotations.AnnotationExample.oldMethod()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.genericsTest() throws java.io.FileNotFoundException' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=10, comments=Main method, date=Nov 17 2012)

Reflection API ist sehr leistungsfähig und wird weit verbreitet in Java, J2EE-Frameworks wie Spring, Hibernate, JUnit verwendet. Das ist alles für das Tutorial zu Java-Annotationen-Beispielen, ich hoffe, Sie haben etwas daraus gelernt.