Mécanisme d'annotation Java et ses principes

Les annotations sont également appelées métadonnées, comme nos communes @Override et @Deprecated. Les annotations sont une fonctionnalité introduite dans la version JDK1.5. Elles sont utilisées pour expliquer le code. Elles peuvent être utilisées pour décrire des packages, des classes, des interfaces. , champs et paramètres de méthode, variables locales, etc. pour l'annotation. Ses principales fonctions sont les suivantes :

1. Générer des documents et générer des documents javadoc grâce aux métadonnées identifiées dans le code.

2. Vérification de la compilation, les métadonnées identifiées dans le code permettent au compilateur de vérifier et de vérifier lors de la compilation.

3. Traitement dynamique au moment de la compilation. Traitement dynamique au moment de la compilation via les métadonnées identifiées dans le code, telles que la génération dynamique de code.

4. Traitement dynamique au moment de l'exécution. Traitement dynamique au moment de l'exécution via des métadonnées identifiées dans le code, comme l'utilisation d'instances d'injection de réflexion.

Les annotations générales peuvent être divisées en trois catégories :

• La première catégorie est constituée des annotations standard de Java, notamment @Override, @Deprecated et @ Les SuppressWarnings sont utilisés pour indiquer le remplacement d'une méthode, indiquant qu'une certaine classe ou méthode est obsolète et indiquant que les avertissements doivent être ignorés. Le compilateur vérifiera après avoir été marqué avec ces annotations.

• Une catégorie est celle des méta-annotations. Les méta-annotations sont des annotations utilisées pour définir des annotations, notamment @Retention, @Target, @Inherited, @Documented et @Retention est utilisé pour indiquer que. les annotations sont conservées, @Target est utilisé pour indiquer la portée d'utilisation des annotations, @Inherited est utilisé pour indiquer que les annotations peuvent être héritées et @Documented est utilisé pour indiquer s'il faut générer un document javadoc.

• Le premier type est celui des annotations personnalisées. Vous pouvez définir des annotations en fonction de vos propres besoins et utiliser des méta-annotations pour annoter des annotations personnalisées.
  

Utilisation des annotations

L'utilisation des annotations est très simple Il vous suffit de marquer une annotation là où une annotation est requise. Par exemple, annoter un. méthode :

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

Par exemple, annoter la classe :

@Deprecated
public class Test {
}

Les annotations intégrées de Java peuvent donc être utilisées directement, mais nous devons souvent définir certaines annotations nous-mêmes, comme celles courantes de Spring. Un grand nombre d'annotations sont utilisées pour gérer les dépendances entre les objets. Voyons comment définir votre propre annotation. Implémentons une telle annotation : injectez une chaîne dans une certaine classe via @Test et injectez une chaîne dans une certaine méthode via @TestMethod.

① Créez une annotation Test, déclarez-la pour agir sur la classe et conservez-la jusqu'à l'exécution. La valeur par défaut est default.

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

② Créez une annotation TestMethod, déclarez-la pour agir sur la méthode et conservez-la jusqu'à l'exécution.

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

③La classe de test génère deux chaînes, default et tomcat-method, après l'exécution. Étant donné que @Test ne transmet pas de valeur, la valeur par défaut est générée, tandis que @TestMethod génère la chaîne injectée.

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

Principes des annotations

Précédemment, nous avons présenté comment utiliser les annotations intégrées de Java et comment personnaliser une annotation. Examinons ensuite les principes de mise en œuvre des annotations et les principes de leur annotation. système plus vaste de Java. Voici comment les annotations sont prises en charge. Revenons à l'exemple d'annotation personnalisée ci-dessus. Pour le test d'annotation, comme suit, si la classe AnnotationTest est annotée, la valeur de la déclaration d'annotation peut être obtenue au moment de l'exécution via AnnotationTest.class.getAnnotation(Test.class). Dans la phrase ci-dessus, vous pouvez voir qu'il obtient l'annotation Test de la structure de classe, donc l'annotation doit avoir été ajoutée à la structure de classe à un moment donné.

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

Du code source Java au bytecode de classe est complété par le compilateur. Le compilateur analysera le code source Java et générera des fichiers de classe, et les annotations seront également traitées par le compilateur lors de la compilation. traiter les symboles d'annotation et les ajouter à la structure de classe. Selon la spécification JVM, la structure du fichier de classe est dans un format strictement ordonné. La seule façon d'ajouter des informations à la structure de classe est de les enregistrer dans l'attribut d'attributs de la classe. structure. Nous savons que les classes, les champs et les méthodes ont leurs propres structures de tables spécifiques dans la structure de classe, et chacune a ses propres attributs. Quant aux annotations, leur champ d'action peut également être différent. Elles peuvent agir sur des classes ou sur un champ. ou méthode, le compilateur stockera les informations d'annotation dans les propriétés de la classe, du champ ou de la méthode.

Une fois notre classe AnnotationTest compilée, le fichier AnnotationTest.class correspondant contiendra un attribut RuntimeVisibleAnnotations Puisque cette annotation est appliquée à la classe, cet attribut est ajouté à l'ensemble d'attributs de la classe. Autrement dit, la paire clé-valeur value=test de l'annotation Test sera enregistrée. Lorsque la JVM charge le bytecode du fichier AnnotationTest.class, elle enregistre la valeur de l'attribut RuntimeVisibleAnnotations dans l'objet Class d'AnnotationTest, afin que l'objet d'annotation Test puisse être obtenu via AnnotationTest.class.getAnnotation(Test.class), puis via L'objet d'annotation Test obtient les valeurs d'attribut dans Test.

Vous avez peut-être des questions ici, qu'est-ce que l'objet d'annotation Test ? En fait, l'essence de l'annotation compilée est une interface qui hérite de l'interface Annotation, donc @Test est en fait "l'interface publique Test étend l'Annotation". Lorsque nous l'appelons via AnnotationTest.class.getAnnotation(Test.class), le JDK le fera. générer via un proxy dynamique Un objet qui implémente l'interface Test et définit la valeur de l'attribut RuntimeVisibleAnnotations dans cet objet. Cet objet est l'objet d'annotation Test, et la valeur d'annotation peut être obtenue via sa méthode value().

L'ensemble du processus de mise en œuvre du mécanisme d'annotation Java est comme indiqué ci-dessus. Sa mise en œuvre nécessite la coopération du compilateur et de la JVM.