Depuis l'introduction des annotations dans la version Java 5.0, il est devenu une partie très importante de la plate-forme Java. Au cours du processus de développement, nous voyons souvent des annotations telles que @Override et @Deprecated dans le code d'application. Dans cet article, je vais vous dire quelles sont les annotations, pourquoi elles devraient être introduites, comment les annotations fonctionnent, comment rédiger des annotations personnalisées (à travers des exemples) et dans quelles circonstances pouvez-vous utiliser des annotations ainsi que les dernières annotations et ADF (Framework de développement d'applications). Cela prendra un peu de temps, alors préparez-vous une tasse de café et laissez-nous entrer dans le monde de l'annotation.
Qu'est-ce que l'annotation?
Un mot peut décrire des annotations, c'est-à-dire des métadonnées, c'est-à-dire des données qui décrivent les données. Par conséquent, on peut dire que l'annotation est les métadonnées du code source. Par exemple, le code suivant:
@OverridePublic String toString () {return "Ceci est une représentation de chaîne de l'objet actuel.";}Dans le code ci-dessus, je réécrit la méthode toString () et j'utilise l'annotation @Override. Cependant, même si je n'utilise pas d'annotation @Override pour marquer le code, le programme peut s'exécuter normalement. Alors, que signifie l'annotation? Y a-t-il un avantage à écrire de cette façon? En fait, @Override dit au compilateur que cette méthode est une méthode de réécriture (métadonnées décrivant la méthode). Si la méthode n'existe pas dans la classe parent, le compilateur rapportera une erreur, ce qui a suscité que la méthode n'a pas réécrit la méthode dans la classe parent. Si j'épelle accidentellement la mauvaise faute de frappe, par exemple, écrivez ToString () comme toString () {double r}, et je n'utilise pas l'annotation @Override, le programme peut toujours être compilé et exécuté. Mais les résultats de l'opération seront très différents de ce à quoi je m'attendais. Maintenant, nous comprenons ce que sont les annotations et l'utilisation d'annotations aide à lire le programme.
L'annotation est un modificateur spécial appliqué aux classes, méthodes, paramètres, variables, constructeurs et déclarations de packages. Il s'agit d'un outil sélectionné par la norme JSR-175 pour décrire les métadonnées.
Pourquoi introduire des annotations?
Avant (ou même après utilisation), XML est largement utilisé pour décrire les métadonnées. Certains développeurs et architectes d'applications ont commencé à constater que la maintenance de XML s'aggrave. Ils veulent utiliser quelque chose de serré couplé au code, plutôt qu'une description de code qui est vaguement couplée au code (et dans certains cas même complètement séparé) comme XML. Si vous recherchez "XML vs annotations" dans Google, vous verrez de nombreux débats sur cette question. La chose la plus intéressante est que la configuration XML est réellement introduite pour séparer le code et la configuration. Les deux vues ci-dessus peuvent vous confondre. Les deux vues semblent former un cycle, mais chacun a ses avantages et ses inconvénients. Utilisons un exemple pour comprendre la différence entre les deux.
Si vous souhaitez définir beaucoup de constantes ou de paramètres pour votre application, XML est un bon choix dans ce cas car il ne sera pas connecté à un code spécifique. Si vous souhaitez déclarer une méthode en tant que service, il serait préférable d'utiliser l'annotation car dans ce cas, les annotations et les méthodes doivent être étroitement couplées, et les développeurs doivent le reconnaître.
Un autre facteur important est que l'annotation définit un moyen standard de décrire les métadonnées. Avant cela, les développeurs définissent généralement les métadonnées à leur manière. Par exemple, utilisez des interfaces marquées, des annotations, des mots clés transitoires, etc. Chaque programmeur définit les métadonnées à sa manière, contrairement à la manière standard d'Annotation.
Actuellement, de nombreux cadres utilisent du XML et de l'annotation en combinaison pour équilibrer les avantages et les inconvénients entre les deux.
Comment fonctionne l'annotation? Comment rédiger une annotation personnalisée?
Avant de le dire, nous vous recommandons de télécharger d'abord l'exemple d'annotations Exemple de code annotations échantillon.zip. Après le téléchargement, mettez-le dans l'IDE que vous avez l'habitude d'utiliser. Ces codes vous aideront à mieux comprendre le mécanisme d'annotation.
L'écriture de l'annotation est très simple, vous pouvez comparer la définition de l'annotation avec la définition de l'interface. Regardons deux exemples: l'un est l'annotation standard @Override, et l'autre est l'annotation définie par l'utilisateur @Todo.
@Target (elementType.Method) @retention (retenderPolicy.source) public @Interface Override {}Vous pouvez avoir des questions sur l'annotation @Override, cela ne fait rien, alors comment vérifie-t-il qu'il existe une fonction avec le même nom dans la classe parent? Bien sûr, ne soyez pas surpris, je vous taquine juste. La définition de l'annotation @Override n'est pas seulement ce petit code. Cette partie du contenu est très importante, je dois la répéter à nouveau: les annotations ne sont que des métadonnées et n'ont rien à voir avec la logique commerciale. C'est un peu difficile à comprendre, mais c'est tout. Si les annotations ne contiennent pas de logique métier, quelqu'un doit les implémenter. Les utilisateurs de métadonnées le font. Les annotations ne fournissent que des informations sur les propriétés qu'il définit (classe / méthode / package / domaine). Les utilisateurs d'annotations (encore une fois, un code) lisent ces informations et implémentent la logique nécessaire.
Lorsque nous utilisons les annotations de Java (comme @Override), le JVM est un utilisateur, qui fonctionne au niveau du bytecode. À ce stade, les développeurs d'applications ne peuvent pas contrôler ou utiliser des annotations personnalisées. Alors, expliquons comment rédiger des annotations personnalisées.
Parlons des points clés de l'écriture d'annotations personnalisées une par une. Dans l'exemple ci-dessus, vous voyez des annotations appliquées aux annotations.
La version J2SE5.0 fournit quatre types de méta-annotations dans java.lang.annotation, qui annote spécifiquement d'autres annotations:
@Documented une annotation de balises d'annotations simples indiquant si des informations d'annotation sont ajoutées au document Java.
@Retention définit le cycle de vie de cette annotation.
Retentepolicy.Source est rejetée pendant la phase de compilation. Ces annotations n'ont plus de sens après compilation, donc elles n'écrivent pas de bytecode. @Override, @SuppressWarnings appartiennent tous à ce type d'annotation.
RetenderPolicy.class est rejeté lorsque la classe est chargée. Utile pour traiter les fichiers bytecode. Il s'agit de la méthode par défaut pour les annotations.
RetentionPolicy.Runtime n'est jamais rejeté et l'annotation est conservée pendant l'exécution, de sorte que les informations de l'annotation peuvent être lues en utilisant le mécanisme de réflexion. Nos annotations personnalisées sont généralement utilisées de cette façon.
@Target indique où cette annotation est utilisée. Si ce n'est pas spécifié, l'annotation peut être placée n'importe où. Voici quelques-uns des paramètres disponibles. Il convient de noter que l'annotation des attributs est compatible. Si vous souhaitez ajouter l'annotation aux 7 attributs et exclure un seul attribut, vous devez définir la cible pour inclure tous les attributs.
@Inherited définit la relation entre cette annotation et les sous-classes
Alors, comment est la définition interne des annotations? Les annotations ne prennent en charge que les types de base, les chaînes et les types d'énumération. Tous les attributs du commentaire sont définis comme des méthodes et permettent de fournir des valeurs par défaut.
@Target (elementType.Method) @retention (RetenderPolicy.Runtime) @Interface Todo {Public Enum Priority {Low, Medium, High} Public Enum Status {démarré, not_started} String Author () Default "Yash"; priority priority () Priority. L'exemple suivant montre comment utiliser les annotations ci-dessus.
@Todo (priority = todo.priority.medium, auteur = "yashwant", status = todo.status.started) public void incomplèteMethod1 () {// Une logique commerciale est écrite // mais elle n'est pas encore complète} S'il n'y a qu'un seul attribut dans l'annotation, il peut être nommé directement "valeur", et il n'est pas nécessaire d'indiquer le nom d'attribut lors de l'utilisation.
@Interface auteur {String Value ();} @ auteur ("Yashwant") public void SomeMethod () {} Mais jusqu'à présent, tout semble plutôt bien. Nous définissons nos propres annotations et les appliquons aux méthodes de logique commerciale. Nous devons maintenant rédiger un programme utilisateur pour appeler notre annotation. Ici, nous devons utiliser le mécanisme de réflexion. Si vous connaissez le code de réflexion, vous saurez que la réflexion peut fournir des noms de classe, des méthodes et des objets variables d'instance. Tous ces objets ont la méthode getAnnotation () pour retourner les informations d'annotation. Nous devons convertir cet objet en notre commentaire personnalisé (après avoir vérifié avec instanceOf ()), et nous pouvons également appeler les méthodes du commentaire personnalisé. Jetez un œil à l'exemple de code suivant, en utilisant l'annotation ci-dessus:
Classe BusinessLogicClass = BusinessLogic.Class; For (Méthode Méthode: BusinessLogicClass.GetMethods ()) {Todo Todoannotation = (TODO) Method.GetAnannotation (ToDo.Class); if (Todoannotation! = Null) {System.out.Println ("Nom de la méthode:" + Méthode.GetName ()); ToDoAnnotation.Author ()); System.out.println ("Priority:" + Todoannotation.priority ()); System.out.println ("Status:" + Todoannotation.Status ());}}Cas d'utilisation de l'annotation
Les fonctions des annotations sont très puissantes et des cadres tels que le printemps et l'hébernate utilisent des annotations dans l'exploitation forestière et la validité. Des annotations peuvent être appliquées lorsque des interfaces de marqueur sont utilisées. La différence est que l'interface de balise est utilisée pour définir une classe complète, mais vous pouvez définir des commentaires pour une seule méthode, telle que la question de savoir s'il faut exposer une méthode en tant que service.
De nombreuses nouvelles annotations ont été introduites dans le dernier servlet 3.0, en particulier celles liées à la sécurité des servlet.
Handlestypes Cette annotation est utilisée pour représenter un ensemble de classes d'application transmises au servletContainerinitializer.
HttpConstraine cette annotation représente les contraintes de sécurité pour les demandes d'application de toutes les méthodes HTTP, et est différente de la HTTPMethodConstrainer des contraintes de sécurité définies dans l'annotation de la sécurité.
HTTPMethodConstraint spécifie les contraintes de sécurité pour différents types de demandes, qui sont différentes de l'annotation qui décrit le type de méthode du protocole HTTP dans l'annotation de servletsecurity.
MultipartConfig Cette annotation est marquée sur le servlet, indiquant que le type MIME de la demande que le servlet souhaite traiter est multipart / format.
ServletSecurity L'annotation est marquée sur la classe de succession du servlet, et la demande de protocole HTTP est obligée de se conformer aux contraintes de sécurité.
WebFilter est utilisé pour déclarer un filtre de serveur;
Webinitparam Cette annotation est utilisée pour déclarer les paramètres d'initialisation dans le servlet ou le filtre, et est généralement utilisé avec @WebServlet ou @WebFilter.
WEBLISTERNE Cette annotation est un autre type d'auditeur de déclaration d'événements dans le contexte de l'application Web.
Webservlet Cette annotation est utilisée pour déclarer la configuration d'un servlet.
ADF (Framework d'application) et annotations
Maintenant, nous commençons à discuter de la dernière partie de l'article. Le cadre d'application, connu sous le nom d'ADF, est développé par Oracle pour créer des applications convergées Oracle. Nous avons compris les avantages et les inconvénients des annotations et savons comment rédiger des annotations personnalisées, mais où devrions-nous appliquer les annotations? L'ADF fournit-il des annotations simples? Une bonne question, en effet, il y a quelques limites à utiliser des annotations dans l'ADF. Les cadres d'application mentionnés précédemment tels que Spring et Hibernate utilisent AOP (programmation orientée verso). Dans AOP, le cadre fournit un mécanisme pour injecter du code dans le prétraitement et le traitement ultérieur des événements. Par exemple: vous avez un crochet pour ajouter du code avant et après l'exécution de la méthode, afin que vous puissiez écrire votre code utilisateur à ces endroits. L'ADF n'utilise pas AOP. Si nous avons des cas d'utilisation pour l'annotation disponibles, nous devrons peut-être le mettre en œuvre par l'héritage.
J'espère que vous aimez cet article pour vous aider à mieux comprendre le sens de l'annotation!