Annotations dans la réflexion Java

On peut dire que le mot "Annotation" a un taux d'apparition élevé en JavaProgrammation, et c'est également un sujet courant. Lorsque nous parlions de choses liées à Spring auparavant, les annotations étaient partout. Nous avons brièvement parlé de certains contenus liés aux "annotations" auparavant, comme la façon de combiner des "annotations" dans Spring. Parce que les annotations sont encore relativement importantes dans la programmation Java, notre blog d'aujourd'hui donnera une introduction systématique aux annotations. Bien entendu, nous nous appuierons sur des exemples spécifiques.

Pour parler franchement, "l'annotation" est un moyen de stocker des données Si l'annotation est supprimée seule, la fonction est moyenne Si "l'annotation" est combinée avec le "de Java". mécanisme de réflexion", il reste encore beaucoup à faire. En d'autres termes, vous pouvez lire les informations fournies par les « annotations » par réflexion, puis faire quelque chose en fonction de vos besoins spécifiques. Bien sûr, nous utilisions XML pour fournir des informations pour le mécanisme de réflexion. Cependant, la configuration de "XML" n'a toujours pas la forme de données "annotations" qui est facile à gérer et à maintenir, donc. le statut des « annotations » est encore relativement important.

Ci-dessous, nous parlerons d'abord des "méta-annotations", puis personnaliserons les annotations en fonction de ces "méta-annotations" et utiliserons le "mécanisme de réflexion" de Java pour lire différents types d'informations d'annotation .

1. Méta-annotation

Dans la première partie de ce blog, faisons un tour d'horizon global"Méta-annotations", puis le contenu ci-dessous est développé en fonction de ces méta-annotations.

1. @Target

Utilisation : @Target(ElementType . CONSTRUCTEUR)

@TargetL'annotation est plus importante que le nom chinois de Target est "Cible, emplacement. " signifie connaître la signification après avoir vu le nom. @Target est utilisé pour déclarer l'emplacement de l'annotation que nous avons créée, c'est-à-dire quel type d'éléments l'annotation que nous avons créée peut modifier. Le paramètre de @Target est une énumération de ElementType, et chaque élément d'énumération représente une position. Vous trouverez ci-dessous quelques-unes des valeurs les plus couramment utilisées de l'énumération ElementType :

• TYPE : Classe, si le paramètre de @Target est TYPE, alors l'annotation nous créons uniquement des classes modifiées, des interfaces, des énumérations et d'autres types.

• FIELD : Modification de champ Si notre annotation personnalisée est de type FIELD, alors notre annotation ne peut être utilisée que pour modifier des champs de classes ou d'énumérations. membre variable .

• CONSTRUCTEUR : Type constructeur, les "annotations" de ce type ne peuvent que modifier le constructeur.

• MÉTHODE : annotation qui modifie "méthode".

• PARAMETER : annotation qui modifie les paramètres dans la "méthode".

• LOCAL_VARIABLE : annotation qui modifie les "variables locales".

Bien sûr, ce qui précède est une brève discussion, et des exemples spécifiques des types d'annotations ci-dessus seront donnés ci-dessous. La capture d'écran ci-dessous montre toutes les options dans ElementType et le rôle de chaque valeur d'énumération. Les détails sont les suivants. Les deux derniers sont des éléments d'énumération nouvellement ajoutés après 1.8, comme suit :

　

2. @Retention

Utilisation : @Retention(RetentionPolicy.RUNTIME)

Ce qui précède explique comment utiliser @Retention La signification chinoise de la rétention est "Rétention. ", c'est-à-dire que la méta-annotation donne la durée de conservation de "l'annotation". @Retention reçoit également un paramètre de type énumération. Vous trouverez ci-dessous le type contenu dans l'énumération. L'annotation anglaise ci-dessous a spécifiquement donné la signification de chaque élément d'énumération.

• SOURCE : Cela signifie que nos annotations resteront uniquement dans notre code source et ne seront pas compilées.

• CLASS : Indique que nos annotations seront compilées en bytecode et stockées dans le fichier .class Mais. il ne sera pas lié et exécuté dans la machine virtuelle.

• RUNTIME : Cela signifie que nos annotations seront conservées jusqu'à l'exécution du programme si vous souhaitez faire quelque chose via le mécanisme de réflexion basé sur les informations d'annotation. au moment de l'exécution Si c'est le cas, alors nous devons conserver nos annotations jusqu'à ce stade.

　

3. @Document et @Hérité

Ces deux annotations sont relativement simples. @Document indique que cette annotation est incluse dans Javadoc, tandis que @Inherited signifie Indique que cette annotation peut être héritée par les sous-classes .

L'introduction ci-dessus est peut-être un peu abstraite. Ensuite, nous utiliserons le mécanisme de réflexion pour exploiter les types d'annotations personnalisées correspondants sur la base d'exemples.

2. Introduction aux cas de test

La capture d'écran ci-dessous est la démo impliquée dans ce blog Répertoire et principales classes d'opérations.

• AnnotationTracker : Cette classe est chargée d'obtenir l' objet du type d'annotation correspondant et les informations associées dans l'annotation via " mécanisme de réflexion". Dans la classe AnnotationTracker, il y a toutes les méthodes statiques . Les méthodes statiques sont transmises dans la classe modifiée par annotation appropriée. La structure générale est la suivante.

• CE…Annotation : Ces classes sont différents types d'annotations, dont nous parlerons en détail plus tard.

• TestClass : Cette classe est la classe de test modifiée par l'annotation.

• Main : La méthode d'exécution de notre scénario de test pour cette démo.

3. Tapez l'annotation : @Target( ElementType.TYPE)

Ensuite, examinons la création et l'utilisation d'annotations de type. Dans le contenu suivant, nous créons une annotation de type modification, puis ajoutons la modification de l'annotation à la classe appropriée et enfin utilisons le mécanisme de réflexion de Java pour obtenir les informations d'annotation correspondantes.

1. Créer une annotation

Créez d'abord notre annotation. Les étapes spécifiques sont les suivantes. Sélectionnez Annotation et tapez. Cliquez simplement sur Entrée sur le nom de l'annotation.

　

L'extrait de code ci-dessous est le contenu détaillé de l'annotation créée. On voit que les paramètres de la méta-annotation @Target sont de type ElementType.TYPE. Cela signifie que l'annotation que nous avons créée est une annotation de type modification, qui peut concerner des classes, des interfaces, des énumérations et d'autres types. Ensuite, nous voyons également que le paramètre de @Retention est de type RetentionPolicy.RUNTIME, indiquant que l'annotation est conservée jusqu'à l'exécution. L'annotation

est déclarée en utilisant @Interface, qui est similaire à une interface. @Interface est suivi du nom de l'annotation. Le nom de cette annotation est CETypeAnnotation. Il existe un attribut public entier (int) de type id. La valeur par défaut de cet attribut est 0, comme indiqué ci-dessous.

2. Utilisation des annotations

L'extrait de code ci-dessous est l'utilisation des annotations ci-dessus. Étant donné que l'annotation créée ci-dessus est de type ElementType.TYPE, nous utilisons cette annotation pour modifier une classe que nous avons créée, qui est la TestClass ci-dessous. Lors de l'annotation d'une modification, nous définissons une valeur pour id, qui est id = 10 ci-dessous.

　

3. Utilisez la réflexion pour obtenir des informations sur les annotations de type modifiées

Ensuite, nous ajouterons le « mécanisme de réflexion » de Java à la classe AnnotationTracker pour obtenir les informations relatives aux annotations de la classe TestClass correspondante. Le paramètre de la méthode trackTypeAnnotation() est un type Class, puis l'objet d'annotation dans la classe correspondante peut être obtenu via la méthode getAnnotation() de Class. Comme indiqué dans l'encadré rouge ci-dessous.

Après avoir obtenu l'objet d'annotation correspondant, nous pouvons obtenir les informations de configuration dans l'annotation correspondante.

　

4. Cas de test et résultats des tests

Ensuite, nous le ferons. la méthode Main, appelez la méthode ci-dessus dans la classe AnnotationTracker et transmettez-la dans TestClass, comme indiqué ci-dessous. Vous en trouverez ci-dessous une copie imprimée.

　

4. Autres types d'annotations

Nous avons discuté en détail des annotations de type ElementType.TYPE ci-dessus. Examinons ensuite d'autres types d'annotations et comment utiliser ces annotations.

1. @Target(ElementType.CONSTRUCTEUR)

Ensuite, nous créons une annotation qui décore le constructeur. La CEConstructorAnnotation ci-dessous est l'annotation que nous avons créée pour modifier le constructeur de classe. La valeur par défaut du champ de valeur est une chaîne vide.

　

2. @Target(ElementType.CHAMP)

Ensuite, nous allons créer une annotation qui modifie le champ. Nous nommons le champ CEFieldAnnotation Le code spécifique est le suivant :

　<.>

3. @Target(ElementType.MÉTHODE)

Vous trouverez ci-dessous l'annotation de la méthode de modification que nous avons créée. Nous l'avons nommée

CEMethodAnnotation Le code spécifique est le suivant.

　

4. @Target(ElementType.PARAMETER)

Ci-dessous les annotations pour les paramètres de la méthode modifiée, nous les nommons comme suit :

　

5. Utilisation des annotations associées mentionnées ci-dessus

Voici comment utiliser les différents types d'annotations définis ci-dessus, chacune effectuant sa tâche. propres devoirs. Je n’entrerai pas dans les détails.

　

6. Utilisez le mécanisme de réflexion pour obtenir différents types d'informations d'annotation

Auparavant, nous avons expliqué comment utiliser le mécanisme de réflexion de « Java » pour obtenir des informations d'annotation pertinentes. Ci-dessous, nous obtiendrons les informations pertinentes sur les différents types d'annotations mentionnés ci-dessus. Le code ci-dessous est principalement le code pertinent dans AnnotationTracker.

1. Obtenez les informations d'annotation du type de constructeur modifié

　

2. Obtenez des informations d'annotation sur les méthodes modifiées et les paramètres de méthode

　

3. Obtenez les informations d'annotation du champ modifié

　

4. et résultat de sortie

　

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!