Sujet Précédent Sujet Suivant

Pattern Observer plusieur observateur pour

Résolu
seichan94 Messages postés 38 Date d'inscription mardi 29 octobre 2013 Statut Membre Dernière intervention 6 novembre 2014 - 28 avril 2014 à 21:40
cs_Julien39 Messages postés 6414 Date d'inscription mardi 8 mars 2005 Statut Modérateur Dernière intervention 29 juillet 2020 - 1 mai 2014 à 20:13
Bonjour bonjour,

bon je vient poser une nouvelle question, au sujet du pattern Observer.
Je réalise une application avec swing,
j'ai un contrôleur qui implémente Observable
avec plusieur liste d'observateur

j'ai un JPanel qui implémente Observateur avec la fonction update qui va bien
je souhaite qu'une autre JPanel implémente Observateur mais j ai pas envie d'avoir le update du précédent est il possible d'avoir 2 Observateur

exemple

Observable
ObservateurClient
ObservateurProduit

sans avoir a crée 2 Observable different ???

je sais si je suis bien claire peut-etre qu je mi prend pas comme il faut je sais pas trop

merci pour votre aide
A voir également:

4 réponses

Réponse 1 / 4
cs_Julien39 Messages postés 6414 Date d'inscription mardi 8 mars 2005 Statut Modérateur Dernière intervention 29 juillet 2020 369
29 avril 2014 à 08:57
La problème est que les classes du JDK qui te permettent d'implémenter ce pattern n'ont pas prévu ce cas de figure. Tu ne pourras donc pas les utiliser. Cependant, tu peux toi même redéfinir le comportement d'un pattern Observer sans te servir des classe du JDK.

Par exemple :

Tu créés deux interfaces : 
public interface ObservateurClient {
    
    public void updateClient();

}
public interface ObservateurProduit {
    
    public void updateProduit();

}


Puis tu créés tes classes Observables : 
public class ObservableClient {

    private List<ObservateurClient> observateurs;

    public ObserVableClient(){
        observateurs = new ArrayList<ObservateurClient>();
    }

    public void addObserver(ObservateurClient o){
        observateurs.add(o);
    }

    public void notifyAll(){
        for(ObservateurClient o : observateurs){
            o.updateClient();
        }
    }

}


Je ne te détaille pas ObservableProduit, c'est la même.

Et ensuite, tu créés la classe qui observe les modifications de ObservableProduit et ObservableClient : 
public class ObserverProduitClient implements ObservateurProduit, ObservateurClient(){
    
    @Override
    public void updateProduit(){
        // Code exécuté quand ObservableProduit notifie
    }

    @Override
    public void updateClient(){
        // Code exécuté quand ObservableClient notifie
    }

}


Et voilà, tu viens d'implémenter à la main le pattern Observer, il ne te reste plus qu'à initialiser : 

ObservableProduit obProduit = new ObservableProduit();
ObservableClient obClient = new ObservableClient();
ObserverProduitClient observer = new ObserverProduitClient();
obProduit.addObserver(observer);
obClient.addObserver(observer);
2
Réponse 2 / 4
cs_Julien39 Messages postés 6414 Date d'inscription mardi 8 mars 2005 Statut Modérateur Dernière intervention 29 juillet 2020 369
29 avril 2014 à 08:45
Salut,

Si j'ai bien compris tu as deux classes observables :
- ObservableClient
- ObservableProduit

Et tu veux ajouter des observateurs de ces deux classes.

Problème, c'est toujours la même méthode update() qui est appelée et tu voudrais que ces deux observable déclenchent des comportement différents.

Donc que faire ?
1
Réponse 3 / 4
seichan94 Messages postés 38 Date d'inscription mardi 29 octobre 2013 Statut Membre Dernière intervention 6 novembre 2014
29 avril 2014 à 12:13
Bonjour

Merci pour ta réponse je vais faire comme cela en terme de bonne pratique c'est courant ce style d'utilisation ?

Merci bonne journée
0
Réponse 4 / 4
cs_Julien39 Messages postés 6414 Date d'inscription mardi 8 mars 2005 Statut Modérateur Dernière intervention 29 juillet 2020 369
1 mai 2014 à 20:13
Il y a tout un tas de bonnes raison de ré-implémenter ce pattern en java.

Il est possible que dans la conception de ton application tu ais fait quelques maladresses, mais ce n'est pas garanti, en tout cas, je ne peux pas le savoir avec si peu d'informations.

Dans tous les cas, ré-implémenter le pattern Observer dans ce cas ne me semble pas être une solution maladroite.

C'est une chose que je fais assez souvent pour d'autres raisons, l'implémentation de ce pattern est à mon sens assez mal pensée. J'avais dans un projet implémenté ce pattern avec des classes génériques de manière à récupérer des informations sur l'état de l'observable dans la méthode update de cette manière : 
public class Observer<T extends IObservable> {
   
    public void update(T observable){

    }
}
0
Rejoignez-nous