Polymorphisme et appels serveur
Bonjour,
Je développe une application client/serveur et je me pose la question de la bonne gestion du polymorphisme avec les objets provenant du serveur :
Voici le contexte :
J'ai plusieurs fruits qui implémentent l'interface fruit :
Code:
1
2
3
4
5
6
7
8
9
10
| public interface Fruit{
float getPoid();
//...
}
public class Orange implements Fruit{
private float poid;
//...
} |
J'ai un service sur le serveur qui me renvoie un fruit :
Code:
1
2
3
| public interface Service{
private Fruit getFruit( ...);
} |
J'ai une interface sur le client qui me permet d'afficher un fruit et ses implémentations :
Code:
1
2
3
4
5
6
7
8
9
10
11
| public interface FruitClient{
void afficherLeFruit();
}
public class OrangeClient implements FruitClient{
public void afficherLeFruit() {
// afficher une orange
}
} |
Comment puis-je passer du fruit que j'ai reçu du serveur (et dont je ne connais pas la class exacte) en fruit "affichable"
Les deux solutions qui me viennent à l'esprit sont soit d'utiliser des "instanceof" :
Code:
1
2
3
4
5
6
| public FruitClient convertFruit(Fruit fruit) {
Fruit fruit = service.getFruit(...);
if (fruit instanceof Orange) return new OrangeClient((Orange)fruit);
else if (fruit instanceof Pomme) return new PommeClient((Pomme)fruit);
else...
} |
soit de mettre des méthodes dans mon interface fruit pour générer les class désirées
Code:
1
2
3
4
5
6
| public interface Fruit{
float getPoid();
FruitClient generateClientObject();
} |
Dans le premier cas, je trouve que ça ne fait vraiment pas propre (on m'a toujours exliqué de limiter les instanceof le plus possible)
Dans le second cas, je suis obligé d'embarquer la logique client sur le serveur ce qui n'est pas terrible non plus.
Tout ça me porte à croire que quelque chose cloche dans ma conception :weird: .
Il y a-t-il une manière élégante de résoudre ce problème?
