Discussion :

[fabgamer]

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

[tristan_m]

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?

[fabgamer]

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.

[ego]

peut être des idéees ici : http://www.contract4j.org/contract4j

[kungfoo]

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

[fabgamer]

Je connais la prog aspect que de nom. Je vais jeter un oeil la dessus, et je reviendrais avec mes questions

[duboisfa]

Un retour sur la solution choisie et mise en oeuvre ?

[Hephaistos007]

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;
}