Comment et où sont les Annotations de Java?
Quels sont les principaux domaines que nous pouvons utiliser les Annotations? Est la fonction de remplacement à base de XML de configuration?
- cdb, je ne suis pas sûr que vous êtes tout à fait l'idée de primes -- vous avez un tas d'assez bonnes réponses ici, et sans une clarification de ce qui manque ou ce que vous êtes à la recherche précisément, vous avez ajouté une prime. (Vous avez également ici: stackoverflow.com/questions/1746550/...)
- Bon, je sais que c'est super vieux, mais @delfuego: si vous allez dire à l'OP, il utilise des primes de manière incorrecte, il peut être utile de faire un suivi par aussi expliquer comment utiliser correctement.
Vous devez vous connecter pour publier un commentaire.
Annotations sont méta-méta-objets qui peut être utilisé pour décrire d'autres méta-objets. Les méta-objets sont des classes, d'attributs et de méthodes. Demander à un objet pour ses méta-objet (par exemple,
anObj.getClass()
) est appelée introspection. L'introspection permet d'aller plus loin et nous pouvons demander à un méta-objet ce sont ses annotations (par exempleaClass.getAnnotations
). L'Introspection et les annotations appartiennent à ce qu'on appelle réflexion et de la méta-programmation.Une annotation doit être interprété d'une manière ou d'une autre pour être utile. Les Annotations peuvent être interprétées à développement-temps par l'IDE ou le compilateur, ou à au moment de l'exécution par un cadre.
Annotation processing est un mécanisme très puissant et peut être utilisé dans beaucoup de façons différentes:
@Deprecated, @Override
, ou@NotNull
@Entity, @TestCase, @WebService
@Statefull, @Transaction
@Column, @XmlElement
Dans tous les cas, une annotation est utilisée pour décrire l'élément et de clarifier ses sens.
Avant JDK5, les informations qui s'exprime désormais avec les annotations nécessaires pour être stocké quelque part d'autre, et les fichiers XML ont été fréquemment utilisés. Mais il est plus commode d'utiliser des annotations parce qu'ils appartiennent à la Java le code lui-même, et sont donc beaucoup plus faciles à manipuler que XML.
L'utilisation d'annotations:
...regardez par exemple le projet Lombok, qui utilise les annotations pour définir comment générer
equals
ouhashCode
méthodes.Il existe plusieurs applications de Java annotations. Tout d'abord, ils peuvent être utilisés par le compilateur (ou le compilateur extensions). Considérons par exemple l' Remplacer annotation:
Celui-ci est en fait intégré dans le JDK Java. Le compilateur signale une erreur, si une méthode est taggés avec elle, ce qui ne pas remplacement d'une méthode héritée d'une classe de base. Cette annotation peut être utile pour éviter l'erreur commune, où vous avez réellement l'intention de remplacer une méthode, mais ne parviennent pas à le faire, parce que la signature de votre méthode ne correspond pas à la signature de la méthode redéfinie:
La prochaine JDK7 permettra annotations sur n'importe quel type. Il y a déjà des propositions pour utiliser cette fonctionnalité pour compilateur des annotations telles que NotNull, comme dans:
ce qui pourrait permettre au compilateur de vous avertir de la mauvaise/décoché utilise des variables et null valeurs.
Un autre, plus avancé de l'application pour les annotations implique une réflexion et une annotation de traitement au moment de l'exécution. C'est (je pense) ce que vous aviez à l'esprit quand vous parlez d'annotations comme "remplacement d'basé sur XML de configuration". C'est le type de l'annotation de traitement utilisé, par exemple, par les différents cadres et JCP normes (persistance, l'injection de dépendance, vous le nom) afin de fournir des méta-données et informations de configuration.
Annotations sont une forme de métadonnées (données sur les données) ajouté à un fichier source de Java. Ils sont largement utilisés par les cadres de simplifier l'intégration de code client. Quelques exemples dans le monde réel sur le dessus de ma tête:
JUnit 4 - vous ajouter le
@Test
annotation pour chaque méthode de test que vous voulez JUnit coureur à courir. Il y a aussi des annotations supplémentaires à faire avec la mise en place de tests (comme@Before
et@BeforeClass
). Toutes ces demandes sont traitées par le runner JUnit, qui exécute le test en conséquence. Vous pourriez dire que c'est un remplacement pour le XML de configuration, mais les annotations sont parfois plus puissants (ils peuvent utiliser la réflexion, par exemple) et aussi, ils sont plus proches du code, qu'ils sont le référencement (le@Test
annotation est juste avant la méthode d'essai, de sorte que le but de cette méthode est clair sert de la documentation). XML de configuration sur l'autre main peut être plus complexe et peut inclure beaucoup plus de données que les annotations.En terre cuite - utilise les annotations et des fichiers de configuration XML. Par exemple, le
@Root
annotation raconte la en terre Cuite d'exécution que le annoté champ est une racine et sa mémoire doit être partagée entre les VM instances. Le fichier de configuration XML est utilisé pour configurer le serveur et dire des classes d'instrument.Google Guice - un exemple serait le
@Inject
annotation, qui lorsqu'il est appliqué à un constructeur fait le Guice runtime regarder pour les valeurs de chaque paramètre, basé sur les injecteurs. Le@Inject
annotation serait assez difficile à reproduire, à l'aide de fichiers de configuration XML, et sa proximité avec les références constructeur qu'il est assez utile (imaginez avoir à la recherche d'un énorme fichier XML pour trouver toutes les dépendances des injections vous avez mis en place).J'espère que je vous ai donné un aperçu de la manière dont les annotations sont utilisées dans différents cadres.
Les Annotations en Java, fournir un moyen de décrire les classes, les champs et les méthodes. Essentiellement, ils sont une forme de métadonnées ajoutées à un fichier source de Java, ils ne peuvent pas affecter la sémantique d'un programme directement. Cependant, les annotations peuvent être lues au moment de l'exécution à l'aide de la Réflexion & ce processus est connu comme l'Introspection. Il pourrait être utilisé pour modifier les classes, les champs ou méthodes.
Cette fonction, est souvent exploitée par les Bibliothèques & des Kits de développement logiciel (hibernate, JUnit, Spring Framework) afin de simplifier ou de réduire la quantité de code que le programmeur devrait à moins de faire dans orer de travailler avec ces Bibliothèques ou des Kits de développement logiciel.Par conséquent, il est juste de dire que les Annotations et de Réflexion travailler main dans la main en Java.
Nous obtenons également de limiter la disponibilité d'une annotation, soit au moment de la compilation ou de l'exécution.Ci-dessous est un exemple simple sur la création d'annotations personnalisées
Driver.java
TestAlpha.java
IssueInfo.java
Pas complètement, mais confguration qui correspond étroitement aux structures de code (comme JPA mappages de l'injection de dépendance au Printemps peuvent souvent être remplacés par des annotations, et est généralement beaucoup moins bavard, ennuyeux et douloureux. Quasiment tous les notables de cadres ont réussi ce passage, bien que l'ancien de configuration XML reste le plus souvent comme une option.
Il y a 2 vues d'annotations
vue de l'utilisateur, la plupart du temps, les annotations de travail comme un raccourci, vous faire économiser quelques coups de clés, ou de rendre votre programme plus lisible
fournisseur de vue, le processeur de vue de l'annotation est plus de la lumière pondérée '"interface", votre programme NE se confronter à quelque CHOSE, mais sans explicitement "met en œuvre" l'interface donnée(ici, aka l'annotation)
par exemple en jpa vous définir quelque chose comme
au lieu de
les deux parlent de la même chose "Foo est une classe d'Entité"
Où les Annotations Peuvent Être Utilisés
Java SE 8 mise à Jour: les annotations peuvent également être appliquée à l'utilisation de types. Voici quelques exemples:
Classe création de l'instance de l'expression:
nouveau @Interné Monobjet();
De Type cast:
myString = (@Non null String) str;
met en œuvre la clause:
classe implémente UnmodifiableList
@Readonly Liste<@Readonly T> { ... }
La levée d'une exception de la déclaration:
vide monitorTemperature() throws
@Critiques TemperatureException { ... }
Cadres comme Hibernate avait beaucoup de configuration/mapping est nécessaire utilise les Annotations fortement.
Prendre un coup d'oeil à Hibernate Annotations
JPA (Java EE 5) est un excellent exemple de la (sur)l'utilisation des annotations. Java EE 6 présentera également les annotations dans beaucoup de domaines nouveaux tels que les services web RESTful et de nouvelles annotations pour les sous chacun le bon vieux Servlet API.
Voici plusieurs ressources:
Ce n'est pas seulement les spécificités de la configuration qui doivent /peuvent être prises en charge par les annotations, mais ils peuvent également être utilisés pour contrôler le comportement. Vous voyez ce bon de retour dans Java EE 6 de JAX-RS exemples.
Il est utile pour annoter vos classes, soit à la méthode, la classe ou le niveau de champ, quelque chose à propos de cette classe qui n'est pas tout à fait liée à la classe.
Vous pourriez avoir vos propres annotations, utilisé pour marquer certaines classes comme test de l'utilisation seulement. Il peut être tout simplement à des fins de documentation, ou vous pouvez la faire respecter par le filtrage lors de votre compilation d'une version de production candidat.
Vous pouvez utiliser les annotations pour stocker des méta-données, comme dans un plugin cadre, par exemple, le nom du plugin.
Ses juste un autre outil, sa a de nombreuses fins.
Qu'il attache plus d'informations sur le code (a) compilateur de vérifier ou (b) l'analyse du code
**
**
De Type 1) les Annotations appliqué au code java:
De Type 2) les Annotations appliquée à d'autres annotations:
**
**
http://en.wikipedia.org/wiki/Java_annotation#Custom_annotations
POUR UNE MEILLEURE COMPRÉHENSION ESSAYEZ LIEN CI-DESSOUS:ÉLABORER AVEC DES EXEMPLES
http://www.javabeat.net/2007/08/annotations-in-java-5-0/
Les Annotations peuvent être utilisées comme alternative à l'externe les fichiers de configuration, mais ne peut pas être considéré comme un remplacement complet. Vous pouvez trouver de nombreux exemples où annotationi ont été utilisés pour remplacer les fichiers de configuration, comme Hibernate, JPA, EJB 3 et de presque toutes les technologies Java EE.
De toute façon ce n'est pas toujours un bon choix. Le but de l'utilisation des fichiers de configuration est généralement de séparer le code à partir des détails de l'environnement dans lequel l'application est en cours d'exécution. Dans de telles situations, et surtout quand la configuration est utilisé pour mapper l'application à la structure d'un système externe, l'annotation ne sont pas un bon remplacement pour le fichier de configuration, comme ils vous d'inclure les détails du système externe, à l'intérieur du code source de votre application. Ici fichiers externes sont considérés comme le meilleur choix, sinon, vous aurez besoin de modifier le code source et recompiler à chaque fois que vous modifiez un détail pertinent dans l'environnement d'exécution.
Annotations sont beaucoup plus adaptés pour décorer le code source de l'information additionnelle qui demandent des outils de traitement, à la fois au moment de la compilation et à l'exécution, pour gérer les classes et la structure de classe en particulier.
@Override
et JUnit est@Test
sont de bons exemples de cette utilisation, déjà expliqué en détail dans d'autres réponses.À la fin, la règle est toujours la même: conserver à l'intérieur de la source des choses qui changent avec la source, et de les garder à l'extérieur de la source des choses qui changent de façon indépendante à partir de la source.
Java EE 5 favorise l'utilisation des annotations XML de configuration. Par exemple, dans EJB3 les attributs de transaction sur un EJB méthode sont spécifiés à l'aide d'annotations. Ils ont même utiliser des annotations pour marquer Pojo comme les Ejb et de spécifier les méthodes particulières comme le cycle de vie des méthodes au lieu d'exiger que la mise en œuvre d'une interface.
L'objet d'une annotation Java est tout simplement d'associer l'information à l'élément de programme. Annotations Java peut être utilisé en tant que modificateurs de toute déclaration, si le package, classe (y compris les enums), l'interface (y compris les types d'annotation), le champ, la méthode, le paramètre formel, constructeur, ou une variable locale.
Annotations Java peut aussi être utilisé sur les enum constantes. Ces annotations sont placés immédiatement avant la constante enum ils annoter. Annotations Java sont classiquement placé à l'avant de tous les autres modificateurs, mais ce n'est pas une exigence; ils peuvent être librement mélangés avec d'autres modificateurs.
Lire plus en détail sur Annotations Java.