Simplifiez-vous JDBC avec Jakarta Commons DbUtils

Toutes les méthodes de cette classe sont statiques. Ce sont des méthodes utilitaires qui permettent de faire toutes les tâches de routines s'articulant autour de l'utilisation d'une base de données (chargement de driver JDBC, ouverture et fermeture de connexions). Nous allons voir quelques-unes de ces méthodes :

• loadDriver(String driverClassName) : cette méthode charge et enregistre le driver JDBC et retourne TRUE en cas de succès. L'utilisation de cette méthode rend le code plus lisible puisqu'elle dispense de la gestion de l'exception ClassNotFoundException. De plus on dispose alors d'un booléen pour savoir si le chargement s'est bien effectué ;
• close() : cette méthode peut accepter un Connection, un Statement ou un ResultSet. Elle vérifie si l'argument fourni est null, et s'il ne l'est pas, elle le ferme. Elle est susceptible de renvoyer une SQLException ;
• closeQuietly() : elle a la même fonction que la précédente, mais masque l'éventuelle SQLException qui peut survenir. Elle présente en plus une version acceptant les trois arguments en simultané : closeQuietly(Connection conn, Statement stmt, ResultSet rs). Ce qui permet de réduire à une ligne la fermeture des trois objets se faisant généralement dans les blocs finally ;
• commitAndCloseQuietly(Connection conn) : cette méthode effectue un « commit » sur la connexion et la ferme sans remonter aucune des Exceptions pouvant survenir.

L'implémentation de cette interface par une classe lui permet de manipuler des ResultSet et convertir les données qu'ils contiennent dans une autre forme. L'API fournit huit implémentations de cette interface permettant d'obtenir au choix : un tableau, un Bean, un Map, un List des précédents objets ou une gestion du ResultSet par colonne (une colonne dans un objet ou un List d'objets correspondant aux colonnes).
L'interface présente une seule méthode : Object handle(java.sql.ResultSet rs). Ainsi toutes les implémentations de ResultSetHandler acceptent en paramètre un ResultSet et renvoient un java.lang.Object. Par conséquent, exception faite des types primitifs, il n'y a pas de restriction sur ce qui peut être retourné par votre implémentation de l'interface.

Cette classe permet le chargement d'une Map contenant les différentes requêtes SQL à partir d'un fichier properties. Cette externalisation de vos requêtes permet d'en faciliter des éventuelles optimisations. Cette Map ne doit pas être demandée par un chemin de fichier système, mais comme une ressource du jar de l'application. Cette classe est un singleton qui s'utilise comme un registre pour vos requêtes. Les deux méthodes intéressantes de cette classe sont :

• instance() : cette méthode statique permet de récupérer le QueryLoader ;
• load(java.lang.String path) : cette méthode renvoie la Map de requête qui est chargée à partir du fichier properties situé à l'adresse path. Ainsi pour le fichier queries.properties qui se trouve dans le package « mon.package.jdbc », le chemin est « /mon/package/jdbc/queries.properties ».

Cette classe simplifie l'exécution de la requête. En association avec un ResultSetHandler, elle permet de réduire considérablement le code nécessaire. Cette classe dispose de deux constructeurs. Le premier est un constructeur sans argument, le second prend un javax.sql.DataSource en paramètre. Si vous ne fournissez pas de Connection comme argument à une méthode, le DataSource fourni au constructeur est utilisé pour l'obtention d'une nouvelle connexion. Le DataSource peut aussi être paramétré avec la méthode setDataSource().
Les méthodes importantes de cette classe sont :

• query(Connection conn, String requête, ResultSetHandler rsh) : cette méthode exécute une requête de type SELECT. La méthode gère la création et la fermeture du PreparedStatement et du ResultSet. Le ResultSetHandler est responsable de la conversion du ResultSet en objet plus simple d'utilisation pour le reste de l'application. Il existe une méthode sans paramètre Connection qui utilise alors le DataSource pour l'obtention de la connexion à la base de données ;
• query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) : c'est le même type de méthodes, mais gérant une requête où les valeurs du tableau d'Object sont utilisées comme paramètres de la requête. De même, il existe une version sans le paramètre Connection ;
• update(Connection conn, String sql, Objet[] params) : cette méthode est utilisée pour exécuter des requêtes de type INSERT, UPDATE ou DELETE. Le tableau d'Object contient les paramètres de remplacement pour la requête.

Sur la base de données MySQL, le tutoriel utilise une base appelée « base » avec un user « user » et un password « password ». La base contient une table « eleve » avec trois champs

III-B-1. La classe de test▲

package tuto.dbutils;

import java.io.IOException;
import java.sql.*;
import java.util.*;
import org.apache.commons.dbutils.*;
import org.apache.commons.dbutils.handlers.*;

public class DbUtilsUse {

    public static void main(String[] args) {
        Connection conn = null;
        String jdbcURL = "jdbc:mysql://localhost:3306/base";
        String jdbcDriver = "org.gjt.mm.mysql.Driver";

        //chargement du Driver
        boolean connect;
        connect=DbUtils.loadDriver(jdbcDriver);
        if(!connect){
            //pas de Driver on s'arrête
            System.out.println("Driver absent.");
            System.exit(0) ;
        }
        try {
            //établissement de la connexion au SGBD
            conn = DriverManager.getConnection(jdbcURL, "user", "password");
        } catch (SQLException e1) {
            e1.printStackTrace();
        }
        //préparation d'un gestionnaire de requête
        QueryRunner qRunner = new QueryRunner();

        //utilisation simple avec un ArrayList
        List list1 = new ArrayList();
        try {
            list1 =
                (List) qRunner.query(
                    conn,
                    "select * from eleve",
                    new ArrayListHandler());
        } catch (SQLException e2) {
            e2.printStackTrace();
        }
        //affichage du résultat
        System.out.println("en ArrayList");
        for (int i = 0; i < list1.size(); i++) {
            Object data[] = (Object[]) list1.get(i);
            System.out.println("\t"+data[0]+" -> "+data[1]+" -> "+data[2]);
        }

        //chargement d'un Map de requêtes        
        QueryLoader qLoad = QueryLoader.instance();
        Map mapQuery = new HashMap();
        try {
            mapQuery = qLoad.load("/tuto/dbUtils/queries.properties");
            System.out.println("map chargée");
        } catch (IOException e) {
            e.printStackTrace();
        }

        //utilisation d'une requête à paramètre depuis le mapQuery
        //utilisation d'un ArrayHandler car il n'y a qu'un résultat
        Object reponse[] = new Object[3];
        String param="14";
        try {
            reponse =
                (Object[]) qRunner.query(
                    conn,
                    (String) mapQuery.get("param"),
                    param,
                    new ArrayHandler());
        } catch (SQLException e3) {
            e3.printStackTrace();
        }
        //affichage du résultat.
        System.out.println("Requete avec parametre");
        System.out.println("\t"+reponse[0]+" -> "+reponse[1]+" -> "+reponse[2]);

        //utilisation d'un Bean
        List lBeans= new ArrayList();
        try {
            lBeans =
                (List) qRunner.query(
                    conn,
                    (String) mapQuery.get("duplike"),
                    new BeanListHandler(EleveBean.class));
        } catch (SQLException e4) {
            e4.printStackTrace();
        }
        //affichage du résultat
        System.out.println("requete avec Bean");
        for (int i = 0; i < lBeans.size(); i++) {
            EleveBean eleve = (EleveBean) lBeans.get(i);
            System.out.println("\t"+eleve.getNom()+" -> "+eleve.getAge());
                
        }
        //fermeture silencieuse de la connexion
        DbUtils.closeQuietly(conn);
    }
}

III-B-2. Le Bean▲

package tuto.dbutils;

public class EleveBean {

    private String nom;
    private int age;
    private String classe;
    
    public EleveBean(){
    }
    public String getNom() {
        return nom;
    }
    public int getAge() {
        return age;
    }
    public String getClasse(){
        return classe;
    }
    public void setNom(String s) {
        nom = s;
    }
    public void setAge(int i) {
        age = i;
    }
    public void setClasse(String s){
        classe = s;
    }
}

III-B-3. Le fichier queries.properties▲

duplike=select * from eleve where nom like 'dup%';
param=select * from eleve where age=?;

III-B-4. Explications▲