Problème de déclaration d'un pointcut

Version imprimable

17/08/2009, 14h04
Baptiste Wicht

Problème de déclaration d'un pointcut

Bonjour,

J'ai un petit souci pour déclarer un point cut.

J'aimerais intercepter tous appels d'une méthode plug sur les classes finissant par Module dans n'importe quel package, par exemple :

org.jtheque.modules.TestModule.plug()
com.xyz.abc.zui.SecondModule.plug()
ThirdModule.plug()

J'ai essayé toute une série de pointcut aspectj, mais j'ai pas encore réussi :?

Voici quelques uns de ceux que j'ai essayé :

@Before("execution(* ...*Module.plug())")
@Before("execution(* ..*Module.plug())")
@Before("execution(* *Module.plug())")
@Before("execution(* *.*Module.plug())")
@Before("execution(* *..*Module.plug())")

Je suis un peu à court d'idées :(

Si quelqu'un savait comment réaliser un tel pointcut, ce serait cool :)

Code:

1
2
3
4
5
6
 
@Before("execution (* * ..*Module.plug(..))")
 
ou 
 
@Before("execution (* * ..*Module.plug())")

Et ca ? :aie:

17/08/2009, 15h11
Baptiste Wicht

Non plus :?

Heuuu c'est pas normal ca :calim2:

J'ai fait un test simple

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
package test.pack1;
 
 
public class BlablaModule {
 
	public void plug(){
		System.out.println("Blabla");
 
	}
 
}

Code:

1
2
3
4
5
6
7
8
 
public class TotoModule {
 
	public void plug(){
		System.out.println("Toto");
 
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd 
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
 
	<!-- activate aspect aop proxying (aspects classes needs to be defined in spring config, see below) -->
	<aop:aspectj-autoproxy/>
 
	<!-- define our logging aspect which is using aop annotations  -->
	<bean class="aop.LoggingAspect"/>
 
	<bean name="blabla" class="test.pack1.BlablaModule"></bean>
	<bean name="toto" class="test.pack2.TotoModule"></bean>
 
 
</beans>

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
package aop;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
 
 
 
@Aspect
public class LoggingAspect {	
 
	@Before("execution (* * ..*Module.plug())")
	public void logWebController(JoinPoint joinPoint) {
		System.out.println(joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
	}
}

Code:

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;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import test.pack1.BlablaModule;
import test.pack2.TotoModule;
 
 
public class Main {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		ApplicationContext  context = new ClassPathXmlApplicationContext("applicationContext.xml");
 
		BlablaModule blabla = context.getBean("blabla",BlablaModule.class);
 
		TotoModule toto = context.getBean("toto",TotoModule.class);
 
		blabla.plug();
		toto.plug();
 
	}
 
}

et J'ai comme sortie :

Citation:

test.pack1.BlablaModule.plug
Blabla
test.pack2.TotoModule.plug
Toto

17/08/2009, 15h18
Hikage

Tu sais nous montrer la config spring etc ? :aie:

Pas de soucis :

Mon aspect :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Aspect
public class ModuleLoggingAspect {
    @Pointcut("execution (* * ..*Module.plug())")
    public void modulePlug(){}
 
    @Before("modulePlug()")
    public void logBeforePlug(JoinPoint joinPoint){
        Logger.getLogger(getClass()).trace("Module " + joinPoint.getSourceLocation().getWithinType().getSimpleName() + " plug started");
    }
 
    @After("modulePlug())")
    public void logAfterPlug(JoinPoint joinPoint){
        Logger.getLogger(getClass()).trace("Module " + joinPoint.getSourceLocation().getWithinType().getSimpleName() + " plug finished");
    }
}

Une classe qui devrait être interceptée :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Module(name = "primary-module-test", description = "ModuleContainer primaire de test", author = "Baptiste Wicht",
        version = "1.0", coreVersion = "2.0", jarFile = "Primary-Module-Test.jar")
@PrimaryModule(icon = "org/jtheque/core/tests/integration/module/primary/resources/test.png")
@ModuleDefinition(updateURL = "http://jtheque.developpez.com/public/versions/PrimaryTestModule.versions")
public class PrimaryTestModule {
    @PrePlug
    private static void prePlug() {
        System.out.println("I'm fast here");
    }
 
    @Plug
    private static void plug() {
        System.out.println("I'm here");
    }
 
    @UnPlug
    private static void unplug() {
        System.out.println("I'm out");
    }
}

Le fichier qui définit le bean à intercepter :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <aop:aspectj-autoproxy/>
 
    <bean id="testModule" class="org.jtheque.core.tests.integration.module.primary.PrimaryTestModule" lazy-init="false" />
 
</beans>

et le fichier de config de l'aspect :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"
       default-lazy-init="true">
 
    <!-- Aspects -->
 
    <bean class="org.jtheque.core.spring.aspect.ManagerLoggingAspect"/>
 
    <bean class="org.jtheque.core.spring.aspect.ModuleLoggingAspect"/>
 
    <bean class="org.jtheque.core.spring.aspect.PhasesCounterAndLoggingAspect"/>
</beans>

Mon application context est une ClassPathXmlApplicationContext qui charge plusieurs fichiers XML dont les 2 cités plus haut.

Par contre, je viens de penser maintenant que je récupère l'instance du module via un post-processeur de bean et que j'enregistre ensuite directement le bean du post-processeur dans mon application.

Est-ce possible qu'en faisant ça j'aie l'instance réelle et non pas l'instance décorée par le proxy ?

17/08/2009, 16h03
Hikage

Montre le code je suis pas sur de comprendre

J'utilise un post processor de bean pour détecter les beans qui sont des modules (Annotation module) et j'enregistre ensuite l'instance de ce module dans une classe utilitaire :

Code:

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
package org.jtheque.core.spring.processors;
 
//...
 
public class ModulePostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class<?> c = bean.getClass();
 
        if(isModule(c)){
            registerModule(bean);
        }
 
        return bean;
    }
 
    private static boolean isModule(AnnotatedElement c) {
        return c.getAnnotation(Module.class) != null;
    }
 
    private static void registerModule(Object bean) {
        ModuleContainer module = new ModuleContainer();
 
        module.setModule(bean);
 
        //...
 
        ModuleLoader.getModules().add(module);
    }
 
    //...
}

Donc la question que je me pose : Est-ce que, parce que je passe par le post-processeur, j'obtiens l'instance réelle et non pas le proxy aop de Spring, ce qui fait que les appels à ces modules ne sont, logiquement, pas interceptés ?

Citation:
Envoyé par Baptiste Wicht
J'utilise un post processor de bean pour détecter les beans qui sont des modules (Annotation module) et j'enregistre ensuite l'instance de ce module dans une classe utilitaire :
Code:

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 package org.jtheque.core.spring.processors; //... public class ModulePostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { Class<?> c = bean.getClass(); if(isModule(c)){ registerModule(bean); } return bean; } private static boolean isModule(AnnotatedElement c) { return c.getAnnotation(Module.class) != null; } private static void registerModule(Object bean) { ModuleContainer module = new ModuleContainer(); module.setModule(bean); //... ModuleLoader.getModules().add(module); } //... }
Donc la question que je me pose : Est-ce que, parce que je passe par le post-processeur, j'obtiens l'instance réelle et non pas le proxy aop de Spring, ce qui fait que les appels à ces modules ne sont, logiquement, pas interceptés ?
Je dirait que c'est fort possible en effet, essaie de vior en début le type de l'object 'bean'. Si c'est directement ta classe, c'est mauvais signe.

Je pense que cela devrait être un proxy

18/08/2009, 10h40
Baptiste Wicht

En fait c'est pas aussi simple :(

J'ai essayé de n'enregistrer que le nom de bean et ensuite lorsque j'appelle la méthode, je récupère le bean et j'appelle ma méthode dessus, mais ça ne marche pas non plus...

Je récupère un bean de type Module au lieu d'un proxy. Est-ce que les aspects ne s'appliquent qu'à leur fichier et non pas à l'ensemble de l'application context ?
18/08/2009, 11h13
Baptiste Wicht

J'ai essayé de passer la méthode plug() en public. Il me crée maintenant un proxy CGLib, par contre, maintenant, je ne peux plus le détecter comme le proxy n'a pas l'annotation @Module :aie:

Me semble que c'est un peu désespéré :?
18/08/2009, 11h15
Hikage
Non normalement, si tu charges plusieurs fichier dans un même contexte, c'est configuré pour l'ensemble.

Donc si je capte bien, tu as tenter un truc du genre :
Code:

1 2 ((Module)context.getBean("nomDuBean")).plug();
Et l'aspect passe tjs pass ?
18/08/2009, 11h19
Hikage

Essaie de mettre @Inherited sur la définition de ton annotation @Plug
18/08/2009, 11h35
Baptiste Wicht

Citation:

Envoyé par Hikage

Essaie de mettre @Inherited sur la définition de ton annotation @Plug

Ca marche au niveau de l'annotation module (au niveau de la classe donc), mais les annotations sont pas reprises par CGlib au niveau des méthodes...
18/08/2009, 12h03
Hikage

Juste une petite question, tu vérifie comment que l'annotation est présenet ?

Citation:

Envoyé par Hikage

Juste une petite question, tu vérifie comment que l'annotation est présenet ?

Voici mon post processor complet :

Code:

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class ModulePostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class<?> c = bean.getClass();
 
        if(isModule(c)){
            registerModule(bean, beanName);
        }
 
        return bean;
    }
 
    private static boolean isModule(AnnotatedElement c) {
        return c.getAnnotation(Module.class) != null;
    }
 
    private static void registerModule(Object bean, String beanName) {
        ModuleContainer module = new ModuleContainer();
 
        module.setBeanName(beanName);
 
        searchForAnnotedMethods(bean, beanName, module);
 
        completeMethods(module);
 
        ModuleLoader.getModules().add(module);
    }
 
    private static void searchForAnnotedMethods(Object bean, String beanName, ModuleContainer module) {
        for(Method m : bean.getClass().getDeclaredMethods()){
            if(m.getAnnotation(UnPlug.class) != null){
                module.setUnPlugMethod(new ReflectionBeanMethod(beanName, m.getName()));
            } else if(m.getAnnotation(Plug.class) != null){
                module.setPlugMethod(new ReflectionBeanMethod(beanName, m.getName()));
            } else if(m.getAnnotation(PrePlug.class) != null){
                module.setPrePlugMethod(new ReflectionBeanMethod(beanName, m.getName()));
            }
        }
    }
 
    private static void completeMethods(ModuleContainer module) {
        if(module.getUnPlugMethod() == null){
            module.setUnPlugMethod(new EmptyBeanMethod());
        }
 
        if(module.getPlugMethod() == null){
            module.setPlugMethod(new EmptyBeanMethod());
        }
 
        if(module.getPrePlugMethod() == null){
            module.setPrePlugMethod(new EmptyBeanMethod());
        }
    }
}

Le test sur la classe passe bien depuis que j'ai rajouté Inherited, mais ça n'a pas suffit pour les méthodes.

Essaie comme cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
private static void searchForAnnotedMethods(Object bean, String beanName, ModuleContainer module) {
        for(Method m : bean.getClass().getSuperclass().getDeclaredMethods()){
            if(m.getAnnotation(UnPlug.class) != null){
                module.setUnPlugMethod(new ReflectionBeanMethod(beanName, m.getName()));
            } else if(m.getAnnotation(Plug.class) != null){
                module.setPlugMethod(new ReflectionBeanMethod(beanName, m.getName()));
            } else if(m.getAnnotation(PrePlug.class) != null){
                module.setPrePlugMethod(new ReflectionBeanMethod(beanName, m.getName()));
            }
        }
    }

18/08/2009, 13h00
Baptiste Wicht

:ave:

Merci beaucoup, cette fois, ça fonctionne à la perfection :)