Groovy - Annotations

Les annotations sont une forme de métadonnées dans lesquelles elles fournissent des données sur un programme qui ne fait pas partie du programme lui-même. Les annotations n'ont aucun effet direct sur le fonctionnement du code qu'elles annotent.

Les annotations sont principalement utilisées pour les raisons suivantes -

  • Information for the compiler - Les annotations peuvent être utilisées par le compilateur pour détecter les erreurs ou supprimer les avertissements.

  • Compile-time and deployment-time processing - Les outils logiciels peuvent traiter les informations d'annotation pour générer du code, des fichiers XML, etc.

  • Runtime processing - Certaines annotations peuvent être examinées lors de l'exécution.

Dans Groovy, une annotation de base se présente comme suit -

@interface - Le caractère de signe arobase (@) indique au compilateur que ce qui suit est une annotation.

Une annotation peut définir des membres dans the form de méthodes sans corps et une valeur par défaut facultative.

Les annotations peuvent être appliquées aux types suivants -

Type de chaîne

Un exemple d'annotation pour une chaîne est donné ci-dessous -

@interface Simple { 
   String str1() default "HelloWorld"; 
}

Type d'énumération

enum DayOfWeek { mon, tue, wed, thu, fri, sat, sun } 
@interface Scheduled {
   DayOfWeek dayOfWeek() 
}

Type de classe

@interface Simple {} 
@Simple 
class User {
   String username
   int age
}
 
def user = new User(username: "Joe",age:1); 
println(user.age); 
println(user.username);

Valeurs des membres d'annotation

Lorsqu'une annotation est utilisée, il est nécessaire de définir au moins tous les membres qui n'ont pas de valeur par défaut. Un exemple est donné ci-dessous. Lorsque l'exemple d'annotation est utilisé après avoir été défini, une valeur doit lui être affectée.

@interface Example {
   int status() 
}

@Example(status = 1)

Paramètres d'annotation de fermeture

Une bonne fonctionnalité des annotations dans Groovy est que vous pouvez également utiliser une fermeture comme valeur d'annotation. Par conséquent, les annotations peuvent être utilisées avec une grande variété d'expressions.

Un exemple est donné ci-dessous à ce sujet. L'annotation Onlyif est créée en fonction d'une valeur de classe. Ensuite, l'annotation est appliquée à deux méthodes qui publient des messages différents dans la variable de résultat en fonction de la valeur de la variable numérique.

@interface OnlyIf {
   Class value() 
}  

@OnlyIf({ number<=6 }) 
void Version6() {
   result << 'Number greater than 6' 
} 

@OnlyIf({ number>=6 }) 
void Version7() {
   result << 'Number greater than 6' 
}

Annotations méta

C'est une fonctionnalité très utile des annotations dans groovy. Il peut arriver que vous ayez plusieurs annotations pour une méthode comme celle illustrée ci-dessous. Parfois, cela peut devenir compliqué d'avoir plusieurs annotations.

@Procedure 
@Master class 
MyMasterProcedure {}

Dans un tel cas, vous pouvez définir une méta-annotation qui associe plusieurs annotations et appliquer la méta-annotation à la méthode. Donc, pour l'exemple ci-dessus, vous pouvez d'abord définir la collection d'annotations à l'aide de AnnotationCollector.

import groovy.transform.AnnotationCollector
  
@Procedure 
@Master 
@AnnotationCollector

Une fois que cela est fait, vous pouvez appliquer le méta-annotateur suivant à la méthode -

import groovy.transform.AnnotationCollector
  
@Procedure 
@Master 
@AnnotationCollector
  
@MasterProcedure 
class MyMasterProcedure {}