IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Design Patterns Discussion :

Pattern pour des contraintes entre Objet


Sujet :

Design Patterns

  1. #1
    Membre à l'essai
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    21
    Détails du profil
    Informations personnelles :
    Âge : 48
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 21
    Points : 17
    Points
    17
    Par défaut Pattern pour des contraintes entre Objet
    Tchô,

    Je cherche un pattern pour écrire de manière générique des contraintes sur des objets seuls ou sur des couples d'objets.
    Par exemple j'ai les classes suivantes
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Patient 
    {
     int age;
     double poids;
     double taille;
     String nom;
    }
    
    Medicament
    {
      String nom;
      int limiteAge;
      double limiteParPoids;
    }
    Et je voudrais pouvoir définir différents types de contraintes génériques sur ces objets. Par exemple je voudrais pouvoir définir une contrainte sur l'age ou la taille du patient. Je voudrais aussi pouvoir lier deux champs entre deux objets comme le champ age du patient et le champ limiteAge de Médicament pour pouvoir vérifier automatiquement une sorte de "compatibilité" entre les deux instances. Bien sûr je veux pouvoir le faire en ayant juste à choisir le type de contrainte à définir "contrainte a seuil" ou "contrainte de compatibilité" et préciser au constructeur correspondant les instances à comparer et les champs à comparer. Ainsi je voudrais définir une contrainte de type SupZeroContrainte sur un objet quelquonque dans ce cas Patient qui permet de verifier qu'un champ quelquonque est superieur à 0. Je veux écrire quelque chose de générique qui NE ressemble donc PAS à ce qui suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class SupZeroContrainte
    {
      static boolean verifier(Object obj, String nomDuChamp) 
      {
       return ((Patient)(obj)).age > 0;
      }
    }
    Je veux pouvoir verifier n'importe quel champ de n'importe quelle classe. Et j'aimerais pouvoir vérifier des compatibilités entre champs de différentes classes. Par exemple, vérifier que l'age du Patient est bien inférieur à l'age min du Médicament (avec une sorte de contrainte du genre CompatibilitéContrainte)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class  CompatibilitéContrainte
    {
      static boolean verifier(Object obj1, Obj2, String champ1, String champ2) 
      {
       return ((Patient)(obj1)).age > ((Medicament)(obj2)).limiteAge;
      }
    }
    Je me doute que je pourrais utiliser la reflexivité Java pour cela, ou les Beans (ce qui revient au même sans doute dans ce cas), mais je me demandais s'il n'y avait pas moyen de résoudre ce pb avec un pattern connu (visitor ? mais je vois pas comment puisqu'il faut passer plus que le visitor à chaque classe dans le cas des contraintes binaires).

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class Patient 
    {
     int age;
     double poids;
     double taille;
     String nom;
     boolean accept(Visitor v) 
     {
       V.verifierAgeSupZeroContrainteOnPatient(this);
     }
    }

    Toutes vos suggestions seront donc les bienvenues

  2. #2
    Membre habitué
    Profil pro
    Inscrit en
    Août 2006
    Messages
    89
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2006
    Messages : 89
    Points : 170
    Points
    170
    Par défaut
    Bonjour,

    Peut être que je passe à côté de quelque chose, mais est ce qu'il ne suffirait pas d'envoyer directement les valeurs des champs que tu veux évaluer/comparer?

    En fait je pense à un objet 'Contraintes' indépendant, de type singleton, qui implémenterait uniquement des méthodes prenant des int en paramètres.
    Exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    supZero(int valeur) {
    
    return valeur > 0;
    }
    Après le code à appeler ne serait pas très compliqué non plus:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Patient 
    {
    
    int age; double poids; double taille; String nom; boolean accept() {
    // Je ne connais pas bien le Java, // donc les méthodes statiques ne s'appellent peut être pas // de cette façon : Contraintes mesContraintes = Contraintes.getInstance(); return mesContraintes.supZero(age);
    }
    }
    Pour la comparaison entre 2 champs ça ne doit pas être beaucoup plus compliqué:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    return mesContraintes.compatibiliteAgeMedicament(monPatient.getAge(), monMedicament.getAgeLimite());
    Après viendra peut être le problème sur la comparaison entre int, string et double, et encore une fois je ne connais pas bien Java, mais je pense que tout ça peut être géré avec des casts et des exceptions. (ou l'utilistation des classes de type Integer et autres de Java peut être?)

    Voila, je ne sais pas si ça répond au problème ou si au moins ça donne une piste?

  3. #3
    Membre à l'essai
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    21
    Détails du profil
    Informations personnelles :
    Âge : 48
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 21
    Points : 17
    Points
    17
    Par défaut
    Ok. Merci tristan pour ta réponse . Elle est très utile car elle permet de clarifier les choses.Du coup, je me rend compte que dans mon cas, Patient et Medicament vont être défini une bonne fois pour toute, avec une foule de champs. En fait, je veux pouvoir ajouter n'importe quel type de contrainte entre deux instances de ces classes n'importe quand. Du coup la méthode accept() que tu proposes ne convient pas puisque les contraintes seront codées en dur dans ce cas. Il faudrait que je puisse ajouter des objets Contraintes à Patient et Medicament et parcourir ces contraintes un peu dans le genre :
    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
    class Patient
    {
        int age; 
        double poids; 
        double taille; 
        String nom; 
        Contrainte[] contraintes;
    
        boolean accept() {
           boolean retour = true;
           for(int i=0; i<contraintes.lenght; i++) {
              retour &= contraintes.accept();
        } 
         return retour;
      }
    }
    Mais pour cela il faut plus au moins passer une instance du Patient en parametres dans la méthode accept et il faudrait des sous classes de Contraintes adaptées à chaque type d'objets (PatientContrainte, MedicamentContrainte)... Sans parler du problème pour gérer les contraintes sur deux objets. Je me demande dans quelle mesure une combo des patterns Mediator et Visitor ne pourrait pas faire l'affaire.

  4. #4
    ego
    ego est déconnecté
    Rédacteur

    Homme Profil pro
    Architecte de système d'information
    Inscrit en
    Juillet 2004
    Messages
    1 883
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Architecte de système d'information
    Secteur : Finance

    Informations forums :
    Inscription : Juillet 2004
    Messages : 1 883
    Points : 3 510
    Points
    3 510
    Billets dans le blog
    2
    Par défaut
    peut être des idéees ici : http://www.contract4j.org/contract4j

  5. #5
    Membre à l'essai
    Profil pro
    Inscrit en
    Mars 2007
    Messages
    18
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : Canada

    Informations forums :
    Inscription : Mars 2007
    Messages : 18
    Points : 21
    Points
    21
    Par défaut
    Bonjour fabgamer,

    je veux ajouter mon petit grain de sel Tu connais la programmation orientée aspect? Parce que les contraintes que tu décris sont, selon moi, des aspects dont le code ira se mettre partout où tu voudrais vérifier la validité (ou non) de ladite contrainte.

    En gros, tu mets les contraintes dans des aspects, tes classes pourront rester très jolies (cohésives) et ne pas avoir à se préoccuper de vérifier si par exemple le patient à l'âge requis pour prendre un médicament donné, c'est l'aspect qui effectuerait ce genre de vérification au moment que tu spécifies.

    Petit exemple bien bête :

    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
    27
    28
    29
    class Patient 
    {
     int age;
     double poids;
     double taille;
     String nom;
    }
    
    class Medicament
    {
      String nom;
      int limiteAge;
      double limiteParPoids;
    }
    
    class Hopital
    {
       methode administrerMedicament(Patient p, Medicament m) {
       ...
       }
    }
    
    aspect ContrainteMedicament {
       avant Hopital.administrerMedicament(..) {
          si (p.age > m.limiteAge) {} 
          sinon {}
       }
    }
    Je ne veux pas faire d'exposé sur la programmation orientée aspect mais c'est une bonne piste pour ton problème, je crois. Va fouiller un peu sur google, particulièrement pour le l'info concernant AspectJ, qui est en ce moment l'implémentation la plus mature de la programmation orientée aspect.

    Si tu as des questions, n'hésite pas!!

    Bonne chance!!

  6. #6
    Membre à l'essai
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    21
    Détails du profil
    Informations personnelles :
    Âge : 48
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 21
    Points : 17
    Points
    17
    Par défaut
    Je connais la prog aspect que de nom. Je vais jeter un oeil la dessus, et je reviendrais avec mes questions

  7. #7
    Nouveau membre du Club
    Inscrit en
    Février 2006
    Messages
    75
    Détails du profil
    Informations forums :
    Inscription : Février 2006
    Messages : 75
    Points : 35
    Points
    35
    Par défaut
    Un retour sur la solution choisie et mise en oeuvre ?

  8. #8
    Expert confirmé
    Avatar de Hephaistos007
    Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2004
    Messages
    2 493
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2004
    Messages : 2 493
    Points : 4 166
    Points
    4 166
    Par défaut
    Même un aspect, est statique : il faut le coder au préalable. Ce que cherche fabgamer c'est un moyen d'appliquer des contraintes dynamiquement. Dans ce cas, à part passer par la réflexion je ne vois pas.

    Pour faciliter cette tâche, il peut être intéressant de s'appuyer sur des conventions de nommage, comme le font les beans pour être manipulé par réflexion.

    Par exemple, les médicament ont des attributs formés du préfixe "Max" ou "Min" suivi du nom des attributs des objets à contraintres. Ceci nous donnerai par convention :

    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    class Patient {
      age;
      poids;
    }
     
    class Medicament {
     
      MaxAge; 
      MinAge; 
      MaxPoids;
      MinPoids;
    }
    Il vaut mieux mobiliser son intelligence sur des conneries que mobiliser sa connerie sur des choses intelligentes --- devise SHADOKS

    Kit de survie Android : mon guide pour apprendre à programmer sur Android, mon tutoriel sur les web services et enfin l'outil en ligne pour vous faire gagner du temps - N'oubliez pas de consulter la FAQ Android

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 1
    Dernier message: 30/04/2011, 19h22
  2. Un design pattern pour des appels à un web service
    Par kekranx dans le forum Design Patterns
    Réponses: 0
    Dernier message: 07/07/2008, 10h32
  3. Réponses: 1
    Dernier message: 25/01/2008, 15h44
  4. [Observateur] pattern publish/subscribe : communication entre objets
    Par mik-at dans le forum Design Patterns
    Réponses: 6
    Dernier message: 04/09/2006, 14h07
  5. delete[] seulement pour des tableaux d'objets?
    Par Crisanar dans le forum C++
    Réponses: 7
    Dernier message: 22/10/2005, 20h50

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo