Annotations personnalisées Java
Les annotations Java sont des méta-informations jointes au code, qui est utilisée pour l'analyse et l'utilisation de certains outils pendant la compilation et l'exécution, et servent de fonctions d'explication et de configuration.
Les annotations ne pourront pas et ne peuvent pas affecter la logique réelle du code et ne joueront qu'un rôle auxiliaire. Inclus dans le package java.lang.annotation.
1. Meta Note
La méta-annotation fait référence à l'annotation de l'annotation. Y compris quatre types: @retention @target @Document @inherited.
1.1. @Retention: définissez la stratégie de rétention des annotations
@Retention (RetenderPolicy.Source) // L'annotation existe uniquement dans le code source et ne contient pas @retention (RetentionPolicy.class) // La politique de rétention par défaut est utilisée. L'annotation existera dans le fichier bytecode de classe, mais elle ne peut pas être obtenue au moment de l'exécution. @Retention (RetentionPolicy.Runtime) // L'annotation existera dans le fichier de bytecode de classe et peut être obtenue par réflexion lors de l'exécution.
Classe d'annotation:
@Retention (RetentionPolicy.Runtime) // L'annotation existera dans le fichier de bytecode de classe. @Target ({elementType.field, elementType.Method} peut être obtenu par réflexion à l'exécution // définir la cible de l'annotation ** la plage du champ et la constante d'énumération / méthode @ documentée // indique que l'annotation sera incluse dans le public Javadoc @Interface FieldMeta {/ ** * est un numéro sérial * @return * false; / ** * Nom de champ * @return * / string name () Default ""; / ** * est-ce qu'il est modifiable * @return * / booléen éditable () par défaut True; / ** * If doit afficher dans la liste * @return * / booléen résumé () par défaut; / ** * Field Description * @return * / String Description () Default "; / ** Classe d'entité:
classe publique Anno {@FieldMeta (id = true, name = "numéro de série", ordre = 1) int private id; @FieldMeta (name = "name", ordre = 3) nom de littoral privé; @FieldMeta (name = "Age", Ordre = 2) Private Int Age; @fieldMeta (Description = "Description", Order = 4) Public String Desc () {retour " getID () {return id;} public void setid (int id) {this.id = id;} public String getName () {return name;} public void setName (String name) {this.name = name;} public int getage () {return} Obtenez la classe d'aide pour l'annotation:
classe publique SortableField {public sortableField () {} public sortablefield (fieldmeta meta, champ de champ) {super (); this.meta = meta = this.field = field; this.name = field.getName (); this.type = field.getType ();} public sortableField (fieldmeta meta, string name, classe <?> meta; this.name = name; this.type = type;} private fieldmeta meta; champ de champ privé; nom de chaîne privée; classe privée <?> type; public fieldmeta getmeta () {return meta;} public void setmetta (fieldmeta meta) {this.meta = meta;} champ public) Field;} public String getName () {return name;} public void setName (String name) {this.name = name;} public class <?> getType () {return type;} public void setType (class <?> type) {this.type = type;}} Pour obtenir des annotations à l'exécution, créez d'abord une classe de base:
Classe publique Parent <T> {Private Class <T> Entity; public Parent () {init ();} @ suppressWarnings ("Unchecked") public list <sortableField> init () {list <sortableField> list = new ArrayList <SorableField> (); / ** getClass (). (classe, interface, type primitif ou void) *, puis la convertit en paramétriedType. . * getactualTypeArguments () Renvoie un tableau d'objets de type représentant les paramètres de type réel de ce type. * [0] est le premier de ce tableau. . * En bref, il s'agit d'obtenir le type réel de paramètres génériques de la superclasse. . * / entity = (class <t>) ((ParameTezedyPe) this.getClass (). getGenerricSuperClass ()). getActualTearGuments () [0]; // fieldmeta filed = Entity.getAntannotation (FieldMeta.class); if (this.entity! = Null) {/* RETOUR champs, mais n'incluez pas les champs hérités * entité.getFields (); Renvoie uniquement tous les champs publics accessibles de la classe ou de l'interface représentée par l'objet * dans la classe GetDeclared ** () Méthode Renvoie des champs, des méthodes, etc. avec toutes les autorisations d'accès; * Voir api * * / champ [] fields = entity.getDeclaredFields (); // for (Field f: fields) {// obtient l'annotation contenant fieldmeta fieldmeta meta = f.getannotation (fieldmeta.class); if (meta! = Null) {sortableFiel f); list.add (sf);}} // renvoie toutes les méthodes publiques accessibles de la classe ou de l'interface représentées par la méthode d'objet [] Methods = Entity.getMethods (); pour (méthode m: méthodes) {fieldmeta meta = m.getAntoTation (fieldmeta.class); if (meta! = null) {sortableField sf = new sortableField (meta, m.getName (), m.getReturnType ()); list.add (sf) Tri // CollectionS.Sort (List, new FieldsortCom ()); Collection.Sort (List, New Comparator <SortableField> () {@OverRidePublic int compare (SortableField S1, SortableField S2) {return S1.GetMeta (). Order () - S2.GetMeta (). s1.getName (). compareto (s2.getName ()); // vous pouvez également utiliser la comparaison pour la comparaison}});} la liste de retour;}} Créez une sous-classe pour hériter de la classe de base:
Classe publique Child étend Parent <NoNo> {} Classe de test:
classe publique Testannotation {@SuppressWarnings ({"Unchecked", "RawTypes"}) public static void main (String [] args) {parent c = newfffre "+ l.getName () +" / t Type de champ: "+ l.getType () +" / t Nom de l'annotation: "+ l.getMeta (). name () +" / t Annotation Description: "+ l.getMeta (). Description ());}}}/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// / ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// / ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// / ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /
1. Le principe de travail de l'annotation:
JDK5.0 fournit des fonctionnalités d'annotation, permettant aux développeurs de définir et d'utiliser leurs propres types d'annotation. Cette fonction consiste en une syntaxe qui définit le type d'annotation et une syntaxe qui décrit la déclaration d'annotation, une API qui lit Annotation, un fichier de classe qui utilise l'annotation pour modifier et l'outil de traitement d'annotation.
L'annotation n'affecte pas directement la sémantique du code, mais elle peut être considérée comme un outil ou une bibliothèque de classe d'un programme. Il aura à son tour un effet sur la sémantique du programme en cours d'exécution.
L'annotation peut être lue de diverses manières grâce à un mécanisme de réflexion pendant l'exécution.
2. @Override Annotation:
java.lang
Remplacer le type de commentaire
@Target (valeur = méthode)
@Retention (valeur = source)
Public @Interface Override signifie qu'une déclaration de méthode a l'intention de remplacer une autre déclaration de méthode dans la superclasse. Si la méthode annote avec ce type d'annotation mais ne remplace pas la méthode Superclass, le compilateur génère un message d'erreur.
L'annotation @Override signifie que la sous-classe doit remplacer la méthode correspondante de la classe parent.
Le remplacement est une annotation de marqueur utilisée pour identifier l'annotation. Le nom d'annotation lui-même représente les informations à fournir au programme d'outils.
Voici un exemple utilisant @Override Annotation:
classe A {private String id; A (string id) {this.id = id; } @Override public String toString () {return id; }}3. @Deprecated Annotation:
java.lang
Type de commentaire déprécié
@Documenté
@Retention (valeur = runtime)
public @Interface Discrated Program Elements Annoted with @deprecated, les programmeurs sont découragés d'utiliser de tels éléments, généralement parce qu'il est dangereux ou qu'il existe de meilleures options. Le compilateur prévient lors de l'utilisation d'éléments de programme non approuvés ou de réécriture des réécritures dans du code non approuvé.
La méthode de représentation d'annotation @Deprecated n'est pas recommandée.
Débordé est une annotation marqueur.
Voici un exemple à l'aide de l'annotation @deprecated:
classe A {private String id; A (string id) {this.id = id; } @Deprecated public void execute () {System.out.println (id); } public static void main (String [] args) {a a = new a ("a123"); a.exécute (); }}4. @Suppresswarnings Annotation:
java.lang
Commentaire TypePppresswarnings
@Target (valeur = {type, champ, méthode, paramètre, constructeur, local_variable})
@Retention (valeur = source)
public @Interface Supprimwarnings indique que l'avertissement du compilateur spécifié devrait être défini dans l'élément de commentaire (et tous les éléments du programme contenus dans cet élément de commentaire). Notez que l'ensemble des avertissements qui ne sont pas joués dans un élément donné est un superset de tous les avertissements qui ne sont pas joués dans l'élément. Par exemple, si vous commentez une classe pour désacloyer un avertissement et annoter une méthode pour désacloyer un autre avertissement, les deux avertissements ne seront pas numérisés dans cette méthode.
Selon le style, les programmeurs doivent toujours utiliser cette annotation sur les éléments imbriqués les plus intérieurs, et cela ne fonctionnera que s'ils y seront utilisés. Si vous souhaitez désagréger un avertissement dans une méthode spécifique, vous devez commenter la méthode au lieu de sa classe.
L'annotation @Suppresswarnings indique un avertissement de suppression.
Voici un exemple utilisant @SuppressWarnings Annotation:
@SuppressWarnings ("Unchecked") public static void main (String [] args) {list list = new ArrayList (); list.add ("ABC");}5. Annotations personnalisées:
Lorsque vous utilisez @interface aux annotations personnalisées, 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, d'autres annotations ou interfaces ne peuvent pas être héritées.
Personnalisez le commentaire le plus simple:
public @Interface Myannotation {} Utilisez une annotation personnalisée: classe publique AnnotationTest2 {@myannotation public void execute () {System.out.println ("méthode"); }} 5.1. Ajouter des variables:
public @Interface Myannotation {String Value1 ();} Utilisez des annotations personnalisées: classe publique AnnotationTest2 {@Myannotation (valeur1 = "ABC") public void execute () {System.out.println ("méthode"); }}Lorsque le nom d'attribut utilisé dans l'annotation est la valeur, l'interface de valeur d'attribut peut être écrite directement sans spécifier le nom de l'attribut lors de l'affecture; À l'exception des noms de variables inattendus de la valeur, tous les noms de variables doivent être attribués à l'aide de name = valeur.
5.2. Ajouter des valeurs par défaut:
public @Interface Myannotation {String Value1 () par défaut "ABC";}5.3. Énumération d'utilisation multivariée:
public @Interface Myannotation {String Value1 () par défaut "ABC"; MyEnum Value2 () par défaut Myenum.sunny;} enum Myenum {Sunny, Rainy} Utilisez des annotations personnalisées:
classe publique AnnotationTest2 {@MyAnnotation (valeur1 = "A", valeur2 = Myenum.sunny) public void execute () {System.out.println ("méthode"); }} 5.4. Variables du tableau:
public @interface myannotation {String [] value1 () par défaut "ABC";} Utilisez des annotations personnalisées:
classe publique AnnotationTest2 {@MyAnnotation (valeur1 = {"A", "B"}) public void execute () {System.out.println ("méthode"); }}6. Définir la portée de l'annotation:
@Documenté
@Retention (valeur = runtime)
@Target (value = annotation_type)
La rétention publique @Interface indique la durée de retenue de l'annotation du type d'annotation. Si une annotation de rétention n'existe pas dans la déclaration de type de commentaire, la politique de rétention par défaut est rétentionPolicy.class.
Les commentaires de méta cibles ne sont valides que lorsque le type de commentaire de méta est directement utilisé pour les commentaires. Si le type de commentaire Meta est utilisé en tant que membre d'un autre type de commentaire, il n'est pas valide.
Rétention publique de rétention
Étend ENUM <RetentionPolicy> Commentaires Politique de rétention. Les constantes de ce type d'énumération décrivent différentes stratégies pour garder les commentaires. Ils sont utilisés avec des types de méta-commentaires de rétention pour spécifier la durée des annotations.
CLASSE
Le compilateur enregistrera les commentaires dans le fichier de classe, mais la machine virtuelle n'a pas besoin de conserver les commentaires au moment de l'exécution.
Temps d'exécution
Le compilateur enregistrera les commentaires dans le fichier de classe, et la machine virtuelle conservera les commentaires lors de l'exécution, il peut donc être lu de manière réfléchie.
SOURCE
Commentaires pour jeter le compilateur. @Retention annotation peut fournir une politique de rétention d'annotation pour les compilateurs lors de la définition d'annotations.
L'annotation appartenant à la politique de rétention de classe est @SuppressWarnings, qui ne sera pas stocké dans le fichier .class.
6.1. Exemples d'utilisation dans les annotations personnalisées:
@Retention (RetentionPolicy.class) public @interface myannotation {String [] value1 () par défaut "ABC";}7. Exemple d'utilisation de la réflexion pour lire les informations d'annotation de la politique de rétention d'exécution:
java.lang.reflect
Interface annoteatedElement
Toutes les classes de mise en œuvre connues:
AccessibleObject, classe, constructeur, champ, méthode, le package représente un élément commenté du programme en cours d'exécution dans cette machine virtuelle. Cette interface permet une lecture réflexive des commentaires. Tous les commentaires renvoyés par les méthodes de cette interface sont immuables et sérialisables. L'appelant peut modifier le tableau renvoyé par l'accessoire du membre énuméré de tableau attribué; Cela n'aura aucun effet sur le tableau renvoyé par d'autres appelants.
Si une méthode dans cette interface renvoie un commentaire (directement ou indirectement) contenant un membre de classe assigné qui fait référence à une classe qui n'est pas accessible dans cette machine virtuelle, tenter de lire la classe en appelant la méthode renvoyée par la classe pertinente sur le commentaire retourné entraînera une typhenotpresentexception.
Isannotationpresent
Boolean IsannotationPresent (classe <? étend Annotation> AnnotationClass) Renvoie True si le commentaire du type spécifié existe sur cet élément, sinon renvoie False. Cette méthode est principalement conçue pour faciliter l'accès aux commentaires de balises.
paramètre:
AnnotationClass - objet de classe correspondant au type d'annotation
retour:
Renvoie vrai si le commentaire du type de commentaire spécifié existe sur cet objet, sinon faux
Lancer:
NullPointerException - Si la classe d'annotation donnée est nul
Commencez par la version suivante:
1.5
getannotation
<T étend l'annotation> t getannotation (classe <T> AnnotationClass) Renvoie ces commentaires s'il existe des commentaires du type spécifié de cet élément, sinon null est renvoyé.
paramètre:
AnnotationClass - objet de classe correspondant au type d'annotation
retour:
Si les commentaires du type de commentaire spécifié de l'élément existent sur cet objet, ces commentaires sont retournés, sinon nul
Lancer:
NullPointerException - Si la classe d'annotation donnée est nul
Commencez par la version suivante:
1.5
getannotations
Annotation [] getAnnotations () Renvoie tous les commentaires qui existent sur cet élément. (Si cet élément n'est pas commenté, un tableau de longueur zéro est renvoyé.) L'appelant de la méthode peut modifier le tableau renvoyé à volonté; Cela n'aura aucun effet sur le tableau renvoyé par d'autres appelants.
retour:
Tous les commentaires qui existent sur cet élément
Commencez par la version suivante:
1.5
Getdeclarenotations
Annotation [] GetDeclaredAnnotations () Renvoie tous les commentaires qui existent directement sur cet élément. Contrairement à d'autres méthodes de cette interface, cette méthode ignore les annotations héréditaires. (Si aucun commentaire n'existe directement sur cet élément, un tableau de longueur zéro est retourné.) L'appelant de la méthode peut modifier le tableau renvoyé à volonté; Cela n'aura aucun effet sur le tableau renvoyé par d'autres appelants.
retour:
Tous les commentaires qui existent directement sur cet élément
Commencez par la version suivante:
1.5
Voici un exemple d'utilisation de la réflexion pour lire les informations d'annotation de la politique de rétention d'exécution:
Annotations personnalisées:
@Retention (RetentionPolicy.Runtime) public @interface myannotation {String [] value1 () par défaut "ABC";} Utilisez des annotations personnalisées:
classe publique AnnotationTest2 {@MyAnnotation (valeur1 = {"A", "B"}) @Deprecated public void execute () {System.out.println ("méthode"); }} Lisez des informations dans l'annotation:
public static void main (String [] args) lance SecurityException, NosuchMethodexception, illégalargumentException, illégalaccessException, invocationTargetException {annotationtest2 annotationtest2 = new annotationTest2 (); // GetClass Instance of AnnotationTest2Class <NotationTest2> C = annotationTest2.class; // getMethodInstance Method Method Method = C.GetMethod ("Execute", new Class [] {}); // Déterminez si la méthode contient l'annotation de la myannotation if (méthode.isannotationPresent (myannotation.class)) {// Obtenez l'instance d'annotation de myannotation de cette méthode Myanannotation myannotation = méthode.getannotation (myannotation.class); // Exécuter la méthode méthode.invoke (annotationTest2, nouvel objet [] {}); // Get myannotation String [] value1 = myannotation.value1 (); System.out.println (valeur1 [0]); } // Obtenez toutes les annotations sur l'annotation de la méthode [] annotations = méthode.getAnnotations (); pour (annotation annotation: annotations) {System.out.println (annotation); }}8. Utilisation d'annotations limitées:
Annotations limitées Utilisez @Target.
@Documenté
@Retention (valeur = runtime)
@Target (value = annotation_type)
La cible publique @interface indique le type d'éléments de programme auxquels le type d'annotation s'applique. Si une méta-commentaire cible n'existe pas dans la déclaration de type de commentaire, le type déclaré peut être utilisé sur n'importe quel élément de programme. Si une telle méta commentaire existe, le compilateur applique la limite d'utilisation spécifiée. Par exemple, cette méta commentaire indique que le type de déclaration est lui-même, c'est-à-dire le type de commentaire de méta. Il ne peut être utilisé que sur les déclarations de type de commentaires:
@Target (elementType.annotation_type) public @Interface MetaannotationType {...} Cette méta commentaire indique que le type de déclaration ne peut être utilisé que comme type de membres dans des déclarations de type d'annotation complexes. Il ne peut pas être utilisé directement pour les commentaires:
@Target ({}) public @Interface membreype {...} Il s'agit d'une erreur de temps de compilation qui indique qu'une constante ElementType apparaît plus d'une fois dans le commentaire cible. Par exemple, les méta-commentaires suivantes sont illégales:
@Target ({elementType.field, elementType.Method, elementType.field}) public @Interface Bogus {...} public enum ElementTypeétend le type d'élément de programme enum <ElementType>. Les constantes de ce type d'énumération fournissent une classification simple des éléments déclarés dans un programme Java.
Ces constantes sont utilisées avec le type de commentaire cible pour spécifier dans quelles circonstances il est légal d'utiliser le type de commentaire.
Annotation_type
Déclaration de type de commentaire
CONSTRUCTEUR
Énoncé de méthode du constructeur
CHAMP
Déclaration sur le terrain (y compris les constantes de dénombrement)
Local_variable
Déclaration variable locale
MÉTHODE
Déclaration de méthode
EMBALLER
Déclaration de package
PARAMÈTRE
Déclaration de paramètres
TAPER
Classe, interface (y compris les types de commentaires) ou Déclaration d'énumération
Exemples de limitations sur l'utilisation des annotations:
@Target (elementType.Method) public @interface myannotation {String [] value1 () par défaut "ABC";}9. Ajouter des notes au document d'aide:
Pour ajouter des informations d'annotation au fichier API lors de la création d'un fichier javadoc, vous pouvez utiliser java.lang.annotation.documented.
Déclarez le document d'annotation de construction dans une annotation personnalisée:
@DocumentEdPublic @Interface Myannotation {String [] value1 () par défaut "ABC";} Utilisez des annotations personnalisées:
classe publique AnnotationTest2 {@MyAnnotation (valeur1 = {"A", "B"}) public void execute () {System.out.println ("méthode"); }}10. Utiliser l'héritage dans les annotations:
Par défaut, les annotations ne sont pas héritées en sous-classes. Vous pouvez ajouter Java.lang.annotation.Caration de l'annotation héritée lorsque des annotations personnalisées sont utilisées.
@Documenté
@Retention (valeur = runtime)
@Target (value = annotation_type)
public @interface hérité indique que le type d'annotation est automatiquement hérité. Si une méta-annotation héritée existe dans la déclaration du type de commentaire et que l'utilisateur interroge le type de commentaire dans une déclaration de classe, et il n'y a aucun commentaire de ce type dans la déclaration de classe, le type de commentaire sera automatiquement interrogé dans la superclasse de la classe. Ce processus est répété jusqu'à ce que ce type de commentaire soit trouvé ou que le niveau supérieur de la hiérarchie des classes soit atteint. Si aucune superclasse n'a d'annotation de ce type, la requête indique que la classe actuelle n'a pas une telle annotation.
Notez que si vous utilisez le type d'annotation pour commenter autre chose que la classe, ce type de méta-commentaire n'est pas valide. Notez également que cette méta commentaire facilite uniquement l'héritage des commentaires des superclasses; Il n'est pas valide pour les commentaires des interfaces implémentées.
L'article ci-dessus parle brièvement des annotations personnalisées Java et de l'utilisation de la réflexion pour obtenir des annotations pendant l'exécution est tout le contenu que je partage avec vous. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.