Les inconvénients de l'annotation de traitement en Java?

Question

J'envisage de commencer un projet qui est utilisé pour générer du code Java à l'aide d'annotations (je ne vais pas rentrer dans les détails, car il n'est pas vraiment pertinent). Je me pose des questions sur la validité et de l'utilité du projet, et quelque chose qui m'a frappé est la dépendance à la Annontation Outil de traitement (apt).

Ce que j'aimerais savoir, car je ne peux pas parler d'expérience, est quels sont les inconvénients de l'utilisation de l'annotation de traitement en Java?

Ces pourrait être n'importe quoi, y compris les goûts de:

• il est difficile de faire TDD lors de l'écriture du processeur
• il est difficile de comprendre le traitement sur un système de construction
• le traitement prend beaucoup de temps, et il est très difficile de courir vite
• en utilisant les annotations dans un IDE nécessite un plugin pour chacun, pour l'amener à se comporter de la même lors de la déclaration des erreurs

Ce sont juste des exemples, pas mon opinion. Je suis dans le processus de recherche si l'un de ces vrais, y compris en posant cette question ;-) )

Je suis sûr qu'il y a des inconvénients (par exemple, Qi4J pas spécifiquement sur la liste à l'aide de pré-processeurs comme un avantage) mais je n'ai pas l'expérience avec lui pour dire ce qu'ils sont.

Tout facteur, peu importe combien de petite ou insignifiante, est la bienvenue!

---

EDIT: le ony alternative raisonnable à l'aide de l'annotation de traitement est probablement de créer des plugins pour les IDEs de générer du code (ce serait quelque chose de vaguement similaire à remplacer/mettre en œuvre des méthodes fonctionnalité qui permettrait de générer toutes les signatures sans le corps de méthode). Cependant, cette étape devra être répétée à chaque fois que les parties pertinentes du code des changements, annotation de traitement ne serait pas, pour autant que je peux dire.

En ce qui concerne l'exemple donné avec le envahissantes montant des annotations, je n'envisage pas le recours devant être quelque chose comme ça, peut-être une poignée pour toute la classe. Ce ne serait pas l'empêcher d'être abusé, bien sûr... ;-)

Answer 1

J'ai créé un ensemble de JavaBean annotations (http://code.google.com/p/javadude/wiki/Annotations)

[Note: je suis en train de travailler sur une nouvelle version dès maintenant, de sorte que le tronc code ne correspond pas à la mise à jour du site téléchargements]

Les tests

Les tests peuvent être assez tentant...

J'ai l'habitude de l'approche par la création d'un projet dans eclipse avec le code de test et de le construire, puis d'en faire une copie et de désactiver l'annotation processing.

Je peux alors utiliser Eclipse pour comparer les "actifs" projet de test pour les "attendus" de la copie du projet.

Je n'ai pas trop de cas de test pour l'instant (c'est très fastidieux à générer de nombreuses combinaisons d'attributs), mais cela aide.

Système De Construction

À l'aide d'annotations dans un système de construction est en fait très facile. Jetez un oeil à http://code.google.com/p/javadude/wiki/Annotations pour un exemple de la façon dont il est utilisé dans un script ant, et de l'utiliser dans eclipse est juste une question de faire un plugin précisant que le processeur d'annotation de l'extension et de la rotation sur l'annotation de traitement dans des projets qui souhaitent l'utiliser.

J'ai utilisé l'annotation de traitement en continu d'un environnement de construction, bâtiment de les annotations & processeur, puis en l'utilisant dans le reste de la construction. C'est vraiment assez indolore.

Le Temps De Traitement

Je n'ai pas trouvé que c'était une question - être prudent de ce que vous faites dans les processeurs. - Je générer beaucoup de code dans la mienne et il fonctionne très bien. C'est un peu plus lent dans ant.

Notez que Java6 processeurs peuvent courir un peu plus vite parce qu'ils font partie de la normale du processus de compilation. Cependant, j'ai eu du mal à les obtenir pour fonctionner correctement dans un code de la capacité de production (je pense que le gros du problème est l'éclipse du soutien et de l'exécution de plusieurs phases compile). Pour l'instant, je bâton avec Java 5.

Erreur De Traitement De

C'est l'un des meilleurs de pensée à travers les choses dans l'annotation de l'API. L'API a un "messager" de l'objet qui gère toutes les erreurs. Chaque IDE fournit une mise en œuvre qui transforme ce dans les messages d'erreur appropriés au bon endroit dans le code.

La seule éclipse spécifiques chose que j'ai fait était de jeter de l'environnement de traitement de l'objet pour que je puisse vérifier si c'était de rentrer exécuter en tant qu'une construire ou pour l'éditeur de la réconciliation. Si l'édition, je l'ai sortie. Finalement, je vais modifier cela de faire de la vérification d'erreur à l'heure de modification de sorte qu'il peut signaler les erreurs que vous tapez. Soyez prudent, car vous avez besoin de le garder vraiment rapide pour une utilisation lors de la réconciliation ou de la modification devient léthargique.

La Génération De Code Gotcha

[ajouté un peu plus par les commentaires]

Le processeur d'annotation spécifications de l'état que vous n'êtes pas autorisé à modifier la classe qui contient l'annotation. Je suppose que c'est pour simplifier le traitement (les autres tours n'avez pas besoin d'inclure les classes annotées, de prévenir l'infini de mise à jour des boucles aussi bien)

Vous pouvez générer des autres classes, cependant, et ils recommandent que l'approche.

- Je créer une super-classe de toutes les méthodes get/set et rien d'autre j'ai besoin de générer. J'ai également le processeur de vérifier que le annoté classe étend la classe générée. Par exemple:

@Bean(...)
public class Foo extends FooGen

- Je créer une classe du même package avec le nom annotées de la classe plus "Gen" et vérifiez que le annoté classe est déclarée à la prolonger.

J'ai vu quelqu'un utiliser le compilateur de l'arbre api pour modifier le annoté de la classe -- c'est contre le spec et je soupçonne qu'ils le branche trou à un certain point, de sorte qu'il ne fonctionne pas.

Je recommande la génération d'une super-classe.

Ensemble

Je suis vraiment heureux à l'aide de l'annotation des processeurs. Très bien conçu, surtout en regardant IDE/version de ligne de commande de l'indépendance.

Pour l'instant, je recommande de s'en tenir à la Java5 annotation processors si vous êtes en train de faire de la génération de code, que vous devez exécuter un outil distinct appelé apt pour les traiter, puis de faire de la compilation.

Notez que l'API de Java 5 et la version 6 de Java annotation des processeurs, c'est différent! La version 6 de Java API de traitement est mieux à mon humble avis, mais je n'ai pas eu de chance avec java 6 processeurs de faire ce que j'ai besoin encore.

Lorsque Java 7 qui vient de sortir, je vais donner à la nouvelle approche de traitement un autre coup.

Hésitez pas à m'envoyer un email si vous avez des questions. (scott@javadude.com)

Espérons que cette aide!

Answer 2

Je pense que si l'annotation processeur, puis certainement utiliser la version 6 de Java version de l'API. C'est lui qui sera pris en charge dans l'avenir. Le Java 5 de l'API était encore dans la dans la non officiel com.soleil.xyz espace de noms.

Je pense que nous allons voir beaucoup plus d'utilisations de l'annotation du processeur de l'API dans un avenir proche. Par exemple Hibernate est le développement d'un processeur de la nouvelle JPA 2 requêtes liées statique de la méta-modèle de la fonctionnalité. Ils sont également à l'élaboration d'un processeur pour la validation de Bean Validation des annotations. Donc annotation processing est là pour rester.

Intégration d'un outil est ok. Les versions les plus récentes de la société IDEs contiennent des options pour configurer l'annotation des processeurs et de les intégrer dans le processus de construction. Les principaux flux de construire des outils de soutien à l'annotation de traitement où maven peut encore causer quelque chagrin.

Les essais j'ai trouver un gros problème. Tous les tests sont indirects et en quelque sorte de vérifier le résultat final de l'annotation de traitement. Je ne peux pas écrire tout simple des tests unitaires qui vient de faire valoir des méthodes simples de travail sur TypeMirrors ou une autre réflexion à partir des classes. Le problème est qu'on ne peut pas instancier de ce type de cours à l'extérieur de l'processeurs compilation cycle. Je ne pense pas que le Soleil avait vraiment la testabilité à l'esprit lors de la conception de l'API.

Answer 3

L'un spécifique qui serait utile pour répondre à la question serait plutôt quoi? Ne pas faire le projet, ou si on le fait pas à l'aide d'annotations? Et si ce n'est l'utilisation d'annotations, quelles sont les alternatives?

Personnellement, je trouve excessive annotations illisibles, et de nombreuses fois trop rigide. Jetez un oeil à ce pour une méthode sur un web service pour mettre en œuvre un fournisseur requis WSDL:

    @WebMethod(action=QBWSBean.NS+"receiveResponseXML")
@WebResult(name="receiveResponseXML"+result,targetNamespace = QBWSBean.NS)
@TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
public int receiveResponseXML(
        @WebParam(name = "ticket",targetNamespace = QBWSBean.NS) String ticket,
        @WebParam(name = "response",targetNamespace = QBWSBean.NS) String response,
        @WebParam(name = "hresult",targetNamespace = QBWSBean.NS) String hresult,
        @WebParam(name = "message",targetNamespace = QBWSBean.NS) String message) {

Je trouve que le code très lisible. Un XML de configuration alternative n'est pas nécessairement mieux, mais.