Discussion :

[Mobius]

Bonjour,

J'utilise AspectJ pour créer des apsects.
Dans l'un des aspects, je voudrais avoir accès à l'objet de type Method correspondant à la méthode sur laquelle s'applique l'aspect.

Est ce que vous avez une idée ? Avez vous déjà fait ca ?

Merci d'avance

[Invité]

Salut,

Essaie de regarder du côté de thisJoinPoint : http://www.eclipse.org/aspectj/doc/r...JoinPoint.html et la méthode getSignature
je pense que ça devrait t'aider .

A plus

[Mobius]

Essaie de regarder du côté de thisJoinPoint : http://www.eclipse.org/aspectj/doc/r...JoinPoint.html et la méthode getSignature

C'est déjà fait

je pense que ça devrait t'aider .

Justement non !
La méthode getSignature donne un objet de type Signature et cet objet permet uniquement de récupérer le nom de la méthode et non pas l'objet de type Method.
Du coup, on est obligé de chercher a la main la méthode ayant le bon nom.
Plusieurs problème à cette solution :
- C'est pas trivial à écrire (mais c'est pas le plus génant)
- C'est encore moins trivial si plusieurs méthode ont le même nom avec des paramètres différents.
- Ce n'est certainement pas ce qu'il y a de plus efficace.

J'ai déjà implémenté cette solution (même si elle ne me satisfait pas complètement) mais j'ai peur que ca soit la seul solution. En attendant mieux je me contenterai de ça.

Pour ceux que ca interesse voici le code permettant de recherche l'objet Method quand on a son nom (A noter que la vérification de la signature n'est pas satisfaisante ici):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
   private Method getMethod(Class<?> classe, String nomMethode, Object[] parametres)
   {
      Method resultat = null;
      Method[] methodes = null;
      Class<?>[] parameterTypes = null;
      Method methode = null;
      if (classe != null)
      {
         methodes = classe.getDeclaredMethods();
         // On recherche une méthode compatible dans la liste des méthodes de la classe
         for (int n = 0; (n < methodes.length) && (resultat == null); n++)
         {
            methode = methodes[n];
            // Est ce que la méthode a le meme nom et le meme nombre de parametres ?
            if ((methode.getName().equals(nomMethode)) && (parametres.length == methode.getParameterTypes().length))
            {
               resultat = methode;
               parameterTypes = methode.getParameterTypes();
               // On vérifie que chaque paramètres à un type compatible avec ceux de la méthode
               for (int i = 0; (i < parametres.length) && (resultat != null); i++)
               {
                  if ((!parameterTypes[i].isPrimitive()) && (parametres[i] != null) && (!parameterTypes[i].isInstance(parametres[i])))
                  {
                     // Le type n'est pas compatible, ce n'est donc pas la bonne méthode
                     resultat = null;
                  }
               }
            }
         }
         if (resultat == null)
         {
            // On n'a pas trouvé de méthode, on la cherche dans la classe parente
            resultat = getMethod(classe.getSuperclass(), nomMethode, parametres);
         }
      }
      return resultat;
   }

[Invité]

Hum...
Etant donné que la liste des paramètres est retournée par la méthode getParameterTypes, tu ne devrais pas avoir de problème pour définir quelle méthode exactement est appelée, car c'est le compilo qui l'a déjà fait... Je pense donc qu'un simple getMethod avec le nom et la liste retournée devrait marcher, j'ai tenté avec ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
package test.aspectj;
 
import java.lang.reflect.Method;
 
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.MethodSignature;
 
public aspect TestLog {
 
	before(): call(* TestMain.*(..)) {
		Signature sig = thisJoinPoint.getSignature();
		if (sig instanceof MethodSignature) {
                        // en théorie le test es inutile, mais bon....
			System.out.println("Method called: " + thisJoinPoint);
			MethodSignature msig = (MethodSignature) sig;
			Class<?> declType = msig.getDeclaringType();
			String name = msig.getName();
			Class<?>[] params = msig.getParameterTypes();
			try {
				Method meth = declType.getMethod(name, params);
				System.out.println("Method found: " + meth);
			} catch (Exception e) {
				e.printStackTrace();
				System.exit(1);
			}
		}
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
package test.aspectj;
 
public class TestMain {
 
    public static void main(String[] args) {
	TestMain tm = new TestMain();
	tm.m1();
	String s = "t";
	Number n = new Integer(1);
	Integer i = new Integer(2);
	tm.m2(s, n);
	tm.m2(s, i);
    }
 
    public void m1() {
 
    }
 
    public void m2(String s, Number n) {
 
    }
 
    public void m2(String s, Integer i) {
 
    }
 
}

Le résultat est :

Method called: call(void test.aspectj.TestMain.m1())
Method found: public void test.aspectj.TestMain.m1()
Method called: call(void test.aspectj.TestMain.m2(String, Number))
Method found: public void test.aspectj.TestMain.m2(java.lang.String,java.lang.Number)
Method called: call(void test.aspectj.TestMain.m2(String, Integer))
Method found: public void test.aspectj.TestMain.m2(java.lang.String,java.lang.Integer)

[Mobius]

Je n'avais pas connaissance de l'interface MethodeSignature

Du coup, j'ai fait un peu compliqué pour pas grand chose...

Avec cette interface, j'ai directement accès à getMethod() qui me donne directement ce que je veux.

Merci beaucoup.