Spring AOP coupe transverse (pointcut) pour annoté argument

Dire que j'ai une méthode comme suit:

public void method(@CustomAnnotation("value") String argument)

Est-il une coupe transverse (pointcut) expression qui pourrait sélectionnez toutes les méthodes avec des arguments annotée avec @CustomAnnotation? Si oui, est-il une manière que je pourrais avoir accès aller à la "valeur" de l'argument?

OriginalL'auteur mogronalol | 2012-04-20

15

Sur la sélection de vos arguments :
```
@Before("execution(* *(@CustomAnnotation (*)))")
public void advice() {
System.out.println("hello");
}
```
ref : http://forum.springsource.org/archive/index.php/t-61308.html

Sur l'obtention de l'annotation param :
```
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
Annotation[][] methodAnnotations = method.getParameterAnnotations();
```
Vous obtiendrez les annotations que vous pouvez parcourir et utiliser instanceof pour trouver votre tenue d'annotation. Je sais que c'est hacky mais autant que je sache, c'est la seule façon pris en charge actuellement.

Vous avez besoin d'ajouter un espace après l'annotation, c'est à dire @CustomAnnotation (*)

OriginalL'auteur MikePatel
1

À partir du Printemps Docs:
```
@Before("@annotation(myAnnotation)")
public void audit(Auditable myAnnotation) {
  AuditCode code = auditable.value();
  //...
}
```
Qui fonctionne bien pour moi, sans aucun besoin de manipuler la signature de la méthode.

Remarque: Si vous utilisez un nom de coupe transverse (pointcut), parce que la coupe transverse (pointcut) les noms peuvent être surchargés, vous devez fournir correspondance (nom du paramètre et de l'ordre) des signatures.
```
@Before("goodAdvise(myAnnotation)")
public void audit(Auditable myAnnotation) {
  String value = auditable.value();
  //...
}

@Pointcut("@annotation(myAnnotation)")
public void goodAdvise(Auditable myAnnotation) { 
  //empty
}
```
Le @annotation coupe transverse (pointcut) se réfère à des annotations sur la méthode, et non sur les paramètres.

OriginalL'auteur Joseph Lust
1

Si vous avez plus d'un paramètre dans la méthode que vous devez utiliser également deux points pour mathing le nombre de paramètres (zéro ou plus)
```
@Before("execution(* *(@CustomAnnotation (*), ..))")
public void advice() {
    System.out.println("hello");
}
```
OriginalL'auteur Przemek Grondek

Juste pour compléter la dernière réponse:

@Before(value="execution(* *(@CustomAnnotation (*), ..)) && args(input, ..)")
public void inspect(JoinPoint jp, Object input) {
        LOGGER.info(">>> inspecting "+input+" on "+jp.getTarget()+", "+jp.getSignature());
}

va correspondre à une méthode où l'une de l'argument de la méthode est annoté avec @CustomAnnotation, par exemple:

service.doJob(@CustomAnnotation Pojo arg0, String arg1);

Contrairement à

@Before(value="execution(* *(@CustomAnnotation *, ..)) && args(input, ..)")
public void inspect(JoinPoint jp, Object input) {
            LOGGER.info(">>> inspecting "+input+" on "+jp.getTarget()+", "+jp.getSignature());
    }

qui va correspondre à des méthodes où l'une de l'argument a l'annotation @CustomAnnotation, par exemple:

service.doJob(AnnotatedPojo arg0, String arg1);

où le pojo est déclarée comme suit:

@CustomAnnotation
public class AnnotatedPojo {
}

Toute la différence réside dans le @CustomAnnotation (*) vs @CustomAnnotation * dans la coupe transverse (pointcut) de la déclaration.

OriginalL'auteur Mahieddine M. Ichir

Pour correspondre à 1..N annoté arguments quelle que soit leur position utilisation

@Before("execution(* *(@CustomAnnotation (*), ..)) || " +
        "execution(* *(.., @CustomAnnotation (*), ..)) || " +                         
        "execution(* *(.., @CustomAnnotation (*)))")
public void advice(int arg1, @CustomAnnotation("val") Object arg2) { ... }

OriginalL'auteur Dan Macák

Vous devez vous connecter pour publier un commentaire.