Exemples détaillés de mécanisme et de principes d'annotation en Java

Cet article présente principalement des informations pertinentes sur le mécanisme d'annotation et ses principes en Java. J'espère que cet article pourra aider tout le monde à comprendre et à maîtriser cette partie du contenu. Les amis dans le besoin pourront s'y référer

Explication détaillée du mécanisme d'annotation et de ses principes en java

Que sont les annotations

Les annotations sont également appelées métadonnées, comme notre commun @Override et @ Obsolète, l'annotation est une fonctionnalité introduite dans la version JDK1.5. Elle est utilisée pour expliquer le code. Elle peut annoter des packages, des classes, des interfaces, des champs, des paramètres de méthode, des variables locales, etc. Ses principales fonctions sont les suivantes :

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

• 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.

• 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.

• 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 @SuppressWarnings sont utilisés pour indiquer le remplacement d'une méthode, indiquant qu'une classe ou une méthode est obsolète et indiquant les avertissements à ignorer. 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 des documents 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 une méthode :

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

Par exemple, annotez sur la classe :

@Deprecated
public class Test {
}

Donc les annotations intégrées en Java peut être utilisé directement Oui, mais nous devons souvent définir nous-mêmes certaines annotations. Par exemple, le ressort commun utilise un grand nombre d'annotations 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, par défaut et la méthode Tomcat, après l'exécution. Parce que @Test ne transmet pas de valeur, la valeur par défaut est affichée. et @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());
  }
}

Le principe des annotations

L'article précédent présentait comment utiliser les annotations intégrées de Java et comment personnaliser une annotation Suivre Allons jeter un œil aux principes de mise en œuvre des annotations et voir comment les annotations sont prises en charge dans le système Java plus large. 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(){
  }
}

La conversion du code source Java en bytecode de classe est effectuée par le compilateur. Le compilateur analysera le code source Java et générera des fichiers de classe, et les annotations sont. également dans Il est traité par le compilateur lors de la compilation. Le compilateur traitera les symboles d'annotation et les ajoutera à la structure de classe. Selon la spécification JVM, la structure du fichier de classe est un format strictement ordonné. La structure de classe consiste à l'enregistrer dans la classe dans l'attribut attributs de la 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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!