Java-Annotationen

Java-Annotationen bieten Informationen über den Code. Java-Annotationen haben keine direkte Auswirkung auf den Code, den sie annotieren. Im Java-Annotationen-Tutorial werden wir uns Folgendes ansehen;

1. Eingebaute Java-Annotationen
2. Wie man benutzerdefinierte Annotationen schreibt
3. Verwendung von Annotationen und wie man Annotationen mithilfe der Reflexions-API analysiert.

Java-Annotationen

Java 1.5 führte Annotationen ein und sie werden jetzt stark in Java EE-Frameworks wie Hibernate, Jersey und Spring verwendet. Eine Java-Annotation ist Metadaten über das Programm, die in das Programm selbst eingebettet ist. Sie kann vom Annotation-Analysetool oder vom Compiler analysiert werden. Wir können auch die Verfügbarkeit der Annotation entweder nur zur Kompilierzeit oder bis zur Laufzeit angeben. Vor Java-Annotationen waren Programm-Metadaten über Java-Kommentare oder über Javadoc verfügbar, aber Annotationen bieten mehr als das. Annotationen-Metadaten können auch zur Laufzeit verfügbar sein und Annotationen-Analysewerkzeuge können sie verwenden, um den Ablauf zu bestimmen. Zum Beispiel fügen wir in einem Jersey-Webservice eine PATH-Annotation mit einer URI-Zeichenkette zu einer Methode hinzu und zur Laufzeit analysiert Jersey sie, um die Methode für das angegebene URI-Muster aufzurufen.

Java benutzerdefinierte Annotation

Das Erstellen einer benutzerdefinierten Annotation ist ähnlich wie das Schreiben einer Schnittstelle, mit dem Unterschied, dass das Schlüsselwort „interface“ mit dem Symbol _@_ versehen ist. Wir können Methoden in der Annotation deklarieren. Schauen wir uns ein Beispiel für eine benutzerdefinierte Java-Annotation an und besprechen dann ihre Funktionen und wichtigen Punkte.

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 zu Java-Annotationen sind:

1. Annotation-Methoden können keine Parameter haben.
2. Die Rückgabetypen von Annotation-Methoden sind auf primitive Datentypen, String, Enums, Annotation oder Arrays davon beschränkt.
3. Java-Annotation-Methoden können Standardwerte haben.
4. Annotationen können Meta-Annotationen haben. Meta-Annotationen werden verwendet, um Informationen über die Annotation bereitzustellen.

Meta-Annotationen in Java

Es gibt fünf Arten von Meta-Annotationen:

1. @Documented – gibt an, dass Elemente, die diese Annotation verwenden, von Javadoc und ähnlichen Tools dokumentiert werden sollten. Diese Art sollte verwendet werden, um die Deklarationen von Typen zu kennzeichnen, deren Annotationen die Verwendung annotierter Elemente durch ihre Clients beeinflussen. Wenn eine Typdeklaration mit Documented annotiert ist, werden ihre Annotationen Teil der öffentlichen API der annotierten Elemente.
2. @Ziel – gibt an, für welche Arten von Programmelementen ein Annotationstyp anwendbar ist. Einige mögliche Werte sind TYPE, METHOD, CONSTRUCTOR, FIELD usw. Wenn die Ziel-Metaannotation nicht vorhanden ist, kann die Annotation auf jedes Programmelement angewendet werden.
3. @Vererbt – zeigt an, dass ein Annotationstyp automatisch vererbt wird. Wenn ein Benutzer den Annotations typ in einer Klassendeklaration abfragt und die Klassendeklaration keine Annotation für diesen Typ aufweist, wird automatisch die Superklasse der Klasse für den Annotations typ abgefragt. Dieser Vorgang wird wiederholt, bis eine Annotation für diesen Typ gefunden wird oder die Spitze der Klassenhierarchie (Objekt) erreicht ist.
4. @Retention – gibt an, wie lange Annotationen mit dem annotierten Typ beibehalten werden sollen. Es nimmt das Argument RetentionPolicy an, dessen mögliche Werte SOURCE, CLASS und RUNTIME sind
5. @Wiederholbar – wird verwendet, um anzuzeigen, dass der Annotations typ, dessen Deklaration er annotiert, wiederholbar ist.

Eingebaute Annotationen in Java

Java bietet fünf eingebaute Annotationen.

1. @Override – Wenn wir eine Methode der Oberklasse überschreiben möchten, sollten wir diese Annotation verwenden, um den Compiler darüber zu informieren, dass wir eine Methode überschreiben. Wenn also die Methode der Oberklasse entfernt oder geändert wird, zeigt der Compiler eine Fehlermeldung an. Erfahren Sie, warum wir immer die Java-Überschreibungsannotation verwenden sollten, während wir eine Methode überschreiben.
2. @Deprecated – Wenn wir möchten, dass der Compiler weiß, dass eine Methode veraltet ist, sollten wir diese Annotation verwenden. Java empfiehlt, dass im Javadoc Informationen bereitgestellt werden, warum diese Methode veraltet ist und was die Alternative ist.
3. @SuppressWarnings – Dies dient nur dazu, den Compiler anzuweisen, bestimmte Warnungen zu ignorieren, die er produziert, beispielsweise die Verwendung von Rohdatentypen in Java-Generika. Seine Retentionsrichtlinie ist SOURCE, und der Compiler verwirft sie.
4. @FunctionalInterface – Diese Annotation wurde in Java 8 eingeführt, um anzuzeigen, dass das Interface beabsichtigt ist, ein funktionales Interface zu sein.
5. @SafeVarargs – Eine programmiererische Behauptung, dass der Körper der annotierten Methode oder des Konstruktors keine potenziell unsicheren Operationen auf seinem varargs-Parameter ausführt.

Java Annotations Beispiel

Lassen Sie uns ein Java-Beispiel betrachten, das die Verwendung von integrierten Annotationen in Java sowie die Verwendung einer benutzerdefinierten Annotation zeigt, die wir im obigen Beispiel erstellt haben.

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();
	}

}

I believe above java annotation example is self-explanatory and showing the use of annotations in different cases.

Java Annotationen Analyse

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

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()) {
				// überprüft, ob die MethodInfo-Annotation für die Methode vorhanden ist
				if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
					try {
						// iteriert über alle verfügbaren Annotationen in der Methode
						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();
		}
	}

}

Die Ausgabe des obigen Programms lautet:

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)

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

1. Servlet Specs 3.0 führte die Verwendung von Annotationen für die Servlet-Konfiguration und Init-Parameter ein. Weitere Informationen finden Sie unter Java Servlet Tutorial.
2. Wir können Annotationen in Struts 2 verwenden, um dessen Aktionsklassen und Ergebnisseiten zu konfigurieren. Ein funktionierendes Beispiel finden Sie unter Struts 2 Hello World Annotation Example.

Referenz: Oracle-Website