Spring AOP cible () - ()

De Le Printemps De La Documentation:

toute jointure point (méthode d'exécution seulement au Printemps AOP) où le proxy
met en œuvre la AccountService interface:
```
this(com.xyz.service.AccountService)
```
toute jointure point (méthode d'exécution seulement au Printemps AOP) où la cible
objet implémente l'AccountService interface:
```
target(com.xyz.service.AccountService)
```

Je ne comprends pas ce que "objet cible" et l'expression target(...) veux dire.

Comment est target différente de this?

OriginalL'auteur rapt | 2012-08-12

spring spring-aop

20

this(AType) moyens de rejoindre tous les points où this instanceof AType est vrai. Cela signifie donc que dans votre cas, une fois l'appel atteint une méthode de AccountService this instanceof AccountService sera vrai.

target(AType) moyens de rejoindre tous les points où anObject instanceof AType . Si vous êtes à l'appel d'une méthode sur un objet et que cet objet est un instanceof AccountService, qui sera valide joinpoint.

De résumer d'une manière différente - this(AType) est à partir d'un point de vue des récepteurs, et target(AType) est à partir d'un point de vue des appelants.

Si je vous obtenir le droit... à la fois this et target faire la même chose??? Une fois mon code tente d'exécuter une méthode de AccountService, puis à partir du récepteur point de vue, this instanceof AccountService est vrai; et à partir de l'appelant point de vue calledObject instanceof AccountService est également vrai. Alors pourquoi est-ce la redondance?
Il importe dans AspectJ, mais vous êtes en droit de ne pas beaucoup plus que dans le Printemps de l'AOP - parce que call(généralement utilisé avec cible) armure de l'appelant, alors que execution(avec) se propose de tisser la classe elle-même. Ceci est important, car avec quelque chose comme de la compilation de tissage vous ne pouvez pas avoir accès à la troisième partie de la classe d'armure à l'aide d'exécution, vous pouvez ensuite tisser les appels à des bibliothèques tierces.
Merci pour l'explication.

OriginalL'auteur Biju Kunjummen
10

Je sais que c'est un vieux post mais je viens de tomber sur une différence importante entre le présent et l'objectif lorsque vous n'utilisez pas AspectJ.

Envisager la suite de l'introduction d'aspect:
```
@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();
    }

}
```
Tout simplement, cet aspect est en train de faire deux choses:
1. Faire la a.b.c.D classe de mettre en œuvre la X interface.
2. Ajout d'un appel à traceable.increment() à être exécuté avant chaque méthode de a.b.c.D.
L'important, c'est "execution(* a.b.c.D.*(..)) && this(traceable)". Remarquez que j'ai utilisé ce, pas cible.

Si vous utilisez cible au lieu de cela, vous essayez de correspondre à la classe d'origine a.b.c.D, pas l'interface X. Donc, Spring AOP ne trouverez pas de rejoindre le point de a.b.c.D.

En résumé:

ce - Vérifie le type de proxy, ou introduit type.
cible - Vérifie le type déclaré.

bon point, merci

OriginalL'auteur Akira
5

À partir de la documentation officielle:

Spring AOP est un proxy basé sur le système et établit une distinction entre le proxy de l'objet lui-même (liée à "il") et l'objet cible derrière le proxy (lié à la "cible").

http://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html#aop-pointcuts-designators

OriginalL'auteur hoodieman

Vous devez vous connecter pour publier un commentaire.