2012-08-12 4 views
10

Da Spring Documentation:bersaglio Spring AOP() vs presente()

this(com.xyz.service.AccountService) 
  • :

    • qualsiasi punto (esecuzione metodo solo in Spring AOP) se il proxy implementa l'interfaccia AccountService join qualsiasi join punto (metodo di esecuzione solo in Spring AOP) dove l'oggetto bersaglio implementa l'interfaccia AccountService:

      target(com.xyz.service.AccountService) 
      

    Non capisco cosa significhi "oggetto target" e l'espressione target(...).

    In che modo target è diverso da this?

  • risposta

    17

    this(AType) significa tutti i punti di unione in cui this instanceof AType è vero. Quindi questo significa che nel tuo caso una volta che la chiamata raggiunge qualsiasi metodo di AccountService this instanceof AccountService sarà vero.

    target(AType) significa che tutti si uniscono i punti dove anObject instanceof AType. Se si chiama un metodo su un oggetto e tale oggetto è un'istanza di AccountService, questo sarà un joinpoint valido.

    Per riepilogare un modo diverso - this(AType) proviene da una prospettiva di destinatari e target(AType) è dal punto di vista del chiamante.

    +0

    Se ottengo il tasto destro ... sia '' this' e target' fanno la stessa cosa ??? Una volta che il mio codice tenta di eseguire un metodo di 'AccountService', quindi dal punto di vista del ricevitore,' questa istanza di AccountService' è vera; e dal punto di vista del chiamante 'calledObject instanceof AccountService' è anche vero. Allora, perché questa ridondanza? – rapt

    +0

    È importante in AspectJ ma hai ragione non tanto in Spring AOP - perché 'call' (tipicamente usato con target) intaccherà il chiamante, mentre' execution' (insieme a questo) tesserà la classe stessa. Questo è importante poiché con qualcosa come la tessitura in tempo di compilazione potresti non avere accesso a classi terze per tessere usando l'esecuzione, puoi quindi intrecciare le chiamate alle librerie di terze parti. –

    +0

    Grazie per la spiegazione. – rapt

    9

    So che questo è un vecchio post ma ho appena trovato un'importante differenza tra questo e il target mentre non utilizzo AspectJ.

    Si consideri il seguente aspetto introduzione:

    @Aspect 
    public class IntroductionsAspect { 
    
        @DeclareParents(value="a.b.c.D", defaultImpl=XImpl.class) 
        public static X x; 
    
        @After("execution(* a.b.c.D.*(..)) && this(traceable)") 
        public void x(Traceable traceable) { 
         traceable.increment(); 
        } 
    
    } 
    

    In poche parole, questo aspetto sta facendo due cose:

    1. Rendere la classe a.b.c.D implementare l'interfaccia X.
    2. aggiungere una chiamata a traceable.increment() che deve essere eseguito prima di ogni metodo di a.b.c.D.

    La parte importante è "execution(* a.b.c.D.*(..)) && this(traceable)". Si noti che ho utilizzato questo, non target.

    Se si utilizza bersaglio invece, si sta cercando di abbinare la classe originale a.b.c.D, non l'interfaccia introdotta X. Quindi Spring AOP non troverà alcun punto di unione in a.b.c.D.

    In sintesi:

    questo - controlla il tipo di proxy, o il tipo introdotto. target - Controlla il tipo dichiarato.

    +0

    buon punto, grazie –