Problème de déclaration d'un pointcut

**Baptiste Wicht** · 17/08/2009, 14h04

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

**Hikage** · 17/08/2009, 14h42

Code :

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

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

Et ca ?

**Baptiste Wicht** · 17/08/2009, 15h11

Non plus

**Hikage** · 17/08/2009, 15h18

Heuuu c'est pas normal ca

J'ai fait un test simple

Code :

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

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 :

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

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

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
 
<?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 :

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
 
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 :

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;
 
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 :

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

**Hikage** · 17/08/2009, 15h18

Tu sais nous montrer la config spring etc ?

**Baptiste Wicht** · 17/08/2009, 15h39

Pas de soucis :

Mon aspect :

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
@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 :

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
@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 XML :

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

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 XML :

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
<?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 ?

**Hikage** · 17/08/2009, 16h03

Montre le code je suis pas sur de comprendre

**Baptiste Wicht** · 17/08/2009, 16h45

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 :

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
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 ?

**Hikage** · 18/08/2009, 07h49

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 :

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
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

**Baptiste Wicht** · 18/08/2009, 10h40

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 ?

**Baptiste Wicht** · 18/08/2009, 11h13

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

Me semble que c'est un peu désespéré

**Hikage** · 18/08/2009, 11h15

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 :

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

1
2
 
((Module)context.getBean("nomDuBean")).plug();

Et l'aspect passe tjs pass ?

**Hikage** · 18/08/2009, 11h19

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

**Baptiste Wicht** · 18/08/2009, 11h35

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...

**Hikage** · 18/08/2009, 12h03

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

**Baptiste Wicht** · 18/08/2009, 12h11

Envoyé par Hikage

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

Voici mon post processor complet :

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
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.

**Hikage** · 18/08/2009, 12h39

Essaie comme cela :

Code :

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

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()));
            }
        }
    }

**Baptiste Wicht** · 18/08/2009, 13h00

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

Problème de déclaration d'un pointcut [Framework]

Spring Java

Discussions similaires

Partager

Partager