FAQ JDBCConsultez toutes les FAQ

L'interface RowSet est une extension de ResultSet. Comme sa super interface, RowSet représente un ensemble de données tabulaires. Le but de cette interface est d'ajouter aux ResultSet : facilité d'utilisation, flexibilité et indépendance.

Facilité d'utilisation et flexibilité

Le principal avantage des RowSet est le fait qu'ils ajoutent à l'API JDBC toute la puissance des JavaBeans. Ce qui signifie des facilités pour :

• la gestion des propriétés : on peut facilement configurer un RowSet grâce à un ensemble de méthodes setXXX. Ces méthodes permettent, par exemple, de spécifier le nom de l'utilisateur, l'URL de connexion ou encore une commande (instruction) SQL ;
• la gestion des événements : les RowSetListener peuvent se mettre à l'écoute des événements relatifs aux RowSet.
  

• par rapport à l'API : tous les types de RowSet sont capables de se connecter et de lancer une instruction SQL. Il n'est plus nécessaire de passer explicitement par une Connection ou un Statement ;
• par rapport au matériel utilisé : tous les types de RowSet peuvent être mis à jour et permettent n'importe quel mouvement du curseur. Donc, vous pourrez utiliser ces fonctionnalités même si la base de données ou le driver ne les fournissent pas directement.
  

On peut séparer les différents RowSet en deux catégories principales : les connectés et les déconnectés. En voici les caractéristiques :

• connectés : en dehors des propriétés générales des RowSet, leur fonctionnement est identique à celui d'un ResultSet. C'est-à-dire que ceux-ci gardent une connexion ouverte vers le SGBD durant tout leur cycle de vie ;
• déconnectés : les RowSet de cette catégorie sont capables de rompre la connexion à la source, faire des modifications sur les données, puis de se reconnecter afin de transmettre les modifications, tout en gérant un éventuel conflit.
  

Sun propose cinq interfaces filles de RowSet et leur implémentation. On pourra remarquer que si RowSet fait partie du package javax.sql, les autres types font partie du package javax.sql.rowset (disponible seulement depuis la version 1.5 de Java). Voici les différents types de RowSet, leurs caractéristiques et leurs avantages :

• RowSet : super interface de tous les autres types. Définie depuis JDBC 2.0 ;
• CachedRowSet : RowSet déconnecté stockant ses données en mémoire. Il n'est pas particulièrement adapté à de grandes quantités de données. Par contre, il est parfaitement adapté pour fournir aux clients légers (comme les PDA (Personal Digital Assistant) ou les téléphones portables) des données tabulaires, provenant d'une base de données ;
• WebRowSet : RowSet déconnecté. Particulièrement adapté aux applications web, grâce à sa faculté de lire (écrire) ses données à partir (sous forme) de fichiers XML ou de flux de données ;
• FilteredRowSet : RowSet déconnecté. Permettant de filtrer les données présentées à l'utilisateur grâce à la classe Predicate ;
• JoinRowSet : RowSet déconnecté. Permettant de réaliser facilement des JOIN à partir de toute classe ou interface implémentant Joinable.
• JdbcRowSet : RowSet connecté. C'est une enveloppe légère autour d'un ResultSet permettant de faire du driver JDBC un bean Java.
  

Il y a généralement trois étapes rencontrées durant la création d'un RowSet. La première de ces étapes est l'obtention d'une instance du RowSet désiré. Vient ensuite la spécification des propriétés de l'instance. Enfin, il ne reste plus qu'à « peupler » ce RowSet, c'est-à-dire le remplir des données souhaitées.

Voici deux cas de figure :

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
. 
//CHARGEMENT DU DRIVER 
Class.forName("com.mysql.jdbc.Driver"); 
//CREATION DE LA CONNEXION 
String url = "jdbc:mysql://localhost/maBase"; 
String user = "utilisateur"; 
String password = "motDePasse"; 
connection = DriverManager.getConnection(url,user,password); 
//RECUPERATION D'UN RESULTSET 
Statement statement = connection.createStatement( 
       ResultSet.TYPE_FORWARD_ONLY, 
       ResultSet.CONCUR_READ_ONLY); 
String sql = "SELECT * FROM Annuaire"; 
ResultSet resultat = statement.executeQuery(sql); 
//CREATION D'UN ROWSET 
CachedRowSet rowset = new CachedRowSetImpl(); 
//propriétés du RowSet 
rowset.setType(ResultSet.TYPE_SCROLL_INSENSITIVE); 
rowset.setConcurrency(ResultSet.CONCUR_UPDATABLE); 
//peuplement du RowSet avec les données du ResultSet 
rowset.populate(resultat); 
//FERMETURE DE LA CONNECTION 
connection.close(); 
System.out.println(connection.isClosed()); 
//FINALEMENT TRAITEMENT DES DONNEES HORS CONNECTION 
while(rowset.previous()){ 
  
}

• la facilité de remplissage du RowSet : la simple ligne rowset.populate(resultat) permet de peupler le RowSet avec les données contenues dans le ResultSet ;
• la possibilité de travailler hors connexion : ici le traitement se fait après la fermeture de la connexion ;
• une plus grande indépendance par rapport à la base et au pilote : même si le ResultSet ne peut pas être mis à jour (ou si le pilote ne permet pas cette option), le RowSet créé lui le sera.
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
. 
//CREATION DU ROWSET 
JdbcRowSet rowset = new JdbcRowSetImpl(); 
//MISE EN PLACE DES DIFFERENTES PROPRIETES 
String url = "jdbc:mysql://localhost/MaBase"; 
String user = "utilisateur"; 
String password = "motDePasse"; 
String command = "SELECT * FROM Annuaire WHERE nom = ?"; 
//propriétés nécessaires à la connexion 
rowset.setUrl(url); 
rowset.setUsername(user); 
rowset.setPassword(password); 
//propriétés nécessaires à l'exécution 
rowset.setCommand(command); 
rowset.setString(1,"unNom"); 
//EXECUTION DU ROWSET POUR LE PEUPLER 
rowset.execute(); 
//puis traitement des différentes données

• plus besoin de créer explicitement une Connection ;
• plus besoin de créer explicitement un Statement ;
• facilité du passage d'arguments à l'instruction SQL (plus de passage par un PreparedStatement et la syntaxe d'échappement).
  

L'utilisation des RowSet est, quasiment en tous points identique à celle des ResultSet. Cela implique les mouvements du curseur, la récupération des données et l'étude des métadonnées. Une des seules différences notables se fait lors de la mise à jour des données pour les RowSet déconnectés (cf. la partie dédiée). Voici un exemple utilisant JdbcRowSet :

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
try{ 
//CHARGEMENT DU DRIVER 
Class.forName("com.mysql.jdbc.Driver"); 
//CREATION D'UN ROWSET 
JdbcRowSet rowset = new JdbcRowSetImpl(); 
//propriétés du RowSet 
rowset.setUrl("jdbc:mysql://localhost/maBase"); 
rowset.setUserName("utilisateur"); 
rowset.setPassword("motdePasse"); 
rowset.setType(ResultSet.TYPE_SCROLL_INSENSITIVE); 
rowset.setConcurrency(ResultSet.CONCUR_UPDATABLE); 
rowset.setCommand("SELECT nom, prenom FROM Annuaire"); 
//exécution et peuplement du RowSet 
rowset.execute(); 
//TRAITEMENT DES DONNEES 
rowset.last(); 
//parcours des résultats du dernier au premier tuple 
while(rowset.previous()){ 
   System.out.println("Nom = "+rowset.getObject("nom")+ 
                        " Prenom = "+rowset.getString(2)); 
} 
//modification de la colonne d'index 1 de la première ligne 
rowset.first(); 
rowset.updateString(1,"modification"); 
rowset.updateRow(); 
//positionnement sur la seconde ligne et suppression de celle-ci 
rowset.relative(1); 
rowset.deleteRow(); 
//insertion d'une nouvelle ligne 
rowset.moveToInsertRow(); 
rowset.updateString("prenom", "un nouveau prénom"); 
rowset.updateString("nom", "un nouveau nom"); 
rowset.insertRow(); 
rowset.moveToCurrentRow(); 
//etc.

Un nouveau type de listener est disponible dans le package javax.sql : RowSetListener. On peut ajouter ou supprimer un tel type de listener à un RowSet grâce aux méthodes addRowSetListener et removeRowSetListener. Par exemple :

1
2
3
4
5
6
7
8
9
10
11
rowset.addRowSetListener(new RowSetListener(){ 
   public void cursorMoved(RowSetEvent rse){ 
      System.out.println("Le curseur à bougé\n"+rse); 
   } 
   public void rowChanged(RowSetEvent rse){ 
      System.out.println("Une ligne du RowSet à changé\n"+rse); 
   } 
   public void rowSetChanged(RowSetEvent rse){ 
      System.out.println("Le RowSet a complètement changé\n"+rse); 
   } 
});