SwingWorker + jtable + accès mysql

**kimausoleil** · 28/01/2010, 16h32

Bonjour !

J'ai commencé à développer une application java mysql qui semble bien marcher.

J'ai des objets simples créés et ajoutés dans une collection de type ArrayList par un chargement avec ma base MySql.

Mon objet :

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
 
public class Personne {
 
   private String nom;
   private String prenom;
 
   public Personne(String nom, String prenom) {
      this.nom=nom;
      this.prenom=prenom;
   }
 
    @Override
    public String toString() {
        return nom + " " + prenom;
    }
 
}

Mon ArrayList qui charge par MySQL

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
 
public class PersonnesList extends ArrayList {
 
   public Personnes() {
      super();
   }
 
   public void load() {
 
      String requete = "SELECT nom, prenom FROM personne";
 
      Statement st = null;
      ResultSet rs = null;
 
      clear();
      try {
         st = Kernel.getConnexion().createStatement();
         rs = st.executeQuery(requete);
 
         while ( rs.next() )
            add(new Adresse(
                             rs.getString("nom"), 
                             rs.getString("prenom"))
                        );
 
      } catch (SQLException ex) {
         System.out.println("Impossible de charger la liste des personnes : " + ex.getMessage());
      } finally {
         try {
            if (rs != null) rs.close();
            if (st != null) st.close();
            rs = null;
            st = null;
         } catch (SQLException ex) {}
      }
   }
}

Cette collection est lue (et chargée) dans le model de mon jtable.

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
 
public class PersonneTableModel extends AbstractTableModel {
 
   private PersonnesList maListe;
 
   public PersonneTableModel() {
      super();
      maListe = new PersonnesList();
   }
 
    @Override
    public int getColumnCount() {
        return Integer.valueOf(1);
    }
 
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
 
        Object value = "";
 
        try {
            Personne p = (Personne) maListe.get(rowIndex);
            value = p;
        } catch (Exception ex) {}
 
        return value;
    }
 
   /**
    * pour charger
    */
   public void load() {
      maListe.load();
      fireTableDataChanged();
   }
 
}

Et tout ça est chargé à partir d'un Thread... un peu bourrin, sans utiliser SwingWorker ou SwingUtilities, ce qui fait que je ne respecte pas du tout EDT !

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
 
public class PersonneFrame extends JFrame {
 
   private JTable maTable;
   private PersonneTableModel monModel;
 
   public PersonneFrame() {
      super();
      /*
       * etc... (on dessine la fenêtre)
       */
 
      monModel = new PersonneTableModel();
      maTable = new JTable(monModel);
 
      //voici le lieu du crime...
      new Thread( new Runnable() {
                           @Override
                           public void run() {
                              monModel.load();
                           }
                        }).start();
 
   }
 
}

J'ai fait certainement de grosses erreurs avec cet appel de Thread un peu cavalier.
Comme ça fait un peu moins d'un mois que je suis passé à java, j'aimerais vraiment partir sur de bonnes bases !

Donc si je dois mettre mon SwingWorker (ou SwingUtilities ?) à la place de mon Thread, ça serait plutôt dans le TableModel ?
Par ailleurs, ma collection de Personnes s'utilisera un peu partout dans mon programme... donc la contrainte et de bien séparer l'accès aux données de l'interface.

Merci de vos réponses et de vos conseils avisés.

**fr1man** · 28/01/2010, 17h00

Le plus propre serait effectivement d'utiliser Swingworker, le problème étant que ton fireTableDataChanged() n'est pas exécuté dans l'EDT.

**kimausoleil** · 28/01/2010, 17h42

Heu... oui !

Le plus propre serait effectivement d'utiliser Swingworker

En gros un truc comme ça dans mon TableModel :

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
 
 
   /**
    * pour charger
    */
   public void load() {
 
 //     maListe.load();
 //     fireTableDataChanged();
 
      new LoadWorker().execute();
 
   }
 
   /**
    * mon worker
    */
    private class LoadWorker extends SwingWorker<Boolean, Boolean> {
 
        public LoadWorker() {
            super();
        }
 
        @Override
        protected Boolean doInBackground() {
            maListe.load();
            return true;
        }
 
        @Override
        protected void done() {
            fireTableDataChanged();
        }
 
    }

Appelé par ma JFrame :

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
 
public class PersonneFrame extends JFrame {
 
   private JTable maTable;
   private PersonneTableModel monModel;
 
   public PersonneFrame() {
      super();
      /*
       * etc... (on dessine la fenêtre)
       */
 
      monModel = new PersonneTableModel();
      maTable = new JTable(monModel);
 
/*
      //voici le lieu du crime...
      new Thread( new Runnable() {
                           @Override
                           public void run() {
                              monModel.load();
                           }
                        }).start();
*/
      /**************
       * fini le thread, place on worker !
       *
       */
      monModel.load();
 
   }
 
}