De l'art et de la manière de définir des propriétés dans vos objets JavaFX, un tutoriel de Fabrice Bouyé

Bonjour, après une longue attente et pas mal de soucis techniques de mon coté, je vous propose un article sur la définition des propriétés en JavaFX.

http://fabrice-bouye.developpez.com/...afxproperties/

Vous pouvez profiter de ce message pour partager vos commentaires et surtout n’hésitez pas à m'indiquer toutes erreurs, omissions ou encore des éventuels bugs.
D'autres articles complémentaires sur le binding de haut niveau et de bas niveau sont également en préparation.

Félicitation pour cet article, et quand il sera publié sur le portail, si je n'avais pas fais un tour ici, je n'allais pas trouver ça.
J'ai commencé un mais je n'arrive pas encore à le finir

En fait il aurait pu être publié depuis longtemps mais j'ai eut beaucoup de soucis avec les outils de publication du forum (en partie a cause de notre connexion internet pourrie).

Félicitations, c'est vraiment du très bon travail.

A priori la classe TableColumnBuilder est devenue deprecated (indiqué par mon IDE) ainsi que pas mal d'autres *Builder : http://mail.openjdk.java.net/piperma...ch/006725.html

Du coup, comment peut-on réécrire le code que tu proposes dans ta partie V-D ?

1 pièce(s) jointe(s)

En effet, tout les builders sont deprecated dans le JDK8 et disparaitront dans le JDK 9.

Il suffit de remplacer :

Code:

TableColumn<Dog, String> nameColumn = TableColumnBuilder.<Dog, String>create().text("Name").build();

Par :

Code:

TableColumn<Dog, String> nameColumn = new TableColumn<>("Name");

La correction a été postée dans l'article.

À propos de TableView, je vous met ici le code (JDK7) un peu plus complet qui permet d'avoir une TableView avec des colonnes contenant des booléens et des textes provenant de 3 sources et surtout de modifier leur valeur :

Des propriétés FX
Des propriétés JavaBeans observables (c-a-d avec toute la plomberie événementielle qui va bien derrière).
des champs en accès direct (ou ça pourrait être aussi des propriétés JavaBeans non-observables via des getter/setters).

test.Main.java

Code:

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package test;
 
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.net.URL;
import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.fxml.FXMLLoader;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
 
public class Main extends Application {
 
    @Override
    public void start(Stage primaryStage) throws IOException {
        final URL fxmlURL = getClass().getResource("Test.fxml");
        final FXMLLoader fxmlLoader = new FXMLLoader(fxmlURL);
        final Node node = (Node) fxmlLoader.load();
        final TestController controller = (TestController) fxmlLoader.getController();
        StackPane root = new StackPane();
        root.getChildren().add(node);
 
        Scene scene = new Scene(root, 700, 250);
 
        primaryStage.setTitle("Hello World!");
        primaryStage.setScene(scene);
        primaryStage.show();
 
        ////////////////////////////////////////////////////////////////////////
        final ChangeListener<Boolean> visibleListener = new ChangeListener<Boolean>() {
            @Override
            public void changed(ObservableValue<? extends Boolean> ov, Boolean oldValue, Boolean newValue) {
                System.out.printf("Visible %b -> %b", oldValue, newValue).println();
            }
        };
        final ChangeListener<String> nameListener = new ChangeListener<String>() {
            @Override
            public void changed(ObservableValue<? extends String> ov, String oldValue, String newValue) {
                System.out.printf("Name %s -> %s", oldValue, newValue).println();
            }
        };
        final PropertyChangeListener oldStyleListener = new PropertyChangeListener() {
 
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                System.out.printf("%s %s -> %s", evt.getPropertyName(), evt.getOldValue(), evt.getNewValue()).println();
            }
        };
        final Truc t1 = new Truc();
        t1.setName("Foo");
        t1.nameProperty().addListener(nameListener);
        t1.setVisible(true);
        t1.visibleProperty().addListener(visibleListener);
        t1.setOpaque(true);
        t1.addPropertyChangeListener("opaque", oldStyleListener);
        t1.setComment("Comment #1");
        t1.addPropertyChangeListener("comment", oldStyleListener);
        t1.administrator = true;
        t1.email = "foo@foo.foo";
        final Truc t2 = new Truc();
        t2.setName("Fuu");
        t2.nameProperty().addListener(nameListener);
        t2.setVisible(false);
        t2.visibleProperty().addListener(visibleListener);
        t2.setOpaque(false);
        t2.addPropertyChangeListener("opaque", oldStyleListener);
        t2.setComment("Comment #2");
        t2.addPropertyChangeListener("comment", oldStyleListener);
        t2.administrator = false;
        t2.email = "fuu@fuu.fuu";
        controller.getTrucs().addAll(t1, t2);
    }
 
    /**
     * The main() method is ignored in correctly deployed JavaFX 
     * application. main() serves only as fallback in case the 
     * application can not be launched through deployment artifacts,
     * e.g., in IDEs with limited FX support. NetBeans ignores main().
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        launch(args);
    }
}

test.Truc.java

Code:

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package test;
 
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
 
public class Truc {
    ////////////////////////////////////////////////////////////////////////////
    // JavaFX Properties.
    private final BooleanProperty visible = new SimpleBooleanProperty();
 
    public final boolean isVisible() {
        return visible.get();
    }
 
    public final void setVisible(boolean value) {
        visible.set(value);
    }
 
    public final BooleanProperty visibleProperty() {
        return visible;
    }
    private final StringProperty name = new SimpleStringProperty();
 
    public final String getName() {
        return name.get();
    }
 
    public final void setName(String value) {
        name.set(value);
    }
 
    public final StringProperty nameProperty() {
        return name;
    }
    ////////////////////////////////////////////////////////////////////////////
    // Java Beans Properties.
    private final PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
 
    public final void addPropertyChangeListener(String property, PropertyChangeListener listener) {
        propertyChangeSupport.addPropertyChangeListener(property, listener);
    }
 
    public final void removePropertyChangeListener(String property, PropertyChangeListener listener) {
        propertyChangeSupport.removePropertyChangeListener(property, listener);
    }
 
    private final void firePropertyChange(String property, Object oldValue, Object newValue) {
        propertyChangeSupport.firePropertyChange(property, oldValue, newValue);
    }
    private boolean opaque = false;
 
    public boolean isOpaque() {
        return opaque;
    }
 
    public void setOpaque(boolean value) {
        final boolean oldValue = opaque;
        opaque = value;
        firePropertyChange("opaque", oldValue, opaque);
    }
    private String comment;
 
    public String getComment() {
        return comment;
    }
 
    public void setComment(String value) {
        final String oldValue = comment;
        comment = value;
        firePropertyChange("comment", oldValue, comment);
    }
 
    ////////////////////////////////////////////////////////////////////////////
    // Other
 
    public boolean administrator;
    public String email;
}

test.Test.fxml

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?xml version="1.0" encoding="UTF-8"?>
 
<?import java.lang.*?>
<?import java.util.*?>
<?import javafx.scene.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>
 
<AnchorPane id="AnchorPane" fx:id="rootPane" prefHeight="400.0" prefWidth="600.0" xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/2.2" fx:controller="test.TestController">
  <children>
    <TableView fx:id="tableView" editable="true" prefHeight="200.0" prefWidth="200.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
      <columns>
        <TableColumn prefWidth="75.0" text="Visible" fx:id="visibleColumn" />
        <TableColumn prefWidth="75.0" text="Name" fx:id="nameColumn" />
        <TableColumn prefWidth="75.0" text="opaque" fx:id="opaqueColumn" />
        <TableColumn prefWidth="75.0" text="Comment" fx:id="commentColumn" />
        <TableColumn prefWidth="75.0" text="Administrator" fx:id="administratorColumn" />
        <TableColumn prefWidth="75.0" text="Email" fx:id="emailColumn" />
      </columns>
    </TableView>
  </children>
</AnchorPane>

test.TestController.java

Code:

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package test;
 
import java.net.URL;
import java.util.LinkedList;
import java.util.ResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.beans.property.ListProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleListProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.adapter.JavaBeanBooleanPropertyBuilder;
import javafx.beans.property.adapter.JavaBeanStringPropertyBuilder;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.cell.CheckBoxTableCell;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.control.cell.TextFieldTableCell;
import javafx.util.Callback;
 
public final class TestController implements Initializable {
 
    @FXML
    private TableView<Truc> tableView;
    ////////////////////////////////////////////////////////////////////////////
    // JavaFX properties.
    @FXML
    private TableColumn<Truc, Boolean> visibleColumn;
    @FXML
    private TableColumn<Truc, String> nameColumn;
    ////////////////////////////////////////////////////////////////////////////
    // Java Beans properties.
    @FXML
    private TableColumn<Truc, Boolean> opaqueColumn;
    @FXML
    private TableColumn<Truc, String> commentColumn;
    ////////////////////////////////////////////////////////////////////////////
    // Java Beans properties.
    @FXML
    private TableColumn<Truc, Boolean> administratorColumn;
    @FXML
    private TableColumn<Truc, String> emailColumn;
 
    @Override
    public void initialize(URL url, ResourceBundle rb) {
        tableView.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
        tableView.itemsProperty().bind(trucs);
        ////////////////////////////////////////////////////////////////////////
        // JavaFX properties.
        visibleColumn.setCellValueFactory(new PropertyValueFactory<Truc, Boolean>("visible"));
        visibleColumn.setCellFactory(CheckBoxTableCell.forTableColumn(visibleColumn));
        nameColumn.setCellValueFactory(new PropertyValueFactory<Truc, String>("name"));
        nameColumn.setCellFactory(TextFieldTableCell.<Truc>forTableColumn());
        ////////////////////////////////////////////////////////////////////////
        // Java Beans properties.
        opaqueColumn.setCellValueFactory(new Callback<TableColumn.CellDataFeatures<Truc, Boolean>, ObservableValue<Boolean>>() {
            @Override
            public ObservableValue<Boolean> call(TableColumn.CellDataFeatures<Truc, Boolean> p) {
                final Truc t = p.getValue();
                try {
                    return JavaBeanBooleanPropertyBuilder.create().bean(t).name("opaque").build();
                } catch (NoSuchMethodException ex) {
                    Logger.getLogger(TestController.class.getName()).log(Level.SEVERE, null, ex);
                    return null;
                }
            }
        });
        opaqueColumn.setCellFactory(CheckBoxTableCell.forTableColumn(opaqueColumn));
        commentColumn.setCellValueFactory(new Callback<TableColumn.CellDataFeatures<Truc, String>, ObservableValue<String>>() {
            @Override
            public ObservableValue<String> call(TableColumn.CellDataFeatures<Truc, String> p) {
                final Truc t = p.getValue();
                try {
                    return JavaBeanStringPropertyBuilder.create().bean(t).name("comment").build();
                } catch (NoSuchMethodException ex) {
                    Logger.getLogger(TestController.class.getName()).log(Level.SEVERE, null, ex);
                    return null;
                }
            }
        });
        commentColumn.setCellFactory(TextFieldTableCell.<Truc>forTableColumn());
        ////////////////////////////////////////////////////////////////////////
        // Other.
        administratorColumn.setCellValueFactory(new Callback<TableColumn.CellDataFeatures<Truc, Boolean>, ObservableValue<Boolean>>() {
            @Override
            public ObservableValue<Boolean> call(TableColumn.CellDataFeatures<Truc, Boolean> p) {
                final Truc t = p.getValue();
                ObservableValue<Boolean> result = new SimpleBooleanProperty(t.administrator);
                // Hack to bypass the issue where the onEditCommit handler on the administratorColumn is never called.
                result.addListener(new ChangeListener<Boolean>() {
 
                    @Override
                    public void changed(ObservableValue<? extends Boolean> ov, Boolean oldValue, Boolean newValue) {
                        t.administrator = newValue;
                    }
                });
                return result;
            }
        });
        administratorColumn.setCellFactory(CheckBoxTableCell.forTableColumn(administratorColumn));
        administratorColumn.setOnEditCommit(new EventHandler<TableColumn.CellEditEvent<Truc, Boolean>>() {
            @Override
            public void handle(TableColumn.CellEditEvent<Truc, Boolean> editEvent) {
                // This method is never called! (see above for a fix).
                final Truc t = (Truc) editEvent.getTableView().getItems().get(editEvent.getTablePosition().getRow());
                t.administrator = editEvent.getNewValue();
            }
        });
        emailColumn.setCellValueFactory(new Callback<TableColumn.CellDataFeatures<Truc, String>, ObservableValue<String>>() {
            @Override
            public ObservableValue<String> call(TableColumn.CellDataFeatures<Truc, String> p) {
                final Truc t = p.getValue();
                return new SimpleStringProperty(t.email);
            }
        });
        emailColumn.setCellFactory(TextFieldTableCell.<Truc>forTableColumn());
        emailColumn.setOnEditCommit(new EventHandler<TableColumn.CellEditEvent<Truc, String>>() {
            @Override
            public void handle(TableColumn.CellEditEvent<Truc, String> editEvent) {
                // Called ok.
                final Truc t = (Truc) editEvent.getTableView().getItems().get(editEvent.getTablePosition().getRow());
                t.email = editEvent.getNewValue();
            }
        });
    }
    ////////////////////////////////////////////////////////////////////////////
    private final ListProperty<Truc> trucs = new SimpleListProperty<>(FXCollections.observableList(new LinkedList()));
 
    public final ObservableList<Truc> getTrucs() {
        return trucs;
    }
}

Pièce jointe 141050

En complément de cet article, je vous conseille également ce blog "Soucis avec les WeakListener" de Mike Mikula, qui apporte un peu d’éclaircissement sur les soucis que peuvent occasionner les écouteurs utilisant des références faibles.

Concernant son point #2 (l’écouteur à référence faible libère bien l’écouteur cible mais la référence à l’écouteur faible est elle conservée et utilise toujours de la mémoire), le soucis, reste le même que partout ailleurs en Java où on utilise le pattern observateur (donc surtout dans les UI) : même si on nous rabâche les oreilles avec le garbage collector, si vous avez des fuites mémoire, c'est probablement que vous n'avez pas désengeristré vos écouteurs.