Bonjour,

Je me pose une questione existencielle : comment Binder les MAJ d'une Table SQL.
- Est-ce qu'on peut Binder une synchro à 100% Table/Tableview?
- Ou est-ce qu'on doit gérer les MAJ (Insert/Update/Delete) et gérer un refresh à base de select?

Concernant mon code actuel, j'ai un FXML déclaré dans le JAVA
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
    private TableView<Compte> table;
    @FXML
    private TableColumn<Compte, String> COL_ID;
    @FXML
    private TableColumn<Compte,String> COL_Nom;
    @FXML
    private TableColumn<Compte,String> COL_Banque;
etc... (les puristes pourront noter que je merdoie à gérer mon ID en affichage de type INT).

J'ai un CallBack :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
        table.setEditable(true);
        Callback<TableColumn<Compte,String>, TableCell<Compte,String>> CellFactory = new Callback<TableColumn<Compte,String>, TableCell<Compte,String>>() { 
            @Override
            public TableCell call(TableColumn p) { 
                return new EditingCell(); 
            } 
        };
Pour chaque colonne, je lie les colonnes du Tableview à une classe de données perso :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
        //-------------------------------( Bind des colonnes
        COL_ID.setCellValueFactory(new PropertyValueFactory<Compte, String>("ID"));
        COL_ID.setCellFactory(CellFactory);
        COL_ID.setOnEditCommit(
                new EventHandler<CellEditEvent<Compte, String>>() {
        @Override
        public void handle(CellEditEvent<Compte, String> t) {
            ((Compte) t.getTableView().getItems().get(
                t.getTablePosition().getRow())
                ).setID(t.getNewValue());
            }
        });
Le select fonctionne (j'ai externalisé la connexion BDD). :
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
        Connection c;
        try {
            c = DBConnect.connect();
            //SQL sélection des comptes
            String SQL = "SELECT * from T_Comptes";
            //ResultSet
            ResultSet rs = c.createStatement().executeQuery(SQL);
            while (rs.next()) {
                Compte Enregistrement = new Compte(rs.getString(1),rs.getString(2),rs.getString(3),rs.getString(4),rs.getString(5),rs.getString(6),rs.getString(7));
                //Enregistrement.ID =SimpleIntegerProperty(rs.getInt(1));
                Enregistrement.ID.set(rs.getString(1));
                Enregistrement.NOM.set(rs.getString(2));
                Enregistrement.BANQUE.set(rs.getString(3));
                Enregistrement.AGENCE.set(rs.getString(4));
                Enregistrement.COMPTE.set(rs.getString(5));
                Enregistrement.CLE.set(rs.getString(6));
                Enregistrement.COMMENT.set(rs.getString(7));
                data.add(Enregistrement);      
                System.out.println(rs.getString(5));                
                System.out.println(Enregistrement);
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Erreur de construction données SQL");
        }
        System.out.println(data);
        table.setItems(data);
J'arrive à ajouter des lignes en visuelk (mais pas dans la BDD :p) via des textfields :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
    @FXML
    public void BTN_Enregistrer_Action(ActionEvent event) {
        data.add(new Compte(
            //Integer.parseInt(ADD_ID.getText()),    
            ADD_ID.getText(),
            ADD_NOM.getText(),    
            ADD_BANQUE.getText(),
            ADD_AGENCE.getText(),
            ADD_COMPTE.getText(),
            ADD_CLE.getText(),
            ADD_COMMENT.getText()
La classe de données :
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
public static class Compte {
        //private final SimpleIntegerProperty ID;
        private final SimpleStringProperty ID;
        private final SimpleStringProperty NOM;
        private final SimpleStringProperty BANQUE;
        private final SimpleStringProperty AGENCE;
        private final SimpleStringProperty COMPTE;
        private final SimpleStringProperty CLE;
        private final SimpleStringProperty COMMENT;
 
        private Compte(String id, String nom, String banque, String agence, String compte, String cle, String comment) {
            //this.ID = new SimpleIntegerProperty(id);
            this.ID = new SimpleStringProperty(id);
            this.NOM = new SimpleStringProperty(nom);
            this.BANQUE = new SimpleStringProperty(banque);
            this.AGENCE = new SimpleStringProperty(agence);
            this.COMPTE = new SimpleStringProperty(compte);
            this.CLE = new SimpleStringProperty(cle);
            this.COMMENT = new SimpleStringProperty(comment);
    }
Les fonctions de la classe (je met que le premier champ, tout est pareil pour toutes les données).
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
    public String getID()                  { return ID.get(); }
    public void setID(String id)           { ID.set(id); }
Et enfin les fonctions qui vont bien pour éditer en direct le tableview :
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
66
67
68
69
   public static class EditingCell extends TableCell<Compte, String> {
 
        private TextField Text_Into_Tableview = new TextField();
 
        public EditingCell() {
        }
 
        @Override
        public void startEdit() {
            Text_Into_Tableview.setId("Text_Into_Tableview");
            Text_Into_Tableview.setStyle("-fx-background-color: black;");
            if (!isEmpty()) {
                super.startEdit();
                createTextField();
                setText(null);
                setGraphic(Text_Into_Tableview);
                Text_Into_Tableview.selectAll();
            }
        }
 
        @Override
        public void cancelEdit() {
            super.cancelEdit();
 
            setText((String) getItem());
            setGraphic(null);
        }
 
        @Override
        public void updateItem(String item, boolean empty) {
            super.updateItem(item, empty);
 
            if (empty) {
                setText(null);
                setGraphic(null);
            } else {
                if (isEditing()) {
                    if (Text_Into_Tableview != null) {
                        Text_Into_Tableview.setText(getString());
                    }
                    setText(null);
                    setGraphic(Text_Into_Tableview);
                } else {
                    setText(getString());
                    setGraphic(null);
                }
            }
        }
 
        private void createTextField() {
            Text_Into_Tableview = new TextField(getString());
            Text_Into_Tableview.setMinWidth(this.getWidth() - this.getGraphicTextGap()* 2);
            Text_Into_Tableview.focusedProperty().addListener(new ChangeListener<Boolean>(){
                @Override
                public void changed(ObservableValue<? extends Boolean> arg0, 
                    Boolean arg1, Boolean arg2) {
                        if (!arg2) {
                            commitEdit(Text_Into_Tableview.getText());
                        }
                }
            });
        }
 
        private String getString() {
            return getItem() == null ? "" : getItem().toString();
        }
    }
 
}
Pour trouver tout ça j'ai surfé comme un âne, d'où le résultat de bourricot ou je suis un peu bloqué.

Si personne ne me donne de tuyau, je crois que je ferai marche arrière sur le côté éditable du tableview, pour tout gérer manuellement sur un tableview d'affichage, et des textfields sous forme de miniform, avec gestion de lecture/Modif/ajout/suppression et des séquences d'ordres sql.

Des idées?
Par avance merci à tous!!!

Et que le FX soit avec votre Java...