Discussion :

[la.lune]

Voila je crois que le titre est claire, moi je comprend ce que ça veut dire de quoi il s'agit mais je cherche le mot disons standard équivalent e français.
est ce :
liaison, liaison dynamique, interdépendance, consolidation, reliure, accrochage.. ou autre que je ne sais pas quoi.

[Mathieu.J]

liaison

Me paraît bien.

[bouye]

Liaison, lien, lié

[Teocali]

Si on passe outre la signification litterale, et qu'on s'interesse au sens, Synchronisation, bien que verbeux, fait également l'affaire.

Teo

[la.lune]

Le binding n'est pas toujours synchrone , quand une propriété faisant partie du lien(binding) fût changé, l'expression bindé n'est pas directement recalculé, Mais lorsque d'une expression ou instruction utilisant cette propriété la sollicite. Cependant il y a l'écouteur InvalidationListener qu'on enregiste au lien et qui nous permet se savoir si une propriété parmi les propriété composants le lien a été modifié il nous dit : Ah! attention ,l'expression actuelle est invalide!! La liaison implémente l'interface Observable c'est pour cela qu'on peut écouter via IvalidationListener, mais il n'est déclenché qu'une seule fois (i.e. si d'autres propretés sont modifié l'écouteur ne va pas nous notifier car l'expression est déjà invalide)

Par contre on a l'écouteur ChangeListener qui nous permet d'écouter tout changement mais au niveau de la propriété pour son implémentation de ObservableValue.

MAIS IL NE FAUT PAS OUBLIER, la liaison , en plus de son implémentation de Observable, il implémente aussi ObservableValue. Ainsi, si on enregistre son changeListener alors il n y aura pas d'évaluation tardive, le InvalidationListener n'aura pas de sens. Car à chaque modification d'une partie du lien on sera notifié avec la nouvelle valeur. Le secret est qu'il n'est pas possible de savoir avec le InvalidationListener si le binding fùt réellement changé alors il sera sollicité à chaque modification d'une propriété qui entre dans le lien et on écoutera si la valeur fût changé.Là il y aura de la synchronisation.

[Robin56]

Je n'ai pas saisis toute ta tirade la.lune. En tout cas ce que je peux en dire c'est que le mot "synchronisation" peut se tenir aussi.

Synchronisation directe lorsque le mode de binding est du type :
1. J'ai modifié ma valeur
2. J'avertis aux autres que j'ai été modifié

Synchronisation évènementielle lorsque le mode de binding est du type :
1. J'ai modifié ma valeur
2. Quelqu'un me sollicite
3. Je lui envoie la valeur modifiée

Je parle du binding en général puisque je n'ai aucune compétence en JavaFX.

PS : Je n'ai absolument rien contre le terme "liaison" qui est approprié.

[la.lune]

Moi je parle d'une synchronisation que si un élément, faisant partie de l'ensemble des propriétés mis en liaison pour construire le binding, est modifié qu'on soit directement sûr que le binding est déjà mis à jour, je peux dire que la synchronisation évènementiel n'est pas le cas ici car tu as déjà dis que tu as modifié ta valeur. Le binding n'est pas forcement modifié lorsqu'une des propriétés qui composent la binding est modifié, c'est vrai qu'il écoute mais ne change pas forcement son contenu. Et la propriété modifié dès qu'il est mis en jeux dans un binding il va forcement notifié le binding à chaque modification.

L'essentiel, je vais juste expliquer ce que je voulais dire à travers mon commentaire à travers un petit exemple de calcule de montant total de certains produits dont la quantité est assigné ,voici ma classe Produit dont les attributs respectent la convention demandé en JavaFX en pratique des binding, comme les JavaBeans aussi nous forcent une convention mais ici c'est étendu.

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
package test;
 
 
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.beans.property.SimpleIntegerProperty;
 
 
class Produit {
   private IntegerProperty Id=new SimpleIntegerProperty();
   private DoubleProperty PU=new SimpleDoubleProperty();
   private IntegerProperty Qantité=new SimpleIntegerProperty();
 
 
 
public Produit() {
    }
public int getId() {
        return Id.get();
    }
 
 
    public void setId(int Id) {
        this.Id.set(Id);
    }
    public IntegerProperty IdProperty(){
        return Id;
    };
 
    public double getPU() {
        return PU.get();
    }
 
    public void setPU(double pu) {
        this.PU.set(pu);
    }
    public DoubleProperty PUProperty() {
        return PU;
    }
 
    public int getQantité() {
        return Qantité.get();
    }
 
    public void setQantité(int Qt) {
        this.Qantité.set(Qt);
    }
    public IntegerProperty QantitéProperty() {
        return Qantité;
    }
 
}

On va à présent faire un petit test avec une classe main

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
package test;
 
import javafx.beans.binding.DoubleBinding;
//Les deux importation suivantes sont nécessaires pour le test fait sur l'invalidationlistener
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
 
 
public class Main {
   public static void main(String args[]){
       Produit p1=new Produit(); p1.setId(1);
       Produit p2=new Produit(); p2.setId(2);
       DoubleBinding MontantTotal;
       //On peut créer la liaision n'importe où ça ne necessite pas l'initialisation des beans avant 
       MontantTotal=  p1.PUProperty().multiply(p1.QantitéProperty())
                                      .add(
                                       p2.PUProperty().multiply(p2.QantitéProperty()));
 
/*     Ou en utilisant les méthoes static, cela  est équivalent à:
 *     MontantTotal=   Bindings.add(p1.PUProperty().multiply(p1.QantitéProperty()),
 *                                  p2.PUProperty().multiply(p2.QantitéProperty()));
 *                 OU bien
 *     MontantTotal=   Bindings.add( Bindings.multiply(p1.PUProperty(),p1.QantitéProperty()),
                                 Bindings.multiply(p2.PUProperty(),p2.QantitéProperty()));
A noté qu'un des membres peut être des nombre entiers ou réel   et ce ne sont pas les opérations arithmétiques seulement qui sont supporté.
*/                          
 
 
 
 
       p1.setPU(20);
       p1.setQantité(1);
       p2.setPU(10);
       p2.setQantité(2);
 
 
       System.out.println("Montant totale :" +MontantTotal.getValue()+" €");
       //ça va afficher : Montant totale : 40 €
       p1.setQantité(2);
      //le MontantTotal est encore égale à 40 € 
       System.out.println("Montant totale :" +MontantTotal.getValue()+" €");
       //ça va afficher : Montant totale : 60 €
       //le motant totale est 60 par ce le binding MontantTotal est sollicité  .
 
       //Ajoutons un InvalidationListener pour écouter toute modification sur le binding.
       MontantTotal.addListener(new InvalidationListener() {
 
            @Override
            public void invalidated(Observable o) {
 
                System.out.println("Le montant totale n'est pas valide ");
 
 
            }
        });
 
       p2.setQantité(3);
       //ça va nous afficher : Le montant totale n'est pas valide 
       //Mais MontantTotal est égle à 60 € et non pas 70 €
       System.out.println("Montant totale :" +MontantTotal.getValue()+" €");
       //ça va afficher : Montant totale : 70 €
 
}
}

Voici le resultat

Montant totale :40.0 €
Montant totale :60.0 €
Le montant totale n'est pas valide
Montant totale :70.0 €

On parle d'une évaluation paresseuse du binding, il n'est pas dirrectement évaluer.
Si on ajoute les instructions suivantes après le ligne 54

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
p2.setQantité(3);
p2.setQantité(4);
p2.setPU(50);
p1.setQantité(5);
//on appel après
   System.out.println("Montant totale :" +MontantTotal.getValue()+" €");

Voici le résultat :

Montant totale :40.0 €
Montant totale :60.0 €
Le montant totale n'est pas valide
Montant totale :300.0 €

L'invalidation est écouté une seule fois après plusieurs modification sans sollicitation.
Mais imaginons si on aimerait afficher le montant total dans la méthode qui se déclenche après l'évènement invalidationListener en modifiant le code comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
MontantTotal.addListener(new InvalidationListener() {
 
            @Override
            public void invalidated(Observable o) {
 
                System.out.println("Le montant totale n'est pas valide ,la valeur est : "+((DoubleBinding)o).getValue());
 
 
            }
        });

Résultat après exécution

Montant totale :40.0 €
Montant totale :60.0 €
Le montant totale n'est pas valide, la valeur est : 70.0
Le montant totale n'est pas valide, la valeur est : 80.0
Le montant totale n'est pas valide, la valeur est : 240.0
Le montant totale n'est pas valide, la valeur est : 300.0
Montant totale :300.0 €

Et oui le montant total est sollicité alors il est validé et ensuite affiché.
Ajoutons à présent un écouteur changeListener sur la quantité pour écouter tout changement au niveau de la propriété Quantité,deux importation importantes(Netbeans peut le faire pour vous comme d'hab)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;

je redéfinis le constructeur sans paramètre dans la classe Produit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
public Produit() {
     this.Qantité.addListener(new ChangeListener<Number>() {
 
            @Override
            public void changed(ObservableValue<? extends Number> arg0, Number ancienValeur, Number nuveaValeur) {
             System.out.println("La quantité est changé pour "+Id.get());            }
        });
 
 
    }

Pour ne pas trop encombrer l'affichage diminuons un peu les instructions

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
p2.setQantité(3);
p2.setQantité(4);
p2.setPU(50);
p1.setQantité(5);

et laissons la première
Exécutons notre programme

La quantité est changé pour 1
La quantité est changé pour 2
Montant totale :40.0 €
La quantité est changé pour 1
Montant totale :60.0 €
Le montant totale n'est pas valide, la valeur est : 70.0
La quantité est changé pour 2
Montant totale :70.0 €

Voila pour finir je vais enregistrer un changeListener sur le binding montantTotal voici a nouveau ma classe main

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
public class Main {
   public static void main(String args[]){
       Produit p1=new Produit();p1.setId(1);
       Produit p2=new Produit();p2.setId(2);
 
       DoubleBinding MontantTotal;
       //On peut créer la liaision n'importe où ça ne necessite pas l'initialisation des beans avant
       MontantTotal= Bindings.add(p1.PUProperty().multiply(p1.QantitéProperty()),p2.PUProperty().multiply(p2.QantitéProperty()));
//En tout c'est une addition et non pas un ajout au                         
 
       p1.setPU(20);
       p1.setQantité(1);
       p2.setPU(10);
       p2.setQantité(2);
 
        MontantTotal=  p1.PUProperty().multiply(p1.QantitéProperty())
                                      .add(
                                       p2.PUProperty().multiply(p2.QantitéProperty()));
       System.out.println("Montant totale :" +MontantTotal.getValue()+" €");
       p1.setQantité(2);
      //le MontantTotal est encore égale à 40 € 
       System.out.println("Montant totale :" +MontantTotal.getValue()+" €");
 
       MontantTotal.addListener(new InvalidationListener() {
 
            @Override
            public void invalidated(Observable o) {
 
                System.out.println("Le montant totale n'est pas valide");        
            }  });
 
       MontantTotal.addListener(new ChangeListener() {
 
            @Override
            public void changed(ObservableValue O, Object ancienValeur, Object nouveauValeur) {
                 System.out.println("Le montant totale est changé");
            }
        });
p2.setQantité(3);
p2.setQantité(4);     
p2.setPU(50);
p1.setQantité(5);       
System.out.println("Montant totale :" +MontantTotal.getValue()+" €");
}

On ne demande pas une affichage du MontantTotal au niveau de InvalidationListener pour ne pas le solliciter.
Mais pour ne pas encombrer l'affichage j'ai supprimé le chageLsitener au niveau de la quantité du produit.
Après l’exécution on a ceci:

Montant totale :40.0 €
Le montant totale n'est pas valide
Le montant totale est changé
Le montant totale n'est pas valide
Le montant totale est changé
Le montant totale n'est pas valide
Le montant totale est changé
Le montant totale n'est pas valide
Le montant totale est changé
Montant totale :300.0 €

Contrairement à ce qu'on avait après l'ajout seulement de InvalidationListener , vu que ce listener n'écoute qu'une seul fois on avait l'affichage suivant :

Montant totale :40.0 €
Montant totale :60.0 €
Le montant totale n'est pas valide
Montant totale :300.0 €

Par contre l'ajout de changeListener entraîne une validation et évaluation automatique après chaque modification d'une des propriété qui sont liés pour former le binding. A noter aussi que les propriété aussi implementent l'interface Observable alors ils supportent l'invalidationListener. Quand on fait un set(...) la propriété ne contient pas directement la nouvelle valeur à moins qu'il soit sollicité ou un évènement changeListener est enregistrer(ces écouteur d'invalidation sont utiles, déjà le fait d'attendre une sollicitation pour s’exécuter c'est un gains ,imaginez une très longue binding et complexe et plusieurs modification et des annulation en cours du programme, le binding ne sera pas recalculé à chaque fois mais seulement quand on valide).Tout ces exemples n'est qu'une utilisation de l'API de haut niveau. Mais il y a une API de bas niveau, c'est un niveau avancée, ça consomme moins de mémoire et très rapide

Pour finir sur la synchronisation ,j'accepte que les binding font aussi de la synchronisation sur la manipulation des propriété,mais pas toujours. Cependant, pensez vous qu'on pourrait appeler MontantTotal comme une synchronisation?

[bouye]

Pour faire court, de manière générale, et pour des raisons de performances, l'implémentation du binding dans JavaFX 2.0 n'est pas synchrone. Généralement elle est asynchrone sauf si à un moment donné on a placé un ChangeListener.

Pas de listener ou InvalidationListener => évaluation asynchrone lors de l'appel suivant à la valeur ou expression bindée/cible.
ChangeListener => évaluation synchrone immédiate de la valeur ou expression bindée/cible.

[Teocali]

Ah ben tiens, ça je savais pas. C'est une bonne info, mine de rien. Ca peut expliquer certain "glitch" que j'avais rencontré...

[bouye]

Lorsqu'on nous a présenté le binding lors de la session "JavaFX Properties and Bindings for Experts (and Those Who Want to Become Experts)", on nous a explique que, généralement l'API de haut niveau (ex: les méthodes bind() et bindBidirectional() ainsi que les méthodes utilitaires fournies dans les classes propriétés pour faire des calculs) est suffisante pour la plupart des binding mais que dans le cas d'expression complexe, il vaudrait mieux écrire soit même le binding en appelant l'API de bas niveau car cela permet de contrôler plus finement si on veut que l’évaluation soit synchrone ou asynchrone ou améliorer les performances.