Spring AOP vs AspectJ

J'ai l'impression que Spring AOP est mieux utilisé pour des tâches spécifiques à une application telles que la sécurité, la journalisation, les transactions, etc., car il utilise des annotations Java5 personnalisées comme cadre. Cependant, AspectJ semble être des modèles de conception plus conviviaux.

Quelqu'un peut-il mettre en évidence les différents avantages et inconvénients de l'utilisation de Spring AOP vs AspectJ dans une application Spring?

Avantages Spring-AOP

• Il est plus simple à utiliser qu'AspectJ, car vous n'avez pas besoin d'utiliser LTW ( load-time weaving ) ou le compilateur AspectJ.

• Il utilise le modèle Proxy et le modèle Decorator

Contre Spring-AOP

• Il s'agit d'un AOP basé sur un proxy, vous ne pouvez donc utiliser que des points de jointure d'exécution de méthode.
• Les aspects ne sont pas appliqués lors de l'appel d'une autre méthode dans la même classe.
• Il peut y avoir une petite surcharge d'exécution.
• Spring-AOP ne peut pas ajouter un aspect à tout ce qui n'est pas créé par l'usine Spring

AspectJ Pros

• Cela prend en charge tous les points de jonction. Cela signifie que vous pouvez tout faire.
• Il y a moins de temps d'exécution que celui de Spring AOP.

AspectJ Inconvénients

• Faites attention. Vérifiez si vos aspects sont tissés uniquement avec ce que vous vouliez tisser.
• Vous avez besoin d'un processus de construction supplémentaire avec AspectJ Compiler ou devez configurer LTW (tissage au moment du chargement)

En dehors de ce que d' autres ont déclaré - juste reformulez, there are two major differences:

1. L'un est lié au type de tissage.
2. Un autre à la définition du point de jonction.

Spring-AOP: tissage d'exécution via proxy utilisant le concept dedynamic proxy if interface exists or cglib library if direct implementation provided.

AspectJ: Compiler le temps de tissage AspectJ Java Tools(ajc compiler)si la source est disponible ou le tissage post compilation (en utilisant des fichiers compilés). En outre, le tissage au moment du chargement avec Spring peut être activé - il a besoin du aspectjfichier de définition et offre une flexibilité.

Le tissage au moment de la compilation peut offrir des avantages de performance (dans certains cas) et joinpoint definition in Spring-aop is restricted to method definition only which is not the case for AspectJ.

Remarque supplémentaire: si les performances sous forte charge sont importantes, vous voudrez AspectJ qui est 9-35x plus rapide que Spring AOP . 10ns vs 355ns peut ne pas sembler beaucoup, mais j'ai vu des gens utiliser BEAUCOUP d'aspects. 10K d'aspects. Dans ces cas, votre demande peut toucher des milliers d'aspects. Dans ce cas, vous ajoutez ms à cette demande.

Voir les benchmarks .

Le manuel d'utilisation du ressort donnera beaucoup d'informations, directement de la bouche du cheval.

Le chapitre 6.4 - Choisir le style de déclaration AOP à utiliser est mort pour vous car il traite des avantages et des inconvénients des deux.

Le paragraphe 6.1.2 - Capacités et objectifs Spring AOP et les chapitres 6.2 - Support @Aspect et 6.8 - Utiliser AspectJ avec les applications Spring devraient être particulièrement intéressants.

Spring AOP est l'une des parties essentielles du cadre à ressort. Au stade très basique, le framework Spring est basé sur IoC et AOP. Dans le cours officiel du printemps, il y a une diapositive dans laquelle il est dit:

L'AOP est l'une des parties les plus importantes du cadre.

Le point clé pour comprendre comment fonctionne AOP dans Spring est que lorsque vous écrivez un Aspect avec Spring, nous instrumentons le framework avec la construction d'un proxy pour vos objets, avec un JDKDynamicProxysi votre bean implémente une interface ou via CGLIB si votre bean n'implémente aucun interface. N'oubliez pas que vous devez avoir cglib 2.2 dans votre chemin de classe si vous utilisez Spring avant la version 3.2. À partir de Spring 3.2, cela ne sert à rien car cglib 2.2 a été inclus dans le noyau.

Le framework lors de la création du bean créera un proxy qui encapsulera vos objets et ajoutera des responsabilités transversales telles que la sécurité, la gestion des transactions, la journalisation, etc.

La création de proxy de cette manière sera appliquée en commençant par une expression de découpage qui instruit le framework pour décider quels beans et méthodes seront créés en tant que proxy. Le conseil sera plus responsable que pour votre code. N'oubliez pas que dans ce processus, le pointcut capture uniquement les méthodes publiques qui ne sont pas déclarées comme finales.

Maintenant, alors que dans Spring AOP, le tissage des Aspects sera effectué par le conteneur au démarrage du conteneur, dans AspectJ vous devez effectuer cela avec une post-compilation de votre code via la modification du bytecode. Pour cette raison, à mon avis, l'approche Spring est plus simple et plus gérable que AspectJ.

D'un autre côté, avec Spring AOP, vous ne pouvez pas utiliser toute la puissance d'AOP car l'implémentation se fait via des proxys et non avec une modification de votre code.

Comme dans AspectJ, vous pouvez utiliser le tissage au moment du chargement dans SpringAOP. Vous pouvez bénéficier de cette fonctionnalité au printemps est implémentée avec un agent et des configurations spéciales, @EnabledLoadWeavingou en XML. Vous pouvez utiliser l'espace de nom comme exemple. Cependant, dans Spring AOP, vous ne pouvez pas intercepter tous les cas. Par exemple, la newcommande n'est pas prise en charge dans Spring AOP.

Cependant, dans Spring AOP, vous pouvez bénéficier de l'utilisation d'AspectJ grâce à l'utilisation de la aspectofméthode d'usine dans le bean de configuration de ressort.

Pour la raison que Spring AOP est essentiellement un proxy créé à partir du conteneur, vous ne pouvez donc utiliser AOP que pour les beans spring. Alors qu'avec AspectJ vous pouvez utiliser l'aspect dans tous vos beans. Un autre point de comparaison est le débogage et la prévisibilité du comportement du code. Avec spring AOP, le travail est préformé à partir du compilateur Java et les aspects sont un moyen très cool de créer un proxy pour votre bean Spring. Dans AspectJ, si vous modifiez le code, vous avez besoin de plus de compilation et comprendre où vos aspects sont tissés peut être difficile. Même arrêter le tissage au printemps est plus simple: avec le ressort vous supprimez l'aspect de votre configuration, redémarrez et cela fonctionne. Dans AspectJ vous devez recompiler le code!

Dans le tissage au moment du chargement, AspectJ est plus flexible que Spring car Spring ne prend pas en charge toutes les options d'AspectJ. Mais à mon avis Si vous souhaitez modifier le processus de création d'un bean, un meilleur moyen est de gérer la connexion personnalisée dans une usine et non avec le tissage au chargement d'un aspect qui change le comportement de votre nouvel opérateur.

J'espère que ce panoramique d'AspectJ et Spring AOP vous aidera à comprendre la différence des deux potions

Il est important de déterminer si vos aspects seront essentiels à la mission et où votre code est déployé. Spring AOP signifie que vous comptez sur le tissage au moment du chargement. Cela peut échouer et, d'après mon expérience, cela signifie que des erreurs enregistrées peuvent exister mais n'empêcheront pas l'application de fonctionner sans code d'aspect [j'ajouterais la mise en garde qu'il peut être possible de le configurer de telle manière que ce ne soit pas le Cas; mais je n'en suis pas personnellement conscient ]. Le tissage à la compilation évite cela.

De plus, si vous utilisez AspectJ en conjonction avec aspectj-maven-plugin, vous pouvez exécuter des tests unitaires contre vos aspects dans un environnement CI et être sûr que les artefacts construits sont testés et correctement tissés. Bien que vous puissiez certainement écrire des tests unitaires pilotés par Spring, vous n'avez toujours aucune garantie que le code déployé sera celui qui a été testé en cas d'échec de LTW.

Une autre considération est de savoir si vous hébergez l'application dans un environnement où vous êtes en mesure de surveiller directement le succès ou l'échec d'un démarrage de serveur / application ou si votre application est en cours de déploiement dans un environnement où elle n'est pas sous votre supervision [par exemple où elle est hébergé par un client]. Encore une fois, cela indiquerait la voie pour compiler le tissage temporel.

Il y a cinq ans, j'étais beaucoup plus en faveur de l'AOP configuré par Spring pour la simple raison qu'il était plus facile de travailler avec et moins susceptible de mâcher mon IDE. Cependant, comme la puissance de calcul et la mémoire disponible ont augmenté, cela est devenu beaucoup moins un problème et CTW avec l'aspectj-maven-plugin est devenu un meilleur choix dans mon environnement de travail pour les raisons que j'ai exposées ci-dessus.

Cet article a également une bonne explication sur le sujet.

Spring AOP et AspectJ ont des objectifs différents.

Spring AOP vise à fournir une implémentation AOP simple dans Spring IoC pour résoudre les problèmes les plus courants auxquels les programmeurs sont confrontés.

D'autre part, AspectJ est la technologie AOP originale qui vise à fournir une solution AOP complète.

Par rapport à AOP, AspectJ n'a pas besoin d'améliorer la classe cible au moment de la compilation. Au lieu de cela, il génère une classe proxy pour la classe cible au moment de l'exécution, qui implémente la même interface que la classe cible ou est une sous-classe de la classe cible.

En résumé, une instance d'une classe proxy peut être utilisée comme instance d'une classe cible. En général, la structure AOP améliorée au moment de la compilation est plus avantageuse en termes de performances, car la structure AOP améliorée à l'exécution nécessite des améliorations dynamiques à chaque exécution.