Spring (Java): l'aspetto non viene attivato nella gerarchia di classi non lineari

Question

Quando la gerarchia di classi non è lineare, l'aspetto non viene attivato quando definito sull'interfaccia di base.

Il più interessante: quando si aggiunge l'implementazione delegante (vedere l'ultimo blocco di codice) alla classe padre dell'implementazione, il test diventa Verde (l'Aspetto viene attivato come previsto).

Domanda: Perché non funziona come descritto nell'esempio e perché funziona con la delega dell'implementazione?

Esempio (mi dispiace, ad esempio non inferiore trovato):

prova:

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

Aspetto:

@Aspect 
@Component 
public static class MyAspect { 

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

Interfacce:

Abstract I mplementations (modello Template):

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 
} 

fagioli Implementazione:

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

(Se siete interessati: configurazione di prova :)

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

soluzione Ugly: Aggiungi questo frammento di SpecializedTemplate

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

Quindi, perché questa soluzione alternativa è necessaria?

Answer 1

Thomas Stets ha già spiegato il bytecode e roba JVM, quindi mi limiterò a fornire una soluzione al vostro problema, si veda anche il mio answer ad una domanda molto simile.

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

I.e. il tuo punto di accesso si rivolge all'interfaccia di base che definisce effettivamente il metodo, quindi limiti la destinazione alla sub-interfaccia specializzata di tua scelta. Questo dovrebbe rendere il tuo test verde.