Joinpoint VS ProceedingJoinPoint trong AOP sử dụng aspectJ?

Question

Bất kỳ ai có thể cho tôi biết sự khác nhau giữa Joinpoint và Proceedingjoinpoint là gì?

Khi nào sử dụng Joinpoint và Proceedingjoinpoint trong phương pháp của lớp khía cạnh?

tôi đã sử dụng JoinPoint trong tôi AspectJ class như,

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

Nhưng một số những gì tôi nhìn thấy trong các nguồn lực khác là,

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

đây những gì ProceedingJoinPoint sẽ làm đặc biệt so sánh với 'JointPoint`?

Ngoài ra, những gì pjp.proceed() sẽ làm gì cho chúng tôi?

Answer 1

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

Có nghĩa là trước khi gọi com.mumz.test.spring.aop.BookShelf.addBook phương thức aroundAddAdvice được gọi. Sau khi hoàn tất thao tác System.out.println("Book being added is : " + object);. nó sẽ gọi phương thức thực tế của bạn addBook(). pjp.proceed() sẽ gọi phương thức addBook().

Answer 2

Lời khuyên xung quanh là lời khuyên đặc biệt có thể kiểm soát khi nào và nếu một phương pháp (hoặc điểm nối khác) được thực thi. Điều này đúng với các lời khuyên xung quanh chỉ, vì vậy họ yêu cầu một đối số của loại ProceedingJoinPoint, trong khi các lời khuyên khác chỉ sử dụng một đồng bằng JoinPoint. Một trường hợp sử dụng mẫu là để cache giá trị trả về:

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

Trong mã này (sử dụng một công nghệ bộ nhớ cache không tồn tại để minh họa cho một điểm) phương pháp thực tế duy nhất được gọi là nếu bộ nhớ cache không trả lại kết quả. Đây là cách chính xác ví dụ như dự án Spring EHCache Annotations.

Một đặc điểm khác của xung quanh lời khuyên là chúng phải có giá trị trả lại, trong khi các loại lời khuyên khác không được có.