[integration] utilisation optionnelle d'une libraire externe

Version imprimable

09/06/2006, 11h13
Grand sorcier

[integration] utilisation optionnelle d'une libraire externe
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:

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 ?

Salut,

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

Code:

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:

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:

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:

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:

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

09/06/2006, 11h40
Grand sorcier
Merci de ta réponse :D

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

1 2 Method[] methods = syncmlClass.getMethods ();
Et donc si cette voie ne marche pas, alors j'utiliserai
ta technique.

Merci.
09/06/2006, 11h42
bulbo

Les solutions apportées par AdiGuba sont tres bien, ce post est juste pour ta culture generale sur la reflection :P (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 ;)
09/06/2006, 11h51
Grand sorcier

Citation:

Envoyé par bulbo

Les solutions apportées par AdiGuba sont tres bien, ce post est juste pour ta culture generale sur la reflection :P (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 ;)

:ccool:

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
09/06/2006, 13h02
sozie9372

En gros cela revient à implémenter un système de plugins... cf le tutoriel sur ca...
+++
Ju
09/06/2006, 17h06
Grand sorcier

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