Configuration DI basée sur les annotations Spring vs XML?
Récemment, dans notre équipe, nous avons commencé à discuter de l'utilisation d'annotations Spring dans le code pour définir les dépendances Spring. Actuellement, nous utilisons context.xml pour définir nos dépendances. Pourriez-vous me donner des indices pour l'une ou l'autre approche, et quand est-il préférable de l'utiliser?
Edit: Je sais que cela semble être une question en double à une question plus générale, mais je suis intéressé par les impacts des annotations par rapport à la configuration pour l'injection de dépendance uniquement, qui, je pense, auraient des réponses et une attitude différentes de la question générale.
Après avoir lu quelques articles connexes ici et avoir discuté plus en détail dans l'équipe, nous arrivons aux conclusions suivantes. J'espère que cela serait utile à d'autres ici.
A propos de la configuration XML (que nous utilisons jusqu'à présent), nous avons décidé de le conserver pour les dépendances définies par les bibliothèques (qu'elles soient développées par nous ou par des tiers).
Les bibliothèques, par définition, fournissent une fonctionnalité particulière et peuvent être utilisées dans divers scénarios, n'impliquant pas nécessairement DI. Par conséquent, l'utilisation d'annotations dans les projets de bibliothèque que nous développons nous-mêmes créerait une dépendance du cadre DI (Spring dans notre cas) à la bibliothèque, rendant la bibliothèque inutilisable dans un contexte non DI. Avoir des dépendances supplémentaires n'est pas considéré comme une bonne pratique dans notre équipe (une IMHO en général).
Lorsque nous assemblons une application, le contexte de l'application définirait les dépendances nécessaires. Cela simplifiera le suivi des dépendances car l'application devient l'unité centrale de combinaison de tous les composants référencés, et c'est généralement en effet là que tout le câblage doit se produire.
XML est également bon pour nous lorsque nous fournissons des implémentations simulées pour de nombreux composants, sans recompiler les modules d'application qui les utiliseront. Cela nous donne de la flexibilité lors du test de l'exécution dans un environnement local ou de production.
En ce qui concerne les annotations, nous avons décidé que nous pouvons bénéficier de leur utilisation lorsque les composants injectés ne varieront pas - par exemple, seule une certaine implémentation pour un composant sera utilisée tout au long de l'application.
Les annotations seront très utiles pour les petits composants/applications qui ne changeront pas ou ne prendront pas en charge différentes implémentations d'une dépendance à la fois, et qui sont peu susceptibles d'être composées de manière différente (par exemple, en utilisant différentes dépendances pour différentes générations). Les micro-services simples entrent dans cette catégorie.
Des composants suffisamment petits, constitués d'annotations, peuvent être utilisés dès la sortie de la boîte dans différents projets, sans avoir les applications respectives pour les couvrir dans leur configuration XML. Cela simplifierait le câblage de dépendance d'application pour l'application et réduirait les configurations répétitives.
Cependant, nous avons convenu que ces composants devraient avoir les dépendances bien décrites dans notre documentation technique, de sorte que lors de l'assemblage de l'application entière, on puisse avoir une idée de ces dépendances sans faire défiler le code, ni même charger le module dans l'IDE.
Un effet secondaire négatif des composants configurés par annotation est que différents composants peuvent apporter des dépendances transitoires conflictuelles, et encore une fois, c'est à l'application finale de résoudre les conflits. Lorsque ces dépendances ne sont pas définies en XML, les approches de résolution des conflits deviennent assez limitées et s'éloignent des meilleures pratiques, si elles sont possibles. Ainsi, lorsque vous utilisez des annotations, le composant doit être suffisamment mature sur les dépendances qu'il va utiliser.
En général, si nos dépendances peuvent varier pour différents scénarios ou si un module peut être utilisé avec différents composants, nous avons décidé de nous en tenir à XML. De toute évidence, il DOIT y avoir un juste équilibre entre les deux approches, et une idée claire des usages.
Une mise à jour importante concernant l'approche mixte. Récemment, nous avons eu un cas avec un cadre de test que nous avons créé pour notre équipe AQ, qui nécessitait des dépendances d'un autre projet. Le cadre a été conçu pour utiliser l'approche d'annotation et les classes de configuration Spring, tandis que le projet référencé avait certains contextes xml que nous devions référencer. Malheureusement, les classes de test (où nous avons utilisé org.testng avec support Spring) ne pouvait fonctionner qu'avec les classes de configuration xml ou Java, sans mélanger les deux).
Cette situation illustre un cas où le mélange des approches se heurterait et clairement, il faut l'éliminer. Dans notre cas, nous avons migré le framework de test pour utiliser des contextes XML de printemps, mais d'autres utilisations pourraient impliquer l'inverse.
d'après mon expérience, je préférerais (ou plutôt suis contraint par des limitations) d'utiliser une combinaison de XML et d'annotation basée sur DI. Si j'ai besoin d'injecter une carte d'éléments dans un bean, je devrais définir un util: map et le câbler automatiquement. De plus, je dois utiliser XML DI pour injecter la source de données dans la sessionFactory si j'ai plusieurs sources de données et ainsi de suite. Une combinaison des deux serait donc requise.
Je préfère l'utilisation de l'analyse des composants pour détecter automatiquement les services et Dao. Cela réduit beaucoup de configuration (nous avons réduit les fichiers de configuration d'environ 50% en passant à l'analyse des composants). La DI basée sur les annotations prend en charge à la fois byName (@Resource) et byType (@Autowired).
En bref, mon conseil est d'aller pour un montage des deux. Je pense que davantage de support d'annotation sera certainement prévu dans les prochaines versions de Spring.
Jetez un œil à cette réponse ici: configuration Xml contre configuration basée sur les annotations
Une courte citation directement à partir de là:
Les annotations ont leur utilité, mais elles ne sont pas la seule solution miracle pour tuer la configuration XML. Je recommande de mélanger les deux!
Par exemple, si vous utilisez Spring, il est tout à fait intuitif d'utiliser XML pour la partie d'injection de dépendance de votre application. Cela éloigne les dépendances du code du code qui l'utilisera, en revanche, l'utilisation d'une sorte d'annotation dans le code qui a besoin des dépendances rend le code conscient de cette configuration automatique.
Cependant, au lieu d'utiliser XML pour la gestion transactionnelle, marquer une méthode comme transactionnelle avec une annotation est parfaitement logique, car il s'agit probablement d'informations qu'un programmeur souhaiterait probablement connaître.
EDIT: Jetez également un œil aux réponses ici: injection de dépendance Java: XML ou annotations Ils ciblent très probablement la zone qui vous intéresse beaucoup mieux.
Quelques avantages de l'utilisation configuration XML:
- La configuration XML est à un seul endroit, au lieu d'être dispersée partout dans le code source en cas d'annotations. Certaines personnes peuvent soutenir que les IDE comme STS vous permettent de regarder toutes les configurations basées sur les annotations en un seul endroit, mais je n'aime jamais avoir des dépendances sur les IDE.
- Cela prend un peu plus d'efforts pour écrire la configuration XML, mais cela vous fait gagner beaucoup de temps plus tard lorsque vous recherchez des dépendances et essayez de comprendre le projet.
- XML maintient la configuration bien organisée et simple. Il est donc plus facile à comprendre, il aide les nouveaux membres de l'équipe relativement inexpérimentés à se mettre rapidement au courant.
- Vous permet de modifier la configuration sans avoir besoin de recompiler et de redéployer le code. C'est donc mieux quand il s'agit de soutien à la production.
Donc, en bref, la configuration XML demande un peu plus d'efforts, mais cela vous fait gagner beaucoup de temps et des maux de tête plus tard dans les grands projets.
D'après ma propre expérience, les annotations sont meilleures que la configuration xml. Je pense que dans tous les cas, vous pouvez remplacer les xml et utiliser des annotations. De plus, Spring 4 nous offre un support énorme pour les annotations, nous pouvons remplacer la sécurité du xml aux annotations e.t.c, donc nous n'aurons pas 100 lignes xml mais 10 lignes Java Code.
Les annotations sont-elles meilleures que XML pour configurer Spring?
L'introduction de configurations basées sur des annotations a soulevé la question de savoir si cette approche est "meilleure" que XML. La réponse courte est que cela dépend. La réponse longue est que chaque approche a ses avantages et ses inconvénients, et c'est généralement au développeur de décider quelle stratégie lui convient le mieux. En raison de la façon dont ils sont définis, les annotations fournissent beaucoup de contexte dans leur déclaration, conduisant à une configuration plus courte et plus concise. Cependant, XML excelle dans le câblage de composants sans
toucher leur code source ou les recompiler. Certains développeurs préfèrent avoir le câblage proche de la source tandis que d'autres soutiennent que les classes annotées ne sont plus des POJO et, en outre, que la configuration devient décentralisée et plus difficile à contrôler.
Peu importe le choix, Spring peut accueillir les deux styles et même les mélanger. Il convient de souligner que grâce à son option JavaConfig, Spring permet aux annotations d'être utilisées de manière non invasive, sans toucher au code source des composants cibles et qu'en termes d'outillage, tous les styles de configuration sont pris en charge par Spring Tool Suite.
mon option personnelle est que xml est meilleur car vous avez tous au même endroit et vous n'avez pas besoin de plonger dans vos packages pour rechercher la classe.
Nous ne pouvons pas dire quelle méthode est bonne, cela dépend de votre projet. On ne peut ni éviter le xml ni l'annotation. Un avantage de l'utilisation de xml est que nous pouvons comprendre la structure du projet en ne voyant que les fichiers de contexte xml, mais l'annotation réduit beaucoup de méta-configuration. Je préfère donc 30% xml et 70% d'annotation.