Discussion :

[Grand sorcier]

Salut,

Je suis en train de rajouter une fonctionnalité pour un logiciel. Mais cette fonctionnalité est spécifique pour un client. Il faut donc que la version standard d'un produit puisse fonctionner sans cette librairie.

L'integration de ma librairie se font dans un bout de code du style

Code :

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

1
2
3
4
5
6
7
 
if (myFeatureIsEnabled)
{
     Class  myClass = Class.forName ("com........myManager");
 
      ...
}

Ainsi le chargement de ma libraire s'effecture dynamiquement
et uniquement si la fonctionnalité est activée ! Super !

Sauf que...

après avoir chargé la classe. Je l'instancie avec un "myClass.newInstance()".
Ce qui me retourne un Object. Or moi je veux appeler des méthodes
de cet objet. Et surtout les methodes qui m'interresse, par exemple
"slowSync()".

Mais ensuite vient une cascade de contraintes :

1) Or pour pouvoir appeler les méthodes de mon object, il faut faire un cast sur l'objet retourné par newInstance().
2) Mais pour faire le cast il faut faire "import com......myClass" en début de
la classe Java.
3) Pour faire le "import" il faut que le JAR de ma librairie soit disponible
lors de la compilation du logiciel.
4) Problème dans sa version standard le logiciel doit pouvoir compiler
sans cette libraire !

Aie !

Quelqun aurait pas une idée ?

[adiGuba]

Salut,


Si c'est toi qui developpe cette classe, tu peux te créer une interface qui décriera toutes ses méthodes :

Code :

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

1
2
3
4
5
6
public interface Fonctionnalite {
 
    public void faireQuelqueChose();
    public void faireAutreChose();
 
}

Et ta classe devra donc implémenter cette interface :

Code :

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

1
2
3
4
5
6
7
8
9
public class MesFonctionnalitees implements Fonctionnalite {
 
    public void faireQuelqueChose() {
        // ...
    }
    public void faireAutreChose() {
        // ...
    }
}

Le code de la classe ne sera donc livré qu'au client spécifique, mais le code de l'interface fera partie intégrante de l'application pour tous les clients.


Ainsi il te suffit de vérifier le type retrouné par le Class.forName() pour pourvoir l'utiliser en tant qu'une implementation de l'interface :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
        Fonctionnalite func = null;
        Class c = Class.forName("pack.MesFonctionnalitees");
        if ( Fonctionnalite.class.isAssignableFrom(c) ) {
            func = (Fonctionnalite) c.newInstance();
        }
 
        if (func!=null) {
            func.faireQuelqueChose();
            func.faireAutreChose();
            func.faireQuelqueChose();
        }

Maintenant tu peux également utiliser l'interface Runnable et rajouter tout le code dans la méthode run() :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MesFonctionnalitees implements Runnable {
 
    public void faireQuelqueChose() {
        // ...
    }
    public void faireAutreChose() {
        // ...
    }
    public void run() {
        faireQuelqueChose();
        faireAutreChose();
        faireQuelqueChose();
    }
}

Ce qui pourrait donner :

Code :

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

1
2
3
4
5
6
7
8
9
        Runnable func = null;
        Class c = Class.forName("pack.MesFonctionnalitees");
        if ( Runnable.class.isAssignableFrom(c) ) {
            func = (Runnable) c.newInstance();
        }
 
        if (func!=null) {
            func.run();
        }

a++

[Grand sorcier]

Merci de ta réponse

J'étais parti sur l'utilisation de "getMethods" comme ceci

Code :

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

1
2
 
Method[] methods = syncmlClass.getMethods ();

Et donc si cette voie ne marche pas, alors j'utiliserai
ta technique.

Merci.

[bulbo]

Les solutions apportées par AdiGuba sont tres bien, ce post est juste pour ta culture generale sur la reflection (voir aussi ici: http://ricky81.developpez.com/tutori...pi/reflection/)

Tu peux acceder aux methodes de ta classe depuis la Classe que tu as obtenu en faisant ton Class.forName notamment avec les methodes getMethod(s)(...) ..

Mais c'est tres lourd a utiliser surtout si tu as un grand nombre d'appel, le coup de l'interface est a mon avis ce qui est le plus elegant a faire.

[Edit] Grilled, tu connaissais deja apparemment [/Edit]

Bulbo

[Grand sorcier]

Les solutions apportées par AdiGuba sont tres bien, ce post est juste pour ta culture generale sur la reflection (voir aussi ici: http://ricky81.developpez.com/tutori...pi/reflection/)

Tu peux acceder aux methodes de ta classe depuis la Classe que tu as obtenu en faisant ton Class.forName notamment avec les methodes getMethod(s)(...) ..

Mais c'est tres lourd a utiliser surtout si tu as un grand nombre d'appel, le coup de l'interface est a mon avis ce qui est le plus elegant a faire.

[Edit] Grilled, tu connaissais deja apparemment [/Edit]

Bulbo

Merci pour le lien. D'une part cela va augmenter ma culture
générale mais cela pourrait aussi me donner des idées
dans mon implementation.

Je le lis de suite

[sozie9372]

En gros cela revient à implémenter un système de plugins... cf le tutoriel sur ca...
+++
Ju

[Grand sorcier]

Ben les getConstuctors(), getMethods() et compagnie marche plutot bien.
Je vai garder cette technique de la reflexivité du code source....