Tutorial zu Java-Annotationen und benutzerdefinierten Anmerkungen

Java-Anmerkungen stellen einige Informationen über den Code bereit, haben jedoch keinen direkten Einfluss auf den Inhalt des Codes, den sie mit Anmerkungen versehen. In diesem Tutorial lernen wir Java-Annotationen, wie man Annotationen anpasst, wie man sie verwendet und wie man Annotationen durch Reflektion analysiert.

Mit Java 1.5 wurden Annotationen eingeführt, die derzeit in vielen Java-Frameworks wie Hibernate, Jersey und Spring weit verbreitet sind. Anmerkungen werden als Metadaten des Programms in das Programm eingebettet. Anmerkungen können von einigen Analyse- oder Kompilierungstools analysiert werden. Wir können Anmerkungen auch so deklarieren, dass sie während der Kompilierung oder Ausführung eine Wirkung haben.

Vor der Verwendung von Annotationen wurden Programmquelldaten nur über Java-Annotationen und Javadoc weitergeleitet, aber die von Annotationen bereitgestellten Funktionen gehen weit darüber hinaus. Anmerkungen enthalten nicht nur Metadaten, sie können auch während der Programmausführung verwendet werden. Der Anmerkungsinterpreter kann durch Anmerkungen die Ausführungsreihenfolge des Programms bestimmen. Im Jersey-Webservice fügen wir beispielsweise die Annotation **PATH** in Form einer URI-Zeichenfolge zur Methode hinzu. Während der Ausführung des Programms bestimmt der Jersey-Interpreter dann die Methode zum Aufrufen des angegebenen URI.

Benutzerdefinierte Java-Annotationen erstellen

Das Erstellen einer benutzerdefinierten Annotation ähnelt dem Erstellen einer Schnittstelle, aber das Schnittstellenschlüsselwort der Annotation muss mit dem @-Symbol beginnen. Wir können Methoden für Anmerkungen deklarieren. Schauen wir uns zunächst ein Beispiel für eine Annotation an und besprechen dann einige ihrer Funktionen.

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

• Annotationsmethoden dürfen keine Parameter haben.

• Die Rückgabewerttypen von Annotationsmethoden sind beschränkt auf: Basistypen, String, Enums, Annotation Oder ein Array dieser Typen;

• Annotationsmethoden können Standardwerte haben;

• Annotationen selbst können Metaanmerkungen enthalten, die zum Annotieren verwendet werden andere Anmerkungen.

Es gibt vier Arten von Meta-Anmerkungen:

1. @Documented – Zeigt an, dass das Element mit dieser Anmerkung von Tools wie Javadoc dokumentiert werden kann. Dieser Typ sollte verwendet werden, um Typen, die sich auf Clientdeklarationen auswirken, mithilfe annotierter Elemente zu kommentieren. Wenn eine Deklaration mit Documented annotiert ist, wird dieser Annotationstyp als öffentliche API des annotierten Programmmitglieds verwendet.

2. @Target – Gibt den Bereich der Programmelemente an, die diese Art von Annotation annotieren kann. Der Wert dieser Metaanmerkung kann TYPE, METHOD, CONSTRUCTOR, FIELD usw. sein. Wenn die Target-Meta-Annotation nicht vorhanden ist, kann die definierte Annotation auf jedes Element des Programms angewendet werden.

3. @Inherited – gibt an, dass der Annotationstyp automatisch geerbt wird. Wenn der Benutzer diesen Meta-Anmerkungstyp in der aktuellen Klasse abfragt und die Deklaration der aktuellen Klasse diesen Meta-Anmerkungstyp nicht enthält, wird auch die übergeordnete Klasse der aktuellen Klasse automatisch abgefragt, um festzustellen, ob ein geerbtes Meta vorhanden ist -Annotation Diese Aktion wird wiederholt ausgeführt, bis dieser Annotationstyp gefunden wird oder die übergeordnete Klasse der obersten Ebene abgefragt wird.

4.@Retention – gibt an, wie lange die Anmerkung aufbewahrt wird. Die Werte von RetentionPolicy sind SOURCE, CLASS und RUNTIME.

In Java integrierte Anmerkungen

Java bietet drei integrierte Anmerkungen.

1. @Override – Wenn wir eine Methode in der übergeordneten Klasse überschreiben möchten, müssen wir diese Annotation verwenden, um dem Compiler mitzuteilen, dass wir diese Methode überschreiben möchten. Auf diese Weise gibt der Compiler eine Fehlermeldung aus, wenn die Methode in der übergeordneten Klasse entfernt oder geändert wird.

2. @Deprecated – Wir sollten diese Annotation verwenden, wenn wir möchten, dass der Compiler weiß, dass eine bestimmte Methode veraltet ist. Java empfiehlt die Verwendung dieser Annotation im Javadoc, und wir sollten angeben, warum diese Methode veraltet ist, und Alternativen angeben.

3. @SuppressWarnings – Dies weist den Compiler lediglich an, bestimmte Warnmeldungen zu ignorieren, z. B. die Verwendung nativer Datentypen in Generika. Seine Aufbewahrungsrichtlinie ist SOURCE (Anmerkung des Übersetzers: gültig in Quelldateien) und wird vom Compiler verworfen.

Sehen wir uns ein Beispiel der in Java integrierten Annotationen an und beziehen uns dabei auf die oben erwähnten benutzerdefinierten Annotationen.

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

}

Ich glaube, dass dieses Beispiel selbsterklärend ist und seine Anwendung in verschiedenen Szenarien zeigen kann.

Analyse von Java-Annotationen

Wir werden die Reflexionstechnologie verwenden, um die Anmerkungen von Java-Klassen zu analysieren. Dann sollte die RetentionPolicy der Annotation auf RUNTIME gesetzt werden. Andernfalls sind die Annotationsinformationen der Java-Klasse während der Ausführung nicht verfügbar und wir können daraus keine annotationsbezogenen Daten 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();
        }
   }

}

Wenn Sie das obige Programm ausführen, wird Folgendes ausgegeben:

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)

Dies ist der gesamte Inhalt dieses Tutorials. Ich hoffe, Sie können etwas daraus lernen.

Das Obige ist der Inhalt des Java-Annotations-Tutorials und der benutzerdefinierten Annotation. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!