Java-Annotationsmechanismus und seine Prinzipien

Annotationen werden auch Metadaten genannt, wie z. B. unsere gemeinsamen @Override- und @Deprecated-Funktionen. Sie werden zur Erläuterung des Codes verwendet. Sie können zur Beschreibung von Paketen, Klassen und Schnittstellen verwendet werden , Felder und Methodenparameter, lokale Variablen usw. zur Annotation. Seine Hauptfunktionen sind wie folgt:

1. Generieren Sie Dokumente und generieren Sie Javadoc-Dokumente mithilfe der im Code identifizierten Metadaten.

2. Kompilierungsprüfung: Die im Code identifizierten Metadaten ermöglichen dem Compiler eine Überprüfung und Verifizierung während der Kompilierung.

3. Dynamische Verarbeitung zur Kompilierungszeit Dynamische Verarbeitung zur Kompilierungszeit durch die im Code identifizierten Metadaten, z. B. dynamisches Generieren von Code.

4. Dynamische Verarbeitung zur Laufzeit Dynamische Verarbeitung zur Laufzeit durch im Code identifizierte Metadaten, z. B. mithilfe von Reflection-Injection-Instanzen.

Allgemeine Anmerkungen können in drei Kategorien unterteilt werden:

• Die erste Kategorie sind Javas eigene Standardanmerkungen, einschließlich @Override, @Deprecated und @ SuppressWarnings werden verwendet, um das Überschreiben einer Methode anzugeben, um anzuzeigen, dass eine bestimmte Klasse oder Methode veraltet ist, und um anzuzeigen, dass Warnungen ignoriert werden sollen. Der Compiler führt eine Überprüfung durch, nachdem er mit diesen Anmerkungen markiert wurde.

• Eine Kategorie sind Meta-Anmerkungen, die zum Definieren von Anmerkungen verwendet werden, einschließlich @Retention, @Target, @Inherited, @Documented, und @Retention wird verwendet, um dies anzuzeigen Anmerkungen bleiben erhalten. @Target wird verwendet, um den Verwendungsbereich von Anmerkungen anzugeben, @Inherited wird verwendet, um anzugeben, dass Anmerkungen vererbt werden können, und @Documented wird verwendet, um anzugeben, ob Javadoc-Dokumente generiert werden sollen.

• Der erste Typ sind benutzerdefinierte Anmerkungen. Sie können Anmerkungen entsprechend Ihren eigenen Anforderungen definieren und Metaanmerkungen verwenden, um benutzerdefinierte Anmerkungen zu kommentieren.
  

Verwendung von Anmerkungen

Die Verwendung von Anmerkungen ist sehr einfach. Sie müssen eine Anmerkung nur dort markieren, wo eine Anmerkung erforderlich ist.

public class Test {
    @Override    
      public String tostring() {        
          return "override it";
    }
}

Zum Beispiel Anmerkungen zur Klasse hinzufügen:

@Deprecated
public class Test {
}

So können die integrierten Anmerkungen von Java direkt verwendet werden, aber oft müssen wir einige Anmerkungen selbst definieren, z Gemeinsame Federanmerkungen werden verwendet, um Abhängigkeiten zwischen Objekten zu verwalten. Schauen wir uns an, wie Sie Ihre eigene Annotation definieren. Lassen Sie uns eine solche Annotation implementieren: Fügen Sie über @Test eine Zeichenfolge in eine bestimmte Klasse ein und über @TestMethod eine Zeichenfolge in eine bestimmte Methode.

① Erstellen Sie eine Testanmerkung, deklarieren Sie sie als Aktion für die Klasse und behalten Sie sie bis zur Laufzeit bei.

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
    String value() default "default";
}

② Erstellen Sie eine TestMethod-Annotation, deklarieren Sie sie als Reaktion auf die Methode und behalten Sie sie bis zur Laufzeit bei.

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface TestMethod {
    String value();
}

③Die Testklasse gibt nach der Ausführung zwei Zeichenfolgen aus, Standard und Tomcat-Methode. Da @Test keinen Wert übergibt, wird der Standardwert ausgegeben, während @TestMethod die injizierte Zeichenfolge ausgibt.

@Test()
public class AnnotationTest {
    @TestMethod("tomcat-method")
    public void test(){
    }
    public static void main(String[] args){
        Test t = AnnotationTest.class.getAnnotation(Test.class);
        System.out.println(t.value());
        TestMethod tm = null;
        try {
            tm = AnnotationTest.class.getDeclaredMethod("test",null).getAnnotation(TestMethod.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(tm.value());
    }
}

Prinzipien von Annotationen

Zuvor haben wir vorgestellt, wie man die integrierten Annotationen von Java verwendet und wie man eine Annotation anpasst. Schauen wir uns als Nächstes die Prinzipien der Annotationsimplementierung an So werden Anmerkungen unterstützt. Kehren wir für den Annotationstest wie folgt zurück: Wenn die AnnotationTest-Klasse mit Annotationen versehen ist, kann der Wert der Annotationsdeklaration zur Laufzeit über AnnotationTest.class.getAnnotation(Test.class) abgerufen werden Im obigen Satz können Sie sehen, dass die Testanmerkung aus der Klassenstruktur abgerufen wird, sodass die Anmerkung irgendwann zur Klassenstruktur hinzugefügt werden muss.

@Test("test")
public class AnnotationTest {
    public void test(){
    }
}

Vom Java-Quellcode zum Klassenbytecode wird der Compiler vervollständigt. Der Compiler analysiert den Java-Quellcode und generiert Klassendateien, und Anmerkungen werden auch vom Compiler während der Kompilierung verarbeitet Verarbeiten Sie die Anmerkungssymbole und hängen Sie sie an die Klassenstruktur an. Gemäß der JVM-Spezifikation liegt die Klassendateistruktur in einem streng geordneten Format vor. Die einzige Möglichkeit, Informationen an die Klassenstruktur anzuhängen, besteht darin, sie im Attribute-Attribut der Klasse zu speichern Struktur. Wir wissen, dass Klassen, Felder und Methoden ihre eigenen spezifischen Tabellenstrukturen in der Klassenstruktur haben und jede ihre eigenen Attribute hat. Auch ihr Wirkungsbereich kann unterschiedlich sein. Sie können auf Klassen oder auf ein Feld wirken oder Methode speichert der Compiler die Anmerkungsinformationen in den Eigenschaften der Klasse, des Felds oder der Methode.

Nachdem unsere AnnotationTest-Klasse kompiliert wurde, enthält die entsprechende AnnotationTest.class-Datei ein RuntimeVisibleAnnotations-Attribut. Da diese Annotation auf die Klasse angewendet wird, wird dieses Attribut dem Attributsatz der Klasse hinzugefügt. Das heißt, das Schlüssel-Wert-Paar value=test der Test-Annotation wird aufgezeichnet. Wenn die JVM den Bytecode der Datei AnnotationTest.class lädt, speichert sie den Attributwert RuntimeVisibleAnnotations im Klassenobjekt von AnnotationTest, sodass das Testannotationsobjekt über AnnotationTest.class.getAnnotation(Test.class) und dann über abgerufen werden kann Das Test-Annotationsobjekt ruft die Attributwerte in Test ab.

Möglicherweise haben Sie hier Fragen: Was ist das Testanmerkungsobjekt? Tatsächlich ist die Essenz der kompilierten Annotation eine Schnittstelle, die die Annotation-Schnittstelle erbt, also ist @Test tatsächlich „öffentliche Schnittstelle Test erweitert Annotation“. Wenn wir sie über AnnotationTest.class.getAnnotation (Test.class) aufrufen, wird das JDK dies tun Generieren Sie es über einen dynamischen Proxy. Ein Objekt, das die Testschnittstelle implementiert und den RuntimeVisibleAnnotations-Attributwert in diesem Objekt festlegt. Dieses Objekt ist das Test-Annotationsobjekt, und der Annotationswert kann über seine value()-Methode abgerufen werden.

Der gesamte Prozess des Java-Annotationsimplementierungsmechanismus ist wie oben gezeigt. Seine Implementierung erfordert die Zusammenarbeit des Compilers und der JVM.