Annotations Java

Quel est le but des annotations en Java? J’ai cette idée floue d’eux comme quelque part entre un commentaire et le code réel. Affectent-ils le programme au moment de l’exécution?

Quels sont leurs usages typiques?

Sont-ils uniques à Java? Y a-t-il un équivalent C ++?

    Les annotations sont principalement utilisées par le code qui inspecte les autres codes. Ils sont souvent utilisés pour modifier (c’est-à-dire décorer ou emballer) des classes existantes au moment de l’exécution pour modifier leur comportement. Les frameworks tels que JUnit et Hibernate utilisent des annotations pour minimiser la quantité de code nécessaire pour écrire vous-même les frameworks.

    Oracle a une bonne explication du concept et de sa signification en Java sur leur site.

    En outre, sont-ils uniques à Java, existe-t-il un équivalent C ++?

    Non, mais VB et C # ont des atsortingbuts identiques.

    Leur utilisation est assez diverse. Un exemple typique de Java, @Override n’a aucun effet sur le code, mais il peut être utilisé par le compilateur pour générer un avertissement (ou une erreur) si la méthode décorée ne remplace pas une autre méthode. De même, les méthodes peuvent être marquées comme obsolètes.

    Ensuite, il y a la reflection. Lorsque vous reflétez un type de classe dans votre code, vous pouvez accéder aux atsortingbuts et agir en fonction des informations trouvées. Je ne connais aucun exemple en Java, mais en .NET, il est utilisé par le compilateur pour générer des informations de sérialisation pour les classes, déterminer la disposition de la mémoire des structures et déclarer les importations de fonctions des anciennes bibliothèques (entre autres). Ils contrôlent également le fonctionnement du concepteur de formulaires IDE.

    / EDIT: Les atsortingbuts sur les classes sont comparables aux interfaces de balises (comme Serializable en Java). Toutefois, les directives de codage .NET stipulent de ne pas utiliser les interfaces de balise. En outre, ils ne fonctionnent qu’au niveau de la classe et non au niveau de la méthode.

    Anders donne un bon résumé, et voici un exemple d’annotation JUnit

     @Test(expected=IOException.class) public void flatfileMissing() throws IOException { readFlatFile("testfiles"+separator+"flatfile_doesnotexist.dat"); } 

    Ici, l’annotation @Test à JUnit que la méthode flatfileMissing est un test qui doit être exécuté et que le résultat attendu est une IOException levée. Ainsi, lorsque vous exécuterez vos tests, cette méthode sera appelée et le test réussira ou échouera selon qu’une IOException est lancée.

    Java possède également l’outil Annotation Processing Tool (apt) où non seulement vous créez des annotations, mais décidez également comment ces annotations fonctionnent sur le code source.

    Voici une introduction.

    Pour voir des choses intéressantes que vous pouvez faire avec les annotations, consultez mon annotateur JavaBean et son processeur d’annotations .

    Ils sont parfaits pour générer du code, append des validations supplémentaires lors de la construction, et je les utilise également pour un cadre de messages d’erreur (pas encore publié – besoin d’être effacé avec les boss …).

    Par définition littérale, une annotation ajoute des notes à un élément. De même, les annotations Java sont des balises que nous insérons dans le code source pour fournir plus d’informations sur le code. Les annotations Java associent des informations à l’élément de programme annoté. Outre les annotations Java, les programmes Java contiennent une grande quantité de documentation informelle qui est généralement contenue dans les commentaires du fichier de code source. Cependant, les annotations Java sont différentes des commentaires. Elles annotent directement les éléments du programme en utilisant les types d’annotation pour décrire la forme des annotations. Les annotations Java présentent les informations de manière standardisée et structurée afin de pouvoir les utiliser facilement par des outils de traitement.

    Pour lire en détail, il y a un bon tutoriel sur les annotations Java

    Quand utilisez-vous l’annotation @Override de Java et pourquoi? Le lien fait référence à une question sur quand on devrait utiliser l’annotation de substitution (@override). Cela pourrait aider à mieux comprendre le concept d’annotation.

    En ce qui concerne les EJB, les annotations sont connues sous le nom d’approche de logiciel intermédiaire implicite par rapport à une approche de logiciel intermédiaire explicite. Lorsque vous utilisez des annotations, vous personnalisez ce dont vous avez besoin : sans annotation: le code sera

     transfer(Account account1, Account account2, long amount) { // 1: Call middleware API to perform a security check // 2: Call middleware API to start a transaction // 3: Call middleware API to load rows from the database // 4: Subtract the balance from one account, add to the other // 5: Call middleware API to store rows in the database // 6: Call middleware API to end the transaction } 

    Lors de l’utilisation d’Annotation, votre code ne contient pas d’appels d’API encombrants pour utiliser les services de middleware. Le code est propre et axé sur la logique métier

     transfer(Account account1, Account account2, long amount) { // 1: Subtract the balance from one account, add to the other } 

    Les annotations , une forme de métadonnées, 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 ont plusieurs utilisations, parmi lesquelles:

    • Informations pour le compilateur – Le compilateur peut utiliser des annotations pour détecter des erreurs ou supprimer des avertissements.
    • Traitement à la compilation et au moment du déploiement – Les outils logiciels peuvent traiter les informations d’annotation pour générer du code, des fichiers XML, etc.
    • Traitement à l’exécution – Certaines annotations peuvent être examinées lors de l’exécution.

    La scope de visibilité est définie par les constantes java.lang.annotation.RetentionPolicy SOURCE , CLASS et RUNTIME

    • RetentionPolicy.SOURCE : L’annotation serait disponible dans le code source du programme et peut être utilisée par le compilateur ou apt pour la génération de code.
    • RetentionPolicy.CLASS : l’annotation serait dans le fichier .class mais ne serait pas disponible à l’exécution. Utilisé par des outils de manipulation de code octet tels que ASM pour effectuer les modifications
    • RetentionPolicy.RUNTIME : L’annotation serait disponible dans le fichier .class et le runtime, pour inspection via la reflection java via getAnnotations ().