Spring AOP: Quelle est la différence entre JoinPoint et PointCut?
J'apprends les concepts de programmation orientés aspect et Spring AOP. Je ne comprends pas la différence entre un point coupé et un point de jonction - les deux semblent identiques pour moi. Un point de coupure est l'endroit où vous appliquez vos conseils et un point de jonction est également un endroit où nous pouvons appliquer nos conseils. Alors quelle est la différence?
Un exemple de coupure de point peut être:
@Pointcut("execution(* * getName()")
Que peut être un exemple de jointure?
Jointure: Une jointure est un candidat point dans l'exécution du programme de l'application où un aspect peut être branché. Ce point peut être une méthode appelée, une exception levée ou même un champ en cours de modification. Ce sont les points où le code de votre aspect peut être inséré dans le flux normal de votre application pour ajouter un nouveau comportement.
Conseil: Cet objet inclut les appels de l'API aux problèmes à l'échelle du système représentant l'action à exécuter à un point de jonction spécifié.
Pointcut: Un pointcut définit à quels points de jonction, l'avis associé doit être appliqué. Les conseils peuvent être appliqués à n’importe quel point de ralliement pris en charge par le cadre AOP. Bien entendu, vous ne souhaitez pas appliquer tous vos aspects à tous les points de jonction possibles. Les découpes en point vous permettent de spécifier où vous souhaitez que vos conseils soient appliqués. Souvent, vous spécifiez ces points en utilisant des noms de classe et de méthode explicites ou via des expressions régulières qui définissent des modèles de nom de classe et de méthode correspondants. Certains frameworks AOP vous permettent de créer des découpages dynamiques qui déterminent si des conseils doivent être appliqués en fonction des décisions d'exécution, telles que la valeur des paramètres de méthode.
L'image suivante peut vous aider à comprendre Advice, PointCut, Joinpoints. 
Explication à l'aide de l'analogie avec le restaurant: Source: @Victor
Lorsque vous sortez au restaurant, vous consultez un menu et vous voyez plusieurs options à choisir. Vous pouvez commander un ou plusieurs des éléments du menu. Mais jusqu'à ce que vous les commandiez, ce ne sont que des "occasions de dîner". Une fois que vous passez la commande et que le serveur l’apporte à votre table, c’est un repas.
Les points de jonction sont des options du menu et les raccourcis sont des éléments que vous sélectionnez.
Un point de jonction est une opportunité dans le code pour vous d'appliquer un aspect ... juste une opportunité. Une fois que vous saisissez cette opportunité, sélectionnez un ou plusieurs points de jonction et appliquez-leur un aspect, vous obtenez un pointcut.
Pour comprendre la différence entre un point de jonction et une coupe de points, considérez les coupes de points comme spécifiant les règles de tissage et les points de jonction comme des situations satisfaisant ces règles.
Dans l'exemple ci-dessous,
@Pointcut("execution(* * getName()")
Pointcut définit les règles en disant que des conseils devraient être appliqués à la méthode getName () présente dans toutes les classes de tous les packages et que joinpoints constituera une liste de toutes les méthodes getName () présentes dans les classes afin que des conseils puissent être appliqués à ces méthodes.
(En cas de Spring, la règle sera appliquée aux beans gérés uniquement et les conseils ne pourront être appliqués qu'aux méthodes publiques).
JoinPoints: Il s’agit essentiellement d’endroits dans la logique métier proprement dite où vous souhaitez insérer des fonctionnalités diverses nécessaires mais ne faisant pas partie de la logique métier proprement dite. Quelques exemples de JoinPints sont: appel de méthode, méthode retournant normalement, méthode levant une exception, instanciation d'un objet, référençant un objet, etc ...
Pointcuts: Les pointcuts ressemblent à des expressions régulières qui servent à identifier des points de jonction. Les pontcuts sont exprimés en "langage d'expression ponctuelle". Les coupes de points sont des points de flux d'exécution où le problème transversal doit être appliqué. Il y a une différence entre Joinpoint et Pointcut; Les points de jonction sont plus généraux et représentent tout flux de contrôle où nous pouvons "choisir" d'introduire un problème transversal, tandis que les découpages ponctuels identifient de tels points de jonction où "nous voulons" introduire un problème transversal.
Explication de Layman pour quelqu'un qui est nouveau dans les concepts AOP. Ce n'est pas exhaustif, mais devrait aider à comprendre les concepts. Si vous connaissez déjà le jargon de base, vous pouvez arrêter de lire maintenant.
Supposons que vous avez un employé de classe normal et que vous voulez faire quelque chose chaque fois que ces méthodes sont appelées.
class Employee{
public String getName(int id){....}
private int getID(String name){...}
}
ces méthodes s'appellent JoinPoints. Nous avons besoin d’un moyen d’identifier ces méthodes afin que le cadre puisse trouver les méthodes, parmi toutes les classes.méthodes qu’il a chargées. Nous allons donc écrire une expression régulière pour correspondre à la signature de ces méthodes. Comme vous le verrez ci-dessous, il y a plus que cela, mais c'est cette expression régulière qui définit vaguement Pointcut. par exemple.
* * mypackage.Employee.get*(*)
Le premier * concerne le modificateur public/privé/protégé/par défaut. Deuxième * est pour le type de retour de la méthode.
Mais vous devez également indiquer deux autres choses:
- When une action doit être entreprise - par exemple, avant/après l'exécution de la méthode OR sur exception
- Quoi devrait-il faire quand ça correspond (peut-être simplement imprimer un message)
La combinaison de ces deux s'appelle Advice.
Comme vous pouvez l’imaginer, il vous faudrait écrire une fonction pour pouvoir exécuter le travail n ° 2. Voilà à quoi cela pourrait ressembler pour les bases.
Remarque: pour plus de clarté, utilisez Word [~ # ~] regex [~ # ~] au lieu de * * mypackage.Employee.get*(*). En réalité, l'expression complète entre dans la définition.
@Before("execution(REGEX)")
public void doBeforeLogging() {....} <-- executed before the matching-method is called
@After("execution(REGEX)")
public void doAfterLogging() {....} <-- executed after the matching-method is called
Une fois que vous aurez commencé à les utiliser assez souvent, vous devrez peut-être spécifier de nombreux conseils @ Après/@ Avant/@ Autour. Les expressions régulières répétées finiront par rendre les choses confuses et difficiles à maintenir. Donc, ce que nous faisons, nous donnons simplement un nom à l’expression et l’utilisons partout ailleurs dans la classe Aspect.
@Pointcut("execution(REGEX)") <-- Note the introduction of Pointcut keyword
public void allGetterLogging(){} <-- This is usually empty
@Before("allGetterLogging")
public void doBeforeLogging() {....}
@After("allGetterLogging")
public void doAfterLogging() {....}
BTW, vous voudriez aussi envelopper toute cette logique dans une classe, qui s'appelle Aspect et vous écririez une classe:
@Aspect
public class MyAwesomeAspect{....}
Pour que toutes ces choses fonctionnent, vous devez dire à Spring d'analyser les classes pour lire, comprendre et agir sur les mots clés @AOP. Une façon de le faire est de spécifier ce qui suit dans le fichier XML print config:
<aop:aspectj-autoproxy>
En comparant un langage AOP tel que AspectJ à un langage de requête de données tel que SQL, vous pouvez concevoir des points de jonction (c'est-à-dire tous les emplacements de votre code où vous pouvez tisser du code d'aspect) comme une table de base de données comportant plusieurs lignes. Un pointcut est comme un stamement SELECT qui peut choisir un sous-ensemble de lignes/points de jointure défini par l'utilisateur. Le code que vous intégrez à ces endroits sélectionnés est appelé conseil.
Les deux concernent le "où" de la programmation orientée aspect.
Un point de jointure est un endroit individuel où vous pouvez exécuter du code avec AOP. Par exemple. "quand une méthode lève une exception".
Un pointcut est une collection de points de jointure. Par exemple. "quand une méthode de la classe Foo lève une exception".
Définitions
Selon la documentation:
Joint à un point: un point lors de l'exécution d'un programme, tel que l'exécution d'une méthode ou le traitement d'une exception.
Vous pouvez considérer les points communs comme des événements en cours d'exécution d'un programme. Si vous utilisez Spring AOP, cela se limite même à l'invocation de méthodes. AspectJ offre plus de flexibilité.
Mais vous ne gérez jamais tous les événements car vous ne mangez pas toute la nourriture du menu lorsque vous allez au restaurant (je ne vous connais pas, vous pourriez! Mais ce n'est certainement pas le cas). Vous faites donc une sélection d’événements à gérer et de quoi faire avec. Voici Pointcuts . Selon la documentation,
Pointcut : un prédicat qui correspond à joindre des points.
Ensuite, vous associez quoi faire avec le Pointcut , voilà le conseil . Selon la documentation,
Un conseil est associé à un pointcut expression et s’exécute à n’importe quel point de jointure correspondant au pointcut.
Code
package com.amanu.example;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
* @author Amanuel Nega on 10/25/16.
*/
class ExampleBussinessClass {
public Object doYourBusiness() {
return new Object();
}
}
@Aspect
class SomeAspect {
@Pointcut("execution(* com.amanu.example.ExampleBussinessClass.doYourBusiness())")
public void somePointCut() {
}//Empty body suffices
@After("somePointCut()")
public void afterSomePointCut() {
//Do what you want to do before the joint point is executed
}
@Before("execution(* *(*))")
public void beforeSomePointCut() {
//Do what you want to do before the joint point is executed
}
}
Explication du code
ExampleBusinessClassquand proxy-ed, est notre cible!doYourBusiness()est un point conjoint possibleSomeAspectest notre aspect qui recoupe de multiples préoccupations telles que le culExampleBusinessClasssomePointCut()est une définition d'un point coupé qui correspond à notre point communafterSomePointCut()est un conseil qui sera exécuté après notre pointsomePointCutcouper qui correspond àdoYourBusiness()point communbeforeSomePointCut()est également un conseil qui correspond à toutes les exécutions de méthodespublic. Contrairement àafterSomePointCut, celui-ci utilise une déclaration de coupe de point en ligne
Vous pouvez regarder le documentation si vous ne me croyez pas. J'espère que ça aide
JoinPoint: Les points de jonction sont des points de l'exécution de votre programme dans lesquels le flux d'exécution a été modifié comme pour intercepter une exception, appeler une autre méthode.
PointCut: Les PointCut sont essentiellement des points de jonction pour lesquels vous pouvez mettre vos conseils (ou aspect de l’appel).
Donc, fondamentalement, les PointCuts sont le sous-ensemble de JoinPoints.
Un point de coupe est défini sur l'implémentation Aspect-class. Le point coupé renvoie essentiellement à l'expression du point coupé dans le conseil.
Pour, par exemple,
@Before("execution(* app.purchase2.service.impl.*(..))")
public void includeAddOns(RolesAllowed roles) {
..
}
La méthode ci-dessus, "includeAddOns", est appelée avant d'appeler (en raison du conseil @Before) les méthodes (dans les classes du package "app.purchase2.service.impl")
L'annotation entière est appelée le pointcut @Before("execution(* app.purchase2.service.impl.*(..))")
Joint point est l'appel de méthode proprement dit, qui a joint la méthode du package "app.purchase2.service.impl" à la méthode de la classe d'aspect "includeAddOns ()".
Vous pouvez accéder aux propriétés du point de jonction avec la classe org.aspectj.lang.JoinPoint.
Je suis d’accord avec les progrès .. Une coupe de points peut être considérée comme un ensemble de points communs. Joint point spécifie le lieu particulier où l'avis peut être mis en œuvre, où point correspond à la liste de tous les points communs.
AOP au printemps a {Advisor, Advice, Pointcut, Joinpoint}
Comme vous le savez, l'objectif principal de aop est de dissocier la logique de préoccupation transversale (Aspect) du code de l'application. Pour l'implémenter au printemps, nous utilisons (Advice/Advisor).
Pointcut est utilisé pour filtrer exactement où nous voulons appliquer ce conseil, comme "toutes les méthodes commencent par insert", ainsi d'autres méthodes seront exclues, c'est pourquoi nous en avons dans l'interface de Pointcut {ClassFilter and MethodMatcher}
Donc Advice est la mise en œuvre de la logique transversale et Advisor est le conseil ainsi que PointCut. Si vous utilisez uniquement Conseil, Spring le mappera sur le conseiller et rendra le pointcut TRUE, ce qui signifie que rien ne bloque. C'est pourquoi, lorsque vous n'utilisez que des conseils, ceux-ci sont appliqués à toutes les méthodes de la classe cible, car vous ne les avez pas filtrés.
Mais Joinpoint est un emplacement dans le programme, vous pouvez le penser comme un reflet lorsque vous accédez à l’objet Class, puis vous pouvez obtenir un objet Method, vous pouvez ensuite appeler n’importe quelle méthode de cette classe, et c’est ainsi que le compilateur fonctionne, si vous pensez comme ceci vous pouvez imaginer le Joinpoint.
Joinpoint peut être avec un champ, un constructeur ou une méthode, mais dans Spring, nous avons jointpoint avec des méthodes uniquement. C’est pourquoi nous avons des types (avant, après, lève, autour de) (avant, après, jets, autour) qui font tous référence aux emplacements de la classe.
Comme je l'ai mentionné, vous pouvez obtenir des conseils sans point (filtre), ils seront alors appliqués à toutes les méthodes ou vous pouvez avoir un conseiller qui est [conseil + point] qui sera appliqué à des méthodes spécifiques, mais vous ne pouvez pas obtenir des conseils sans joinpoint comme pointcut, vous devez le spécifier, et c’est pourquoi les types de conseils printaniers sont exactement les mêmes que ceux du point de jonction. Ainsi, lorsque vous choisissez un conseil, vous choisissez implicitement quel point de jonction.
Pour conclure, advice est la logique d'implémentation de votre aspect pour la classe cible. Cet avis doit avoir un point de jointure comme avant invocation, après invocation, après lancement ou autour d'une invocation, vous pouvez alors filtrer exactement où vous souhaitez l'appliquer à l'aide de pointcut to filtrer les méthodes ou pas de pointcut (pas de filtre) donc il sera appliqué à toutes les méthodes de la classe.