Bonsoir,

J'utilise un namespace custom qui me permet de créer facilement un proxy pour un bean. Par exemple, ce proxy :

Code XML : Sélectionner tout - Visualiser dans une fenêtre à part
<jtheque:proxy id="mainView" type="org.jtheque.core.managers.view.impl.frame.MainView"/>

fait référence à ce bean :

Code XML : Sélectionner tout - Visualiser dans une fenêtre à part
<bean id="_mainView" class="org.jtheque.core.managers.view.impl.frame.MainView" factory-method="get"/>

Actuellement, je déduis simplement le nom du bean destination en ajoutant un "_" devant le nom du bean proxy.

Voici mon parser :

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
public final class ProxyBeanDefinitionParser extends AbstractSimpleBeanDefinitionParser {
    @Override
    protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
        String id = element.getAttribute("id");
 
        builder.addConstructorArgValue('_' + id);
 
        builder.getBeanDefinition().setPrimary(true);
 
        try {
            builder.addConstructorArgValue(Class.forName(element.getAttribute("type")));
        } catch (ClassNotFoundException e) {
            parserContext.getReaderContext().error("Class not found", element, e);
        }
    }
 
    @Override
    protected Class<?> getBeanClass(Element element) {
        return LazyFactoryBean.class;
    }
}
et mon factory bean :

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
public final class LazyFactoryBean extends AbstractFactoryBean {
    private final String beanName;
    private final boolean swing;
    private final Class<?> beanClass;
 
    public LazyFactoryBean(String beanName, boolean swing, Class<?> beanClass) {
        super();
 
        this.beanName = beanName;
        this.swing = swing;
        this.beanClass = beanClass;
    }
 
    @Override
    public Class<?> getObjectType() {
        return beanClass;
    }
 
    @Override
    protected Object createInstance() {
        return Proxy.newProxyInstance(
                ClassLoader.getSystemClassLoader(),
                beanClass.getInterfaces(),
                new LazyProxyHandler(beanName, swing));
    }
}
Tout cela marche très bien, mais avec ça, on peut toujours récupérer directement le bean de destination via son nom ou son type, ce que j'aimerais éviter...

Alors déja première question : Est-ce que c'est possible de rendre invisible un bean à part en interne dans le parser ?

Sinon, j'aimerais effectuer un refactoring pour pouvoir parser un bean à peu près comme ça :

Code XML : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
<bean id="_mainView" class="org.jtheque.core.managers.view.impl.frame.MainView" factory-method="get">
<bean class="org.jtheque.core.managers.view.impl.frame.MainView" factory-method="get"/>
</jtheque:proxy>

mais je ne peux pas le déclarer directement en argument du constructeur de mon LazyFactoryBean car alors il serait alors résolu directement lorsque le proxy serait créé alors que je ne veux une instanciation du bean enfant qu'à l'utilisation.

Donc, il me faut un moyen de déclarer un bean de manière interne à un autre mais sans créer ce bean interne à la création du bean externe.

C'est assez tiré par les cheveux, je sais, mais j'aimerais bien qu'on ne puisse par récupérer le bean non proxy.

Si quelqu'un a une idée, je lui serais très reconnaissant

Egalement si quelqu'un voit une autre façon de faire qui convienne à mon objectif

Le but étant de créer un proxy d'un bean qui ne va s'instancier que lors d'un appel de méthode sur lui et non pas lors de l'affectation du bean.

Merci d'avance

Baptiste