Spring (Java): Aspekt wird nicht in nichtlinearer Klassenhierarchie ausgelöst

Question

Wenn die Klassenhierarchie nicht linear ist, wird Aspekt nicht ausgelöst, wenn sie auf der Basisschnittstelle definiert ist.

Am interessantesten: Wenn Sie delegierende Implementierung (siehe letzten Codeblock) zur übergeordneten Klasse der Implementierung hinzufügen, wird der Test grün (Aspekt wird wie erwartet ausgelöst).

Frage: Warum funktioniert es nicht wie im Beispiel beschrieben und warum funktioniert es mit der delegierenden Implementierung?

Beispiel (sorry, nicht kürzer Beispiel gefunden):

Test:

@Autowired 
private TheInterface underTest; 
private static boolean aspectCalled; 
private static boolean implementationCalled; 

@Test 
public void aspectTest() throws Exception { 
    aspectCalled = false; 
    implementationCalled = false; 

    underTest.doSomething(); 

    assertTrue("Implementation not called!", implementationCalled); 
    assertTrue("Aspect not called!", aspectCalled); 
} 

Richtung:

@Aspect 
@Component 
public static class MyAspect { 

    @Before("execution(* *..SpecializedInterface+.doSomething())") 
    public void applyAspect() { 
     aspectCalled = true; 
    } 
} 

Schnittstellen:

Zusammenfassung i mplementations (Template-Muster):

public static abstract class BaseTemplate implements TheInterface { 
    abstract void doOneStep(); 

    @Override 
    public void doSomething() { 
     // do some stuff and 
     doOneStep(); 
    } 
} 

public static abstract class SpecializedTemplate extends BaseTemplate implements SpecializedInterface { 
    // some other methods 
} 

Implementierung Bohne:

@Component 
public static class TemplateImplementation extends SpecializedTemplate { 
    @Override 
    void doOneStep() { 
     implementationCalled = true; 
    } 
} 

(Wenn Sie interessiert sind: Testaufbau :)

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration(classes = MyConfig.class) 
public class AopTest { 
    @Configuration 
    @EnableAspectJAutoProxy 
    @ComponentScan(basePackageClasses = AopTest.class) 
    public static class MyConfig { 
    } 
    ... 

hässliche Lösung: Fügen Sie diese Schnipsel SpecializedTemplate

@Override 
    public void doSomething() { 
     super.doSomething(); 
    } 

Warum ist diese Problemumgehung erforderlich?

Answer 1

Thomas Stets hat bereits erklärt, den Bytecode und JVM stuff, so dass ich nur eine Lösung für Ihr Problem, siehe auch meine answer auf eine sehr ähnliche Frage.

@Aspect 
public static class MyAspect { 
    @Before("execution(* *..TheInterface+.doSomething()) && target(specializedInterface)") 
    public void applyAspect(SpecializedInterface specializedInterface) { 
     aspectCalled = true; 
    } 
} 

I.e. Ihr Pointcut richtet sich an die Basisschnittstelle, die die Methode definiert, und Sie beschränken das Ziel auf die spezialisierte Subschnittstelle Ihrer Wahl. Dies sollte Ihren Test grün machen.