web-dev-qa-db-fra.com

Joinpoint VS ProceedingJoinPoint dans AOP en utilisant aspectJ?

Quelqu'un peut-il me dire quelle est la différence entre Joinpoint et Proceedingjoinpoint?

Quand utiliser Joinpoint et Proceedingjoinpoint dans la méthode de classe d'aspect?

J'ai utilisé le JoinPoint dans ma classe AspectJ comme:

@Pointcut("execution(* com.pointel.aop.test1.AopTest.beforeAspect(..))")  
public void adviceChild(){}  

@Before("adviceChild()")  
public void beforeAdvicing(JoinPoint joinPoint /*,ProceedingJoinPoint pjp - used refer book marks of AOP*/){ 

    //Used to get the parameters of the method !
    Object[] arguments = joinPoint.getArgs();
    for (Object object : arguments) {
        System.out.println("List of parameters : " + object);
    }

    System.out.println("Method name : " + joinPoint.getSignature().getName());
    log.info("beforeAdvicing...........****************...........");
    log.info("Method name : " + joinPoint.getSignature().getName());
    System.out.println("************************"); 
}

Mais ce que je vois dans d'autres ressources est:

@Around("execution(* com.mumz.test.spring.aop.BookShelf.addBook(..))")
public void aroundAddAdvice(ProceedingJoinPoint pjp){
    Object[] arguments = pjp.getArgs();
    for (Object object : arguments) {
        System.out.println("Book being added is : " + object);
    }
    try {
        pjp.proceed();
    } catch (Throwable e) {
        e.printStackTrace();
    }
}

Voici ce que ProceedingJoinPoint fera différemment par rapport à 'JointPoint? Also what willpjp.proceed () `faire pour nous?

javaspringaspectjspring-aop
18
Human Being
@Around("execution(* com.mumz.test.spring.aop.BookShelf.addBook(..))")

Cela signifie avant d'appeler la méthode com.mumz.test.spring.aop.BookShelf.addBook La méthode aroundAddAdvice est appelée. Une fois l'opération System.out.println("Book being added is : " + object); terminée. il appellera votre méthode actuelle addBook(). pjp.proceed() appellera la méthode addBook().

9
abishkar bhattarai

Un conseil autour est un conseil spécial qui peut contrôler quand et si une méthode (ou un autre point de jointure) est exécutée. Cela est vrai uniquement pour les conseils autour, donc ils nécessitent un argument de type ProceedingJoinPoint, tandis que d'autres conseils utilisent simplement un simple JoinPoint. Un exemple de cas d'utilisation consiste à mettre en cache les valeurs de retour:

private SomeCache cache;

@Around("some.signature.pattern.*(*)")
public Object cacheMethodReturn(ProceedingJoinPoint pjp){
    Object cached = cache.get(pjp.getArgs());
    if(cached != null) return cached; // method is never executed at all
    else{
        Object result = pjp.proceed();
        cache.put(pjp.getArgs(), result);
        return result;
    }
}

Dans ce code (utilisant une technologie de cache inexistante pour illustrer un point), la méthode réelle n'est appelée que si le cache ne renvoie pas de résultat. C'est exactement ainsi que fonctionne le projet Spring EHCache Annotations , par exemple.

Une autre spécialité des conseils autour est qu'ils doivent avoir une valeur de retour, tandis que les autres types de conseils ne doivent pas en avoir.

25
Sean Patrick Floyd