Eine ausführliche Einführung in benutzerdefinierte Anmerkungen in Java

In diesem Artikel werden hauptsächlich relevante Informationen zur detaillierten Erläuterung von benutzerdefinierten Java-Anmerkungen vorgestellt. Java-Anmerkungen enthalten einige Informationen zum Code, haben jedoch keinen direkten Einfluss auf den Inhalt des mit Anmerkungen versehenen Codes.

Benutzerdefinierte Java-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 bereitgestellt, 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();
}

• Anmerkungsmethoden dürfen keine Parameter haben.

• Der Rückgabewerttyp der Anmerkungsmethode ist beschränkt auf : Grundtypen, Zeichenfolgen, Annotationen oder Arrays dieser Typen;

• Annotationsmethoden können Standardwerte haben;

• Annotationen selbst können enthalten Meta-Annotationen, die zum Kommentieren anderer Anmerkungen verwendet werden.
  

Es gibt vier Arten von Meta-Anmerkungen:

1. @Documented —— Zeigt an, dass das Element mit dieser Anmerkung kann Seien Sie Dokumentationstools wie Javadoc. 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 Anmerkungstyp 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();
     }
  }
 
}

Beim Ausführen des obigen Programms 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

Das obige ist der detaillierte Inhalt vonEine ausführliche Einführung in benutzerdefinierte Anmerkungen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!