préoccupations Crosscut au milieu des méthodes

Question

il est commode pour AOP (par exemple AspectJ, SpringAOP) pour traiter (conseiller) préoccupations incisée à pointcuts autour des méthodes ci-dessous,

code "sandwich"

methodA { 
    crosscut code 
    user code A 
    crosscut code 
} 

methodB { 
    crosscut code 
    user code B 
    crosscut code 
} 

Est AOP apte à recouper les préoccupations chevauchées au code utilisateur ci-dessous? Comment?

Code

methodX { 
    user code x1 
    crosscut code 

    user code x2 
    crosscut code 
} 

methodY { 

    user code y1 
    crosscut code 

    user code y2 
    crosscut code 
} 

"Spaghetti" Merci!

Answer 1

Spring AOP ne sera pas utile, car elle ne comprend que l'exécution pointcut().

AspectJ comprend beaucoup plus pointcuts, y compris le withincode() construire, qui ressemble à ce que vous voulez:

withincode(* YourClass.methodX(. .)) 

cela vous permet de conseiller tous les points de jonction dans une méthode donnée exection

Lire AspectJ in Action Pour plus d'informations, c'est un très bon livre sur AspectJ et Spring AOP.

---

EDIT:

ici est un exemple de code:

package com.dummy.aspectj; 

import java.util.Arrays; 
import java.util.Collections; 

public class DummyClass{ 

    public static void main(final String[] args){ 
     System.out.println(Arrays.asList("One", Collections.singleton("Two"))); 
     System.out.println("Enough?"); 
    } 

} 

package com.dummy.aspectj; 

import java.util.Arrays; 

public aspect DummyAspect{ 

    pointcut callWithinMain() : 
     withincode(* com.dummy.aspectj.DummyClass.main(..)) // anything inside DummyClass.main 
     && call(* *.*(..));         // but only method calls 

    before() : callWithinMain() { 
     System.out.println("\n***************************************************"); 
     System.out.println("** Calling:\n**\t" 
      + thisJoinPointStaticPart.getSignature() 
      + "\n** with arguments:\n**\t " 
      + Arrays.deepToString(thisJoinPoint.getArgs())); 
     System.out.println("***************************************************\n"); 
    } 

} 

exécutant le DummyClass d'Eclipse/AJDT génère cette sortie:

*************************************************** 
** Calling: 
** Set java.util.Collections.singleton(Object) 
** with arguments: 
** [Two] 
*************************************************** 


*************************************************** 
** Calling: 
** List java.util.Arrays.asList(Object[]) 
** with arguments: 
** [[One, [Two]]] 
*************************************************** 


*************************************************** 
** Calling: 
** void java.io.PrintStream.println(Object) 
** with arguments: 
** [[One, [Two]]] 
*************************************************** 

[One, [Two]] 

*************************************************** 
** Calling: 
** void java.io.PrintStream.println(String) 
** with arguments: 
** [Enough?] 
*************************************************** 

Enough? 

Answer 2

Bien que certaines implémentations AOP puissent vous permettre de faire cela, cela pourrait indiquer la nécessité de refactoriser ces méthodes en méthodes plus composées car elles pourraient en faire trop si l'on a besoin de transcender les préoccupations au milieu des méthodes . Cela vous donnerait ceci:

methodX 
{ 
    usercodemethod1(); 
    usercodemethod2(); 
} 

usercodemethod1 
{ 
    user code x1 
    crosscut code 
} 

usercodemethod2 
{ 
    user code x2 
    crosscut code 
}