Joinpoint VS ProceedingJoinPoint w AOP przy użyciu aspectJ?

Question

Czy ktoś może mi powiedzieć, jaka jest różnica między Joinpoint a Proceedingjoinpoint?

Kiedy stosować Joinpoint i Proceedingjoinpoint w metodzie aspektu?

użyłem JoinPoint w moim AspectJ class jak,

@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("************************"); 
} 

Ale niektórzy, co widzę w innych zasobów jest

@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(); 
    } 
} 

Tutaj co ProceedingJoinPoint zrobi specjalny porównać do „JointPoint`?

Co nam zrobi pjp.proceed()?

Answer 1

@Around("execution(* com.mumz.test.spring.aop.BookShelf.addBook(..))") 

Oznacza to przed wywołaniem metody aroundAddAdvicecom.mumz.test.spring.aop.BookShelf.addBook wywoływana jest metoda. Po zakończeniu operacji System.out.println("Book being added is : " + object);. zadzwoni on do twojej aktualnej metody addBook(). pjp.proceed() będzie wywoływać metodę addBook().

Answer 2

Porada dotycząca otoczenia to specjalna rada, która może kontrolować, kiedy i czy metoda (lub inny punkt połączenia) jest wykonywana. Dotyczy to tylko wskazówek, więc wymagają one argumentu typu ProceedingJoinPoint, podczas gdy inne porady używają zwykłego JoinPoint. Przypadek użycia próbka jest buforowanie wartości powrotu:

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; 
    } 
} 

W tym kodzie (za pomocą nieistniejącego technologii pamięci podręcznej, aby zilustrować punkt) rzeczywista metoda jest wywoływana tylko wtedy, gdy pamięć podręczna nie zwraca wynik. Dokładnie tak działa projekt Spring EHCache Annotations.

Inną specjalnością dotyczącą porad jest to, że muszą mieć wartość zwracaną, podczas gdy inne typy porad nie mogą mieć takiej wartości.