Pour apprendre les annotations en profondeur, nous devons être capables de définir nos propres annotations et de les utiliser. Avant de définir nos propres annotations, nous devons comprendre la syntaxe des méta-annotations et des annotations de définition associées fournies par Java.
-------------------------------------------------- ----------------------------------
Méta-annotation :
Le rôle des méta-annotations est d'annoter d'autres annotations. Java5.0 définit quatre types de méta-annotations standard, qui sont utilisés pour fournir des descriptions d'autres types d'annotations. Méta-annotations définies par Java5.0 :
1.@Cible,
2.@Rétention,
3.@Documenté,
4.@Hérité
Ces types et les classes qu'ils prennent en charge se trouvent dans le package java.lang.annotation. Jetons un coup d'œil au rôle de chaque méta-annotation et aux instructions d'utilisation des sous-paramètres correspondants.
-------------------------------------------------- ----------------------------------
@Cible:
@Target explique la portée des objets modifiés par Annotation : l'annotation peut être utilisée pour les packages, les types (classes, interfaces, énumérations, types d'annotation), les membres de type (méthodes, constructeurs, variables membres, valeurs d'énumération), les paramètres de méthode et les variables locales ( telles que les variables de boucle, les paramètres de capture). L'utilisation de target dans la déclaration du type Annotation peut rendre la cible modifiée plus claire.
Fonction : utilisé pour décrire la portée d'utilisation des annotations (c'est-à-dire : où les annotations décrites peuvent être utilisées)
Les valeurs (ElementType) sont :
1.CONSTRUCTOR : utilisé pour décrire le constructeur 2.FIELD : utilisé pour décrire le domaine 3.LOCAL_VARIABLE : utilisé pour décrire les variables locales 4.METHOD : utilisé pour décrire la méthode 5.PACKAGE : utilisé pour décrire le package 6.PARAMETER : utilisé pour décrire les paramètres 7.TYPE : utilisé pour décrire des classes, des interfaces (y compris les types d'annotations) ou des déclarations enum
Exemples d'utilisation :
@Target (ElementType.FIELD)
public @interface NoDBColumn {
}
-------------------------------------------------- ----------------------------------
@Rétention:
@Retention définit la durée de conservation de l'annotation : certaines annotations n'apparaissent que dans le code source et sont supprimées par le compilateur tandis que d'autres sont compilées dans le fichier classe. Les annotations compilées dans le fichier classe peuvent être virtualisées. La machine les ignore, tandis que d'autres seront lus lors du chargement de la classe (veuillez noter que cela n'affecte pas l'exécution de la classe, car l'annotation et la classe sont utilisées séparément). Utilisez cette méta-Annotation pour limiter le "cycle de vie" de l'Annotation.
Fonction : indique à quel niveau les informations d'annotation doivent être enregistrées et est utilisée pour décrire le cycle de vie de l'annotation (c'est-à-dire : dans quelle portée l'annotation décrite est valide)
Les valeurs (RetentionPoicy) sont :
1.SOURCE : Valable dans le fichier source (c'est-à-dire que le fichier source est conservé)
2.CLASS : Valable dans les fichiers de classe (c'est-à-dire classe réservée)
3.RUNTIME : valide au moment de l'exécution (c'est-à-dire conservé au moment de l'exécution)
Le type de méta-annotation Retention a une valeur unique en tant que membre et sa valeur provient de la valeur du type d'énumération de java.lang.annotation.RetentionPolicy. Des exemples spécifiques sont les suivants :
-------------------------------------------------- ----------------------------------
@Documenté:
@Documented est utilisé pour décrire d'autres types d'annotations qui doivent être utilisées comme API publique des membres du programme annoté et peuvent donc être documentées par des outils tels que javadoc. Documenté est une annotation de balisage et n'a aucun membre.
La méta-annotation @Inherited est une annotation de balisage @Inherited indique qu'un certain type annoté est hérité. Si un type d'annotation modifié avec @Inherited est utilisé pour une classe, cette annotation sera utilisée pour les sous-classes de cette classe.
Remarque : Les types d'annotation @Inherited sont hérités par les sous-classes de la classe annotée. Une classe n'hérite pas des annotations de l'interface qu'elle implémente, et une méthode n'hérite pas des annotations de la méthode qu'elle surcharge.
Lorsque la rétention de l'annotation annotée avec le type d'annotation @Inherited est RetentionPolicy.RUNTIME, l'API de réflexion améliore cet héritage. Si nous utilisons java.lang.reflect pour interroger l'annotation d'un type d'annotation @Inherited, l'inspection réflexive du code commencera à fonctionner : vérifiant la classe et sa classe parent jusqu'à ce que le type d'annotation spécifié soit trouvé, ou le niveau supérieur de la structure d'héritage de classe. est atteint.
Exemple de code :
-------------------------------------------------- ----------------------------------
Annotation personnalisée :
Lorsque vous utilisez @interface pour personnaliser les annotations, l'interface java.lang.annotation.Annotation est automatiquement héritée et d'autres détails sont automatiquement complétés par le compilateur. Lors de la définition d'annotations, vous ne pouvez pas hériter d'autres annotations ou interfaces. @interface est utilisé pour déclarer une annotation, et chaque méthode déclare en fait un paramètre de configuration. Le nom de la méthode est le nom du paramètre et le type de valeur de retour est le type du paramètre (le type de valeur de retour ne peut être que des types de base, Class, String ou enum). Vous pouvez déclarer la valeur par défaut d'un paramètre via default.
Définir le format des annotations :
nom de l'annotation public @interface {corps de définition}
Types de données pris en charge pour les paramètres d'annotation :
1. Tous les types de données de base (int, float, boolean, byte, double, char, long, short)
2. Type de chaîne 3. Type de classe 4. Type d'énumération 5. Type d'annotation 6. Tableaux de tous les types ci-dessus
Comment définir les paramètres dans le type d'annotation :
Premièrement, il ne peut être modifié qu'avec les deux droits d'accès public ou default. Par exemple, String value(); ici, la méthode est définie sur le type par défaut ;
Deuxièmement, les membres paramètres ne peuvent utiliser que les huit types de données de base byte, short, char, int, long, float, double, boolean et les types de données tels que String, Enum, Class, annotations et tableaux de ces types, par exemple. String value();Le membre paramètre ici est String;
Troisièmement, s'il n'y a qu'un seul membre de paramètre, il est préférable de définir le nom du paramètre sur « valeur » suivi de parenthèses. Exemple : L'annotation FruitName dans l'exemple suivant n'a qu'un seul membre de paramètre.
Annotations personnalisées simples et exemples d'utilisation des annotations :
importer java.lang.annotation.Documented ;
importer java.lang.annotation.ElementType ;
importer java.lang.annotation.Retention ;
importer java.lang.annotation.RetentionPolicy ;
importer java.lang.annotation.Target ;
/**
* Notes sur les noms de fruits
* @auteur peida
*
*/
@Target (ElementType.FIELD)
@Rétention(RetentionPolicy.RUNTIME)
@Documenté
public @interface NomFruit {
Valeur de chaîne() par défaut "" ;
}
importer java.lang.annotation.Documented ;
importer java.lang.annotation.ElementType ;
importer java.lang.annotation.Retention ;
importer java.lang.annotation.RetentionPolicy ;
importer java.lang.annotation.Target ;
/**
* Annotation de la couleur des fruits
* @auteur peida
*
*/
@Target (ElementType.FIELD)
@Rétention(RetentionPolicy.RUNTIME)
@Documenté
public @interface FruitColor {
/**
* Énumération des couleurs
* @auteur peida
*
*/
couleur publique enum {BULE, ROUGE, VERT} ;
/**
* Attributs de couleur
* @retour
*/
Couleur fruitColor() par défaut Color.GREEN;
}
importer annotation.FruitColor.Color ;
classe publique Apple {
@FruitName("Pomme")
chaîne privée appleName ;
@FruitColor(fruitColor=Color.RED)
chaîne privée appleColor ;
public void setAppleColor(String appleColor) {
this.appleColor = appleColor;
}
chaîne publique getAppleColor() {
retourner appleColor ;
}
public void setAppleName (String appleName) {
this.appleName = appleName;
}
chaîne publique getAppleName() {
return appleName;
}
public void displayName(){
System.out.println("Le nom du fruit est : Pomme");
}
}